Changeset 1362 for branches/New Persistence Exploration/Persistence

Timestamp:

03/19/09 14:02:35 (16 years ago)

Author:

epitzer

Message:

Add serializer class information to type cache. (#506)

Location:

branches/New Persistence Exploration/Persistence

Files:

• Persistence/Core/DeSerializer.cs (modified) (6 diffs)
• Persistence/Core/Serializer.cs (modified) (2 diffs)
• Persistence/Default/Xml/XmlGenerator.cs (modified) (2 diffs)
• Persistence/Default/Xml/XmlParser.cs (modified) (2 diffs)
• Test/NewSerializationTest.cs (modified) (2 diffs)

branches/New Persistence Exploration/Persistence/Persistence/Core/DeSerializer.cs

@@ -75 +75 @@
 
     private readonly Dictionary<int, object> id2obj;
+    private readonly Dictionary<Type, object> serializerMapping;
     private readonly Dictionary<Type, Handler> handlers;
-    private readonly Stack<IAccessibleObject> parentStack;
-    private readonly Configuration configuration;
+    private readonly Stack<IAccessibleObject> parentStack;    
     private readonly Dictionary<int, Type> typeIds;    
     private List<Thunk> finalFixes;
 
     public DeSerializer(
-      IEnumerable<KeyValuePair<string, int>> typeCache,
-      Configuration configuration) {
-      this.configuration = configuration;
+      IEnumerable<TypeMapping> typeCache) {      
       id2obj = new Dictionary<int, object>();
       parentStack = new Stack<IAccessibleObject>();
@@ -95 +93 @@
                    };      
       typeIds = new Dictionary<int, Type>();
-      foreach ( var pair in typeCache ) {
-        Type type = Type.GetType(pair.Key);
-        typeIds.Add(pair.Value, type);
+      serializerMapping = new Dictionary<Type, object>();
+      foreach ( var typeMapping in typeCache ) {
+        Type type = Type.GetType(typeMapping.TypeName);
+        typeIds.Add(typeMapping.Id, type);
+        if (typeMapping.Serializer != null) {
+          Type serializerType = Type.GetType(typeMapping.Serializer);
+          serializerMapping.Add(type, Activator.CreateInstance(serializerType, true));
+        }
       }
     }
@@ -116 +119 @@
       object instance;      
       Type type = typeIds[(int)start.TypeId];
-      if (configuration.GetDecomposer(type) != null) {
+      IDecomposer decomposer = null;
+      if ( serializerMapping.ContainsKey(type) )
+        decomposer = serializerMapping[type] as IDecomposer;      
+      if (decomposer != null) {
         instance = new ParentReference();
         parentStack.Push(new CustomComposite(instance));        
@@ -132 +138 @@
       EndToken end = (EndToken)token;
       Type type = typeIds[(int)end.TypeId];
-      IDecomposer decomposer = configuration.GetDecomposer(type);
+      IDecomposer decomposer = null;
+      if (serializerMapping.ContainsKey(type))
+        decomposer = serializerMapping[type] as IDecomposer;            
       if (decomposer != null) {
         CustomComposite customComposite = (CustomComposite)parentStack.Pop();
@@ -150 +158 @@
       PrimitiveToken primitive = (PrimitiveToken)token;
       Type type = typeIds[(int)primitive.TypeId];
-      object value = configuration
-        .GetFormatter(type)
-        .Parse(primitive.SerialData);
+      object value = ((IFormatter) serializerMapping[type]).Parse(primitive.SerialData);
       if ( ! value.GetType().IsValueType )
         id2obj[(int)primitive.Id] = value;
@@ -172 +178 @@
       NullReferenceToken nil = (NullReferenceToken)token;
       SetValue(nil.Name, null);
-    }
+    }    
 
     private void SetValue(string name, object value) {

branches/New Persistence Exploration/Persistence/Persistence/Core/Serializer.cs

@@ -5 +5 @@
 
 namespace HeuristicLab.Persistence.Core {
+
+  public struct TypeMapping {
+    public readonly int Id;
+    public readonly string TypeName;
+    public readonly string Serializer;    
+    public TypeMapping(int id, string typeName, string serializer) {
+      Id = id;
+      TypeName = typeName;
+      Serializer = serializer;
+    }
+    public Dictionary<string, object> GetDict() {
+      return new Dictionary<string, object> {
+        {"id", Id},
+        {"typeName", TypeName},
+        {"serializer", Serializer}};                                            
+    }
+  }
 
   public class Serializer : IEnumerable<ISerializationToken> {
@@ -14 +31 @@
     private readonly Configuration configuration;
 
-    public Dictionary<string, int> TypeCache {
+    public List<TypeMapping> TypeCache {
       get {        
-        Dictionary<string, int> result = new Dictionary<string, int>();
-        foreach ( var pair in typeCache )
-          result.Add(pair.Key.AssemblyQualifiedName, pair.Value);
+        List<TypeMapping> result = new List<TypeMapping>();
+        foreach (var pair in typeCache) {
+          string serializer = null;
+          IFormatter f = configuration.GetFormatter(pair.Key);
+          if (f != null) {
+            serializer = f.GetType().AssemblyQualifiedName;
+          } else {
+            IDecomposer d = configuration.GetDecomposer(pair.Key);
+            if (d != null)
+              serializer = d.GetType().AssemblyQualifiedName;
+          }
+          result.Add(new TypeMapping(pair.Value, pair.Key.AssemblyQualifiedName, serializer));
+        }
         return result;                                     
       }

branches/New Persistence Exploration/Persistence/Persistence/Default/Xml/XmlGenerator.cs

@@ -3 +3 @@
 using System.Text;
 using HeuristicLab.Persistence.Interfaces;
+using HeuristicLab.Persistence.Core;
 
 namespace HeuristicLab.Persistence.Default.Xml {
@@ -108 +109 @@
     }
 
-    public IEnumerable<string> Format(Dictionary<string, int> typeCache) {
+    public IEnumerable<string> Format(List<TypeMapping> typeCache) {
       yield return "<" + XmlStrings.TYPECACHE + ">";
-      foreach ( var pair in typeCache )
-        yield return FormatNode(XmlStrings.TYPE,
-                                new Dictionary<string, object> {{"id", pair.Value}, {"name", pair.Key}},
-                                NodeType.Inline);        
+      foreach (var mapping in typeCache)
+        yield return FormatNode(XmlStrings.TYPE, mapping.GetDict(), NodeType.Inline);                                
       yield return "</" + XmlStrings.TYPECACHE + ">";
     }

branches/New Persistence Exploration/Persistence/Persistence/Default/Xml/XmlParser.cs

@@ -4 +4 @@
 using System.Collections;
 using System.IO;
+using HeuristicLab.Persistence.Core;
 using HeuristicLab.Persistence.Interfaces;
 
 namespace HeuristicLab.Persistence.Default.Xml {
-
 
   public class XmlParser : IEnumerable<ISerializationToken> {
@@ -91 +91 @@
     }
 
-    public static Dictionary<string, int> ParseTypeCache(TextReader reader) {
-      Dictionary<string, int> typeCache = new Dictionary<string, int>();
+    public static List<TypeMapping> ParseTypeCache(TextReader reader) {
+      var typeCache = new List<TypeMapping>();
       XmlReader xmlReader = XmlReader.Create(reader);
       while ( xmlReader.Read() ) {
-        if (xmlReader.Name == XmlStrings.TYPE) {          
-          typeCache.Add(xmlReader.GetAttribute("name")
-          , int.Parse(xmlReader.GetAttribute("id")));
+        if (xmlReader.Name == XmlStrings.TYPE) {
+          typeCache.Add(new TypeMapping(
+            int.Parse(xmlReader.GetAttribute("id")),
+            xmlReader.GetAttribute("typeName"),
+            xmlReader.GetAttribute("serializer")));
         }
       }

branches/New Persistence Exploration/Persistence/Test/NewSerializationTest.cs

@@ -172 +172 @@
       XmlParser parser = new XmlParser(new StreamReader("test.xml"));
       DeSerializer deSerializer = new DeSerializer(
-        XmlParser.ParseTypeCache(new StreamReader("test-types.xml")),
-        ConfigurationService.Instance.GetDefaultConfig(XmlFormat.Instance));        
+        XmlParser.ParseTypeCache(new StreamReader("test-types.xml")));        
       object o = deSerializer.DeSerialize(parser);      
       Console.Out.WriteLine(Util.AutoFormat(o, true));      
@@ -192 +191 @@
       XmlParser parser = new XmlParser(new StreamReader("test2.xml"));
       DeSerializer deSerializer = new DeSerializer(
-        XmlParser.ParseTypeCache(new StreamReader("test-types.xml")),
-        ConfigurationService.Instance.GetDefaultConfig(XmlFormat.Instance));        
+        XmlParser.ParseTypeCache(new StreamReader("test-types.xml")));        
       object o = deSerializer.DeSerialize(parser);      
       Console.Out.WriteLine(Util.AutoFormat(o, true));