Changeset 6737 for branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Core/DeSerializer.cs

Timestamp:

09/12/11 10:12:50 (13 years ago)

Author:

epitzer

Message:

#1530 Split type and serializer tokens and include special handling for CachedTypeSerializer (this should also fix #1527)

File:

• branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Core/DeSerializer.cs (modified) (9 diffs)

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Core/DeSerializer.cs

@@ -32 +32 @@
   /// instantiates objects and fills in values.
   /// </summary>
-  public class Deserializer {
+  public sealed class Deserializer {
 
     /// <summary>
@@ -40 +40 @@
     private class Midwife {
 
+      public string Name { get; private set; }
       public int? Id { get; private set; }
       public bool MetaMode { get; set; }
@@ -53 +54 @@
       }
 
-      public Midwife(Type type, ICompositeSerializer compositeSerializer, int? id) {
+      public Midwife(Type type, ICompositeSerializer compositeSerializer, int? id, string name) {
         this.type = type;
         this.compositeSerializer = compositeSerializer;
         this.Id = id;
+        this.Name = name;
         MetaMode = false;
         metaInfo = new List<Tag>();
@@ -82 +84 @@
 
     private readonly Dictionary<int, object> id2obj;
-    private readonly Dictionary<Type, object> serializerMapping;
     private readonly Stack<Midwife> parentStack;
-    private readonly Dictionary<int, Type> typeIds;
-    private Dictionary<Type, object> serializerInstances;
+    private ReverseTypeCache typeCache;
 
     /// <summary>
@@ -93 +93 @@
     /// </summary>
     /// <param name="typeCache">The type cache.</param>
-    public Deserializer(
-      IEnumerable<TypeMapping> typeCache) {
+    public Deserializer(ReverseTypeCache typeCache) {
+      this.typeCache = typeCache;
       id2obj = new Dictionary<int, object>();
       parentStack = new Stack<Midwife>();
-      typeIds = new Dictionary<int, Type>();
-      serializerMapping = new Dictionary<Type, object>();
-      serializerInstances = new Dictionary<Type, object>();
-      foreach (var typeMapping in typeCache) {
-        AddTypeInfo(typeMapping);
-      }
-    }
-
-    /// <summary>
-    /// Adds additionaly type information.
-    /// </summary>
-    /// <param name="typeMapping">The new type mapping.</param>
-    public void AddTypeInfo(TypeMapping typeMapping) {
-      if (typeIds.ContainsKey(typeMapping.Id))
-        return;
-      try {
-        Type type = TypeLoader.Load(typeMapping.TypeName);
-        typeIds.Add(typeMapping.Id, type);
-        Type serializerType = TypeLoader.Load(typeMapping.Serializer);
-        object serializer;
-        if (serializerInstances.ContainsKey(serializerType)) {
-          serializer = serializerInstances[serializerType];
-        } else {
-          serializer = Activator.CreateInstance(serializerType, true);
-          serializerInstances.Add(serializerType, serializer);
-        }
-        serializerMapping.Add(type, serializer);
-      } catch (PersistenceException) {
-        throw;
-      } catch (Exception e) {
-        throw new PersistenceException(string.Format(
-          "Could not add type info for {0} ({1})",
-          typeMapping.TypeName, typeMapping.Serializer), e);
-      }
     }
 
@@ -157 +123 @@
         } else if (t == typeof(TypeToken)) {
           Type((TypeToken)token);
+        } else if (t == typeof(SerializerToken)) {
+          Serializer((SerializerToken)token);
         } else {
           throw new PersistenceException("invalid token type");
@@ -173 +141 @@
 
     private void Type(TypeToken token) {
-      AddTypeInfo(new TypeMapping(token.Id, token.TypeName, token.Serializer));
+      typeCache.AddType(token.Id, TypeLoader.Load(token.TypeName));
+    }
+
+    private void Serializer(SerializerToken token) {
+      typeCache.AddSerializer(token.Id, TypeLoader.Load(token.Serializer));
     }
 
     private void CompositeStartHandler(BeginToken token) {
       InstantiateParent();
-      Type type = typeIds[(int)token.TypeId];
+      Type type = typeCache.GetType(token.TypeId);
       try {
-        parentStack.Push(new Midwife(type, (ICompositeSerializer)serializerMapping[type], token.Id));
+        parentStack.Push(new Midwife(type, typeCache.GetCompositeSerializer(token.TypeId), token.Id, token.Name));
       } catch (Exception e) {
         if (e is InvalidCastException || e is KeyNotFoundException) {
@@ -195 +167 @@
 
     private void CompositeEndHandler(EndToken token) {
-      Type type = typeIds[(int)token.TypeId];
       Midwife midwife = parentStack.Pop();
       if (midwife.Obj == null)
         CreateInstance(midwife);
       midwife.Populate();
-      SetValue(token.Name, midwife.Obj);
+      SetValue(midwife.Name, midwife.Obj);
     }
 
     private void PrimitiveHandler(PrimitiveToken token) {
-      Type type = typeIds[(int)token.TypeId];
       try {
-        object value = ((IPrimitiveSerializer)serializerMapping[type]).Parse(token.SerialData);
+        object value = typeCache.GetPrimitiveSerializer(token.TypeId).Parse(token.SerialData);
         if (token.Id != null)
           id2obj[(int)token.Id] = value;
@@ -214 +184 @@
           throw new PersistenceException(String.Format(
             "Invalid primitive serializer configuration for type \"{0}\".",
-            type.AssemblyQualifiedName), e);
+            typeCache.GetType(token.TypeId).AssemblyQualifiedName), e);
         } else {
           throw new PersistenceException(String.Format(
             "Unexpected exception while trying to parse object of type \"{0}\".",
-            type.AssemblyQualifiedName), e);
+            typeCache.GetType(token.TypeId).AssemblyQualifiedName), e);
         }
       }