Changeset 3005 for trunk/sources/HeuristicLab.Persistence/3.3/Core

Timestamp:

03/11/10 15:50:50 (15 years ago)

Author:

epitzer

Message:

add support for type information interleaving and subsequently true streaming (#548)

Location:

trunk/sources/HeuristicLab.Persistence/3.3/Core

Files:

• DeSerializer.cs (modified) (3 diffs)
• GeneratorBase.cs (modified) (2 diffs)
• Serializer.cs (modified) (5 diffs)
• Tokens/TypeToken.cs (added)

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

@@ -77 +77 @@
       parentStack = new Stack<Midwife>();
       typeIds = new Dictionary<int, Type>();
-      serializerMapping = CreateSerializers(typeCache);
-    }
-
-    private Dictionary<Type, object> CreateSerializers(IEnumerable<TypeMapping> typeCache) {
-      Dictionary<Type, object> serializerInstances = new Dictionary<Type, object>();
+      serializerMapping = new Dictionary<Type, object>();
+      foreach (var typeMapping in typeCache) {
+        AddTypeInfo(typeMapping);
+      }
+    }
+
+    private Dictionary<Type, object> serializerInstances = new Dictionary<Type, object>();    
+
+    public void AddTypeInfo(TypeMapping typeMapping) {
+      if (typeIds.ContainsKey(typeMapping.Id))
+        return;
       try {
-        var map = new Dictionary<Type, object>();
-        foreach (var typeMapping in typeCache) {
-          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);
-          map.Add(type, serializer);
-        }
-        return map;
+        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);
+        serializerMapping.Add(type, serializer);
       } catch (PersistenceException) {
         throw;
       } catch (Exception e) {
-        throw new PersistenceException(
-          "The serialization type cache could not be loaded.\r\n" +
-          "This usualy happens when you are missing an Assembly or Plugin.", e);
+        throw new PersistenceException(string.Format(
+          "Could not add type info for {0} ({1})",
+          typeMapping.TypeName, typeMapping.Serializer), e);
       }
     }
@@ -125 +127 @@
         } else if (t == typeof(MetaInfoEndToken)) {
           MetaInfoEnd((MetaInfoEndToken)token);
+        } else if (t == typeof(TypeToken)) {
+          Type((TypeToken)token);
         } else {
           throw new PersistenceException("invalid token type");
@@ -138 +142 @@
       if (!m.MetaMode && m.Obj == null)
         CreateInstance(m);
+    }
+
+    private void Type(TypeToken token) {
+      AddTypeInfo(new TypeMapping(token.Id, token.TypeName, token.Serializer));
     }
 

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

@@ -34 +34 @@
       if (type == typeof(MetaInfoEndToken))
         return Format((MetaInfoEndToken)token);
+      if (type == typeof(TypeToken))
+        return Format((TypeToken)token);
       throw new ApplicationException("Invalid token of type " + type.FullName);
     }
@@ -44 +46 @@
     protected abstract T Format(MetaInfoBeginToken metaInfoBeginToken);
     protected abstract T Format(MetaInfoEndToken metaInfoEndToken);
+    protected abstract T Format(TypeToken typeToken);
 
   }

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

@@ -49 +49 @@
     private readonly bool isTestRun;
     private readonly List<Exception> exceptions;
+
+    public bool InterleaveTypeInformation { get; set; }
 
     /// <summary>
@@ -106 +108 @@
     /// don't stop at the first exception</param>
     public Serializer(object obj, Configuration configuration, string rootName, bool isTestRun) {
+      this.InterleaveTypeInformation = false;
       this.obj = obj;
       this.rootName = rootName;
@@ -144 +147 @@
       if (obj2id.ContainsKey(value))
         return ReferenceEnumerator(accessor.Name, obj2id[value]);
-      if (!typeCache.ContainsKey(type))
+      bool emitTypeInfo = false;
+      if (!typeCache.ContainsKey(type)) {
         typeCache.Add(type, typeCache.Count);
+        emitTypeInfo = InterleaveTypeInformation;
+      }
       int typeId = typeCache[type];
       int? id = null;
@@ -155 +161 @@
         IPrimitiveSerializer primitiveSerializer = configuration.GetPrimitiveSerializer(type);
         if (primitiveSerializer != null)
-          return PrimitiveEnumerator(accessor.Name, typeId, primitiveSerializer.Format(value), id);
+          return PrimitiveEnumerator(
+            accessor.Name,
+            typeId,
+            primitiveSerializer.Format(value),
+            id,
+            emitTypeInfo);
         ICompositeSerializer compositeSerializer = configuration.GetCompositeSerializer(type);
         if (compositeSerializer != null)
-          return CompositeEnumerator(accessor.Name, compositeSerializer.Decompose(value), id, typeId, compositeSerializer.CreateMetaInfo(value));
+          return CompositeEnumerator(
+            accessor.Name,
+            compositeSerializer.Decompose(value),
+            id,
+            typeId,
+            compositeSerializer.CreateMetaInfo(value),
+            emitTypeInfo);
         throw CreatePersistenceException(type);
       } catch (Exception x) {
@@ -200 +217 @@
 
     private IEnumerator<ISerializationToken> PrimitiveEnumerator(string name,
-        int typeId, ISerialData serializedValue, int? id) {
+        int typeId, ISerialData serializedValue, int? id, bool emitTypeInfo) {
+      if (emitTypeInfo) {
+        var mapping = TypeCache[typeId];
+        yield return new TypeToken(mapping.Id, mapping.TypeName, mapping.Serializer);
+      }
       yield return new PrimitiveToken(name, typeId, id, serializedValue);
     }
 
     private IEnumerator<ISerializationToken> CompositeEnumerator(
-        string name, IEnumerable<Tag> tags, int? id, int typeId, IEnumerable<Tag> metaInfo) {
+        string name, IEnumerable<Tag> tags, int? id, int typeId, IEnumerable<Tag> metaInfo,
+        bool emitTypeInfo) {
+      if (emitTypeInfo) {
+        var mapping = TypeCache[typeId];
+        yield return new TypeToken(mapping.Id, mapping.TypeName, mapping.Serializer);
+      }
       yield return new BeginToken(name, typeId, id);
       bool first = true;