Changeset 5290

Timestamp:

01/13/11 13:01:28 (14 years ago)

Author:

epitzer

Message:

Added custom serializers for generic HashSets and Dictionaries that include the Comparer property (#1375)

Location:

trunk/sources/HeuristicLab.Persistence/3.3

Files:

• Default/CompositeSerializers/ConcreteDictionarySerializer.cs (copied) (copied from trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/DictionarySerializer.cs) (5 diffs)
• Default/CompositeSerializers/HashSetSerializer.cs (copied) (copied from trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/EnumerableSerializer.cs) (4 diffs)
• HeuristicLab.Persistence-3.3.csproj (modified) (1 diff)
• Tests/UseCases.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/ConcreteDictionarySerializer.cs

@@ -23 +23 @@
 using System.Collections;
 using System.Collections.Generic;
-using HeuristicLab.Persistence.Auxiliary;
+using System.Linq;
 using HeuristicLab.Persistence.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -31 +31 @@
 
   [StorableClass]
-  internal sealed class DictionarySerializer : ICompositeSerializer {
+  internal sealed class ConcreteDictionarySerializer : ICompositeSerializer {
 
     [StorableConstructor]
-    private DictionarySerializer(bool deserializing) { }
-    public DictionarySerializer() { }
+    private ConcreteDictionarySerializer(bool deserializing) { }
+    public ConcreteDictionarySerializer() { }
 
     public int Priority {
@@ -43 +43 @@
 
     public bool CanSerialize(Type type) {
-      return ReflectionTools.HasDefaultConstructor(type) &&
-        type.GetInterface(typeof(IDictionary).FullName) != null;
+      return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<,>);
     }
 
     public string JustifyRejection(Type type) {
-      if (!ReflectionTools.HasDefaultConstructor(type))
-        return "no default constructor";
-      return "interface IDictionary not implemented";
+      return "Type is not a generic Dictionary<>";
     }
 
     public IEnumerable<Tag> CreateMetaInfo(object o) {
-      return new Tag[] { };
+      yield return new Tag("Comparer", o.GetType().GetProperty("Comparer").GetValue(o, null));
     }
 
@@ -66 +63 @@
 
     public object CreateInstance(Type t, IEnumerable<Tag> metaInfo) {
-      return Activator.CreateInstance(t, true);
+      return Activator.CreateInstance(t, metaInfo.First().Value);
     }
 
@@ -79 +76 @@
           dict.Add(key.Value, value.Value);
         }
-      }
-      catch (InvalidOperationException e) {
+      } catch (InvalidOperationException e) {
         throw new PersistenceException("Dictionaries must contain an even number of elements (key+value).", e);
-      }
-      catch (NotSupportedException e) {
+      } catch (NotSupportedException e) {
         throw new PersistenceException("The serialized dictionary type was read-only or had a fixed size and cannot be deserialized.", e);
-      }
-      catch (ArgumentNullException e) {
+      } catch (ArgumentNullException e) {
         throw new PersistenceException("Dictionary key was null.", e);
-      }
-      catch (ArgumentException e) {
+      } catch (ArgumentException e) {
         throw new PersistenceException("Duplicate dictionary key.", e);
       }

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/HashSetSerializer.cs

@@ -23 +23 @@
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
-using HeuristicLab.Persistence.Auxiliary;
 using HeuristicLab.Persistence.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -32 +32 @@
 
   [StorableClass]
-  internal sealed class EnumerableSerializer : ICompositeSerializer {
+  internal sealed class HashSetSerializer : ICompositeSerializer {
 
     [StorableConstructor]
-    private EnumerableSerializer(bool deserializing) { }
-    public EnumerableSerializer() { }
+    private HashSetSerializer(bool deserializing) { }
+    public HashSetSerializer() { }
 
     public int Priority {
-      get { return 100; }
+      get { return 250; }
     }
 
-
     public bool CanSerialize(Type type) {
-      return
-        ReflectionTools.HasDefaultConstructor(type) &&
-        type.GetInterface(typeof(IEnumerable).FullName) != null &&
-        type.GetMethod("Add") != null &&
-        type.GetMethod("Add").GetParameters().Length == 1;
+      return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(HashSet<>);
     }
 
     public string JustifyRejection(Type type) {
-      if (!ReflectionTools.HasDefaultConstructor(type))
-        return "no default constructor";
-      if (type.GetInterface(typeof(IEnumerable).FullName) == null)
-        return "interface IEnumerable not implemented";
-      if (type.GetMethod("Add") == null)
-        return "no 'Add()' method";
-      return "no 'Add()' method with one argument";
+      return "Type is not a generic HashSet<>";
     }
 
     public IEnumerable<Tag> CreateMetaInfo(object o) {
-      return new Tag[] { };
+      yield return new Tag("Comparer", o.GetType().GetProperty("Comparer").GetValue(o, null));
     }
 
@@ -72 +61 @@
 
     public object CreateInstance(Type type, IEnumerable<Tag> metaInfo) {
-      return Activator.CreateInstance(type, true);
+      return Activator.CreateInstance(type, metaInfo.First().Value);
     }
 
@@ -80 +69 @@
         foreach (var tag in tags)
           addMethod.Invoke(instance, new[] { tag.Value });
-      }
-      catch (Exception e) {
+      } catch (Exception e) {
         throw new PersistenceException("Exception caught while trying to populate enumerable.", e);
       }
     }
+
+    public object HashSet { get; set; }
   }
 }

trunk/sources/HeuristicLab.Persistence/3.3/HeuristicLab.Persistence-3.3.csproj

@@ -141 +141 @@
     <Compile Include="Default\CompositeSerializers\ArraySerializer.cs" />
     <Compile Include="Default\CompositeSerializers\CompactNumberArray2StringSerializer.cs" />
+    <Compile Include="Default\CompositeSerializers\ConcreteDictionarySerializer.cs" />
+    <Compile Include="Default\CompositeSerializers\HashSetSerializer.cs" />
     <Compile Include="Default\CompositeSerializers\DictionarySerializer.cs" />
     <Compile Include="Default\CompositeSerializers\EnumerableSerializer.cs" />

trunk/sources/HeuristicLab.Persistence/3.3/Tests/UseCases.cs

@@ -1102 +1102 @@
       }
     }
+    private class IdentityComparer<T> : IEqualityComparer<T> {
+
+      public bool Equals(T x, T y) {
+        return x.Equals(y);
+      }
+
+      public int GetHashCode(T obj) {
+        return obj.GetHashCode();
+      }
+    }
+
+    [TestMethod]
+    public void TestHashSetSerializer() {
+      var hashSets = new List<HashSet<int>>() {
+        new HashSet<int>(new[] { 1, 2, 3 }),
+        new HashSet<int>(new[] { 4, 5, 6 }, new IdentityComparer<int>()),
+      };
+      XmlGenerator.Serialize(hashSets, tempFile);
+      var newHashSets = XmlParser.Deserialize<List<HashSet<int>>>(tempFile);
+      Assert.IsTrue(newHashSets[0].Contains(1));
+      Assert.IsTrue(newHashSets[0].Contains(2));
+      Assert.IsTrue(newHashSets[0].Contains(3));
+      Assert.IsTrue(newHashSets[1].Contains(4));
+      Assert.IsTrue(newHashSets[1].Contains(5));
+      Assert.IsTrue(newHashSets[1].Contains(6));
+      Assert.AreEqual(newHashSets[0].Comparer.GetType(), new HashSet<int>().Comparer.GetType());
+      Assert.AreEqual(newHashSets[1].Comparer.GetType(), typeof(IdentityComparer<int>));
+    }
+
+    [TestMethod]
+    public void TestConcreteDictionarySerializer() {
+      var dictionaries = new List<Dictionary<int, int>>() {
+        new Dictionary<int, int>(),
+        new Dictionary<int, int>(new IdentityComparer<int>()),
+      };
+      dictionaries[0].Add(1, 1);
+      dictionaries[0].Add(2, 2);
+      dictionaries[0].Add(3, 3);
+      dictionaries[1].Add(4, 4);
+      dictionaries[1].Add(5, 5);
+      dictionaries[1].Add(6, 6);
+      XmlGenerator.Serialize(dictionaries, tempFile);
+      var newDictionaries = XmlParser.Deserialize<List<Dictionary<int, int>>>(tempFile);
+      Assert.IsTrue(newDictionaries[0].ContainsKey(1));
+      Assert.IsTrue(newDictionaries[0].ContainsKey(2));
+      Assert.IsTrue(newDictionaries[0].ContainsKey(3));
+      Assert.IsTrue(newDictionaries[1].ContainsKey(4));
+      Assert.IsTrue(newDictionaries[1].ContainsKey(5));
+      Assert.IsTrue(newDictionaries[1].ContainsKey(6));
+      Assert.IsTrue(newDictionaries[0].ContainsValue(1));
+      Assert.IsTrue(newDictionaries[0].ContainsValue(2));
+      Assert.IsTrue(newDictionaries[0].ContainsValue(3));
+      Assert.IsTrue(newDictionaries[1].ContainsValue(4));
+      Assert.IsTrue(newDictionaries[1].ContainsValue(5));
+      Assert.IsTrue(newDictionaries[1].ContainsValue(6));
+      Assert.AreEqual(newDictionaries[0].Comparer.GetType(), new Dictionary<int, int>().Comparer.GetType());
+      Assert.AreEqual(newDictionaries[1].Comparer.GetType(), typeof(IdentityComparer<int>));
+    }
 
     [ClassInitialize]