Changeset 1679

Timestamp:

04/27/09 18:36:06 (15 years ago)

Author:

epitzer

Message:

Persistence fixes: Honor Storable.Name property, add more formatters and decomposers needed for HL integration. (#603)

Location:

trunk/sources/HeuristicLab.Persistence

Files:

• 3.3/Core/Serializer.cs (modified) (1 diff)
• 3.3/Default/Decomposers/EnumerableDecomposer.cs (modified) (1 diff)
• 3.3/Default/Decomposers/Storable/StorableDecomposer.cs (modified) (2 diffs)
• 3.3/Default/Xml/Primitive/String2XmlFormatter.cs (modified) (1 diff)
• UnitTests/UseCases.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.Persistence/3.3/Core/Serializer.cs

@@ -28 +28 @@
           } else {
             IDecomposer d = configuration.GetDecomposer(pair.Key);
-            if (d != null)
-              serializer = d.GetType().VersionInvariantName();
+            serializer = d.GetType().VersionInvariantName();
           }
           result.Add(new TypeMapping(pair.Value, pair.Key.VersionInvariantName(), serializer));

trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/EnumerableDecomposer.cs

@@ -53 +53 @@
     }
   }
+
+
+  [EmptyStorableClass]
+  public class StackDecomposer : IDecomposer {
+
+    public int Priority {
+      get { return 100; }
+    }
+
+
+    public bool CanDecompose(Type type) {
+      return type.IsGenericType &&
+        type.GetGenericTypeDefinition() == typeof(Stack<>);        
+    }
+
+    public IEnumerable<Tag> CreateMetaInfo(object o) {
+      return new Tag[] { };
+    }
+
+    public IEnumerable<Tag> Decompose(object obj) {
+      foreach (object o in (IEnumerable)obj) {
+        yield return new Tag(null, o);
+      }
+    }
+
+    public object CreateInstance(Type type, IEnumerable<Tag> metaInfo) {
+      return Activator.CreateInstance(type, true);
+    }
+
+    public void Populate(object instance, IEnumerable<Tag> tags, Type type) {      
+      MethodInfo addMethod = type.GetMethod("Push");      
+      try {
+        foreach (var tag in tags)
+          addMethod.Invoke(instance, new[] { tag.Value });
+      } catch (Exception e) {
+        throw new PersistenceException("Exception caught while trying to populate enumerable.", e);
+      }
+    }
+  }
 }

trunk/sources/HeuristicLab.Persistence/3.3/Default/Decomposers/Storable/StorableDecomposer.cs

@@ -26 +26 @@
     public IEnumerable<Tag> Decompose(object obj) {
       foreach (var mapping in StorableAttribute.GetStorableAccessors(obj)) {
-        yield return new Tag(mapping.Key, mapping.Value.Get());
+        yield return new Tag(mapping.Value.Name ?? mapping.Key, mapping.Value.Get());        
       }
     }
@@ -41 +41 @@
       }
       foreach (var mapping in StorableAttribute.GetStorableAccessors(instance)) {
-        if (memberDict.ContainsKey(mapping.Key)) {
-          mapping.Value.Set(memberDict[mapping.Key].Value);
+        string name = mapping.Value.Name ?? mapping.Key;
+        if (memberDict.ContainsKey(name)) {
+          mapping.Value.Set(memberDict[name].Value);
         } else if (mapping.Value.DefaultValue != null) {
           mapping.Value.Set(mapping.Value.DefaultValue);

trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/String2XmlFormatter.cs

@@ -5 +5 @@
 using System.Text.RegularExpressions;
 using HeuristicLab.Persistence.Default.Decomposers.Storable;
+using System.Globalization;
 
 
 namespace HeuristicLab.Persistence.Default.Xml.Primitive {
+
+  [EmptyStorableClass]
+  public class TimeSpan2XmlFormatter : PrimitiveXmlFormatterBase<TimeSpan> {
+
+    public override XmlString Format(TimeSpan o) {
+      return new XmlString(o.ToString());
+    }
+
+    public override TimeSpan Parse(XmlString t) {
+      try {
+        return TimeSpan.Parse(t.Data);
+      } catch (FormatException x) {
+        throw new PersistenceException("Cannot parse TimeSpan string representation.", x);
+      } catch (OverflowException x) {
+        throw new PersistenceException("Overflow during TimeSpan parsing.", x);
+      }
+    }
+  }
+
+  [EmptyStorableClass]
+  public class Guid2XmlFormatter : PrimitiveXmlFormatterBase<Guid> {
+
+    public override XmlString Format(Guid o) {
+      return new XmlString(o.ToString("D", CultureInfo.InvariantCulture));
+    }
+
+    public override Guid Parse(XmlString t) {
+      try {
+        return new Guid(t.Data);
+      } catch (FormatException x) {
+        throw new PersistenceException("Cannot parse Guid string representation.", x);
+      } catch (OverflowException x) {
+        throw new PersistenceException("Overflow during Guid parsing.", x);
+      }
+    }
+  }
 
   [EmptyStorableClass]

trunk/sources/HeuristicLab.Persistence/UnitTests/UseCases.cs

@@ -62 +62 @@
     [Storable]
     public int[] i = new[] { 3, 4, 5, 6 };
-    [Storable]
+    [Storable(Name="Test String")]
     public string s;
     [Storable]
@@ -126 +126 @@
 
     [TestCleanup()]
-    public void ClearTempFile() {
+    public void ClearTempFile() {      
       File.Delete(tempFile);
     }