Changeset 6737 for branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default

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)

Location:

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default

Files:

• DebugString/DebugStringGenerator.cs (modified) (1 diff)
• Xml/EasyXmlGenerator.cs (modified) (3 diffs)
• Xml/XmlGenerator.cs (modified) (8 diffs)
• Xml/XmlParser.cs (modified) (7 diffs)
• Xml/XmlStringConstants.cs (modified) (1 diff)

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default/DebugString/DebugStringGenerator.cs

@@ -169 +169 @@
     }
 
+    protected override string Format(SerializerToken serializerToken) {
+      return string.Empty;
+    }
+
     /// <summary>
     /// Serializes the specified object.

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default/Xml/EasyXmlGenerator.cs

@@ -58 +58 @@
     /// <returns>The token in serialized form.</returns>
     protected override string Format(EndToken endToken) {
-      return CreateNodeEnd(typeCache[endToken.TypeId]);
+      return CreateNodeEnd("END");
     }
 
@@ -154 +154 @@
         File.Copy(tempfile, filename, true);
         File.Delete(tempfile);
-      }
-      catch (Exception) {
+      } catch (Exception) {
         Logger.Warn("Exception caught, no data has been written.");
         throw;
@@ -190 +189 @@
           writer.Flush();
         }
-      }
-      catch (PersistenceException) {
+      } catch (PersistenceException) {
         throw;
-      }
-      catch (Exception e) {
+      } catch (Exception e) {
         throw new PersistenceException("Unexpected exception during Serialization.", e);
       }

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default/Xml/XmlGenerator.cs

@@ -157 +157 @@
       AddTypeInfo(beginToken.TypeId, dict);
       return CreateNodeStart(XmlStringConstants.COMPOSITE, dict);
-
     }
 
@@ -164 +163 @@
         if (typeId == lastTypeToken.Id) {
           dict.Add("typeName", lastTypeToken.TypeName);
-          dict.Add("serializer", lastTypeToken.Serializer);
           lastTypeToken = null;
         } else {
           FlushTypeToken();
+        }
+      }
+      if (lastSerializerToken != null) {
+        if (typeId == lastSerializerToken.Id) {
+          dict.Add("serializer", lastSerializerToken.Serializer);
+          lastSerializerToken = null;
+        } else {
+          FlushSerializerToken();
         }
       }
@@ -238 +244 @@
 
     protected TypeToken lastTypeToken;
+    protected SerializerToken lastSerializerToken;
     /// <summary>
     /// Formats the specified token.
@@ -245 +252 @@
     protected override string Format(TypeToken token) {
       lastTypeToken = token;
+      return "";
+    }
+
+    protected override string Format(SerializerToken token) {
+      lastSerializerToken = token;
       return "";
     }
@@ -255 +267 @@
           new Dictionary<string, string> {
           {"id", lastTypeToken.Id.ToString()},
-          {"typeName", lastTypeToken.TypeName },
-          {"serializer", lastTypeToken.Serializer }});
+          {"typeName", lastTypeToken.TypeName }});
       } finally {
         lastTypeToken = null;
@@ -262 +273 @@
     }
 
+    protected string FlushSerializerToken() {
+      if (lastSerializerToken == null)
+        return "";
+      try {
+        return CreateNode(XmlStringConstants.SERIALIZER,
+          new Dictionary<string, string> {
+          {"id", lastSerializerToken.Id.ToString()},
+          {"serializer", lastSerializerToken.Serializer }});
+      } finally {
+        lastTypeToken = null;
+      }
+    }
+
     /// <summary>
     /// Formats the specified type cache.
@@ -267 +291 @@
     /// <param name="typeCache">The type cache.</param>
     /// <returns>An enumerable of formatted type cache tags.</returns>
-    public IEnumerable<string> Format(List<TypeMapping> typeCache) {
+    public IEnumerable<string> Format(TypeCache typeCache) {
       yield return CreateNodeStart(XmlStringConstants.TYPECACHE);
-      foreach (var mapping in typeCache)
-        yield return CreateNode(
-          XmlStringConstants.TYPE,
-          mapping.GetDict());
+      foreach (var type in typeCache.Types) {
+        int id = typeCache.GetOrCreateId(type);
+        var dict = new Dictionary<string, string> {
+          {"id", id.ToString()},
+          {"typeName", type.AssemblyQualifiedName},
+        };
+        Type serializer = typeCache.GetSerializer(id);
+        if (serializer != null)
+          dict.Add("serializer", serializer.AssemblyQualifiedName);
+        yield return CreateNode(XmlStringConstants.TYPE, dict); 
+      }
       yield return CreateNodeEnd(XmlStringConstants.TYPECACHE);
     }
@@ -342 +373 @@
             writer.Flush();
             if (includeAssemblies) {
-              foreach (string name in serializer.RequiredFiles) {
+              foreach (string name in serializer.GetRequiredFiles()) {
                 Uri uri = new Uri(name);
                 if (!uri.IsFile) {

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default/Xml/XmlParser.cs

@@ -26 +26 @@
 using System.IO.Compression;
 using System.Xml;
+using HeuristicLab.Persistence.Auxiliary;
 using HeuristicLab.Persistence.Core;
 using HeuristicLab.Persistence.Core.Tokens;
@@ -58 +59 @@
                      {XmlStringConstants.METAINFO, ParseMetaInfo},
                      {XmlStringConstants.TYPE, ParseTypeInfo},
+                     {XmlStringConstants.SERIALIZER, ParseSerializer},
                    };
     }
@@ -106 +108 @@
       string serializer = reader.GetAttribute("serializer");
       if (typeName != null)
-        yield return new TypeToken(typeId, typeName, serializer);
+        yield return new TypeToken(typeId, typeName);
+      if (serializer != null)
+        yield return new SerializerToken(typeId, serializer);
       XmlReader inner = reader.ReadSubtree();
       inner.Read();
@@ -124 +128 @@
       string serializer = reader.GetAttribute("serializer");
       if (typeName != null)
-        yield return new TypeToken(typeId, typeName, serializer);
+        yield return new TypeToken(typeId, typeName);
+      if (serializer != null)
+        yield return new SerializerToken(typeId, serializer);
       yield return new BeginToken(name, typeId, id);
       IEnumerator<ISerializationToken> iterator = GetEnumerator();
       while (iterator.MoveNext())
         yield return iterator.Current;
-      yield return new EndToken(name, typeId, id);
+      yield return new EndToken();
     }
 
@@ -151 +157 @@
 
     private IEnumerator<ISerializationToken> ParseTypeInfo() {
-      yield return new TypeToken(
-        int.Parse(reader.GetAttribute("id")),
-        reader.GetAttribute("typeName"),
-        reader.GetAttribute("serializer"));
+      int id = int.Parse(reader.GetAttribute("id"));
+      string typeName = reader.GetAttribute("typeName");
+      yield return new TypeToken(id, typeName);
+      string serializer = reader.GetAttribute("serializer");
+      if (serializer != null)
+        yield return new SerializerToken(id, serializer);
+    }
+
+    private IEnumerator<ISerializationToken> ParseSerializer() {
+      int id = int.Parse(reader.GetAttribute("id"));
+      string serializer = reader.GetAttribute("serializer");
+      yield return new SerializerToken(id, serializer);
     }
 
@@ -162 +176 @@
     /// <param name="reader">The reader.</param>
     /// <returns>A list of type mapping entries.</returns>
-    public static List<TypeMapping> ParseTypeCache(TextReader reader) {
-      try {
-        var typeCache = new List<TypeMapping>();
+    public static ReverseTypeCache ParseTypeCache(TextReader reader) {
+      ReverseTypeCache typeCache = new ReverseTypeCache();
+      try {
         XmlReader xmlReader = XmlReader.Create(reader);
         while (xmlReader.Read()) {
           if (xmlReader.Name == XmlStringConstants.TYPE) {
-            typeCache.Add(new TypeMapping(
+            int id = int.Parse(xmlReader.GetAttribute("id"));
+            typeCache.AddType(id, TypeLoader.Load(xmlReader.GetAttribute("typeName")));
+            string serializer = xmlReader.GetAttribute("serializer");
+            if (serializer != null)
+              typeCache.AddSerializer(id, TypeLoader.Load(serializer));
+          } else if (xmlReader.Name == XmlStringConstants.SERIALIZER) {
+            typeCache.AddSerializer(
               int.Parse(xmlReader.GetAttribute("id")),
-              xmlReader.GetAttribute("typeName"),
-              xmlReader.GetAttribute("serializer")));
+              TypeLoader.Load(xmlReader.GetAttribute("serializer")));
           }
         }
@@ -221 +240 @@
         using (StreamReader reader = new StreamReader(new GZipStream(stream, CompressionMode.Decompress))) {
           XmlParser parser = new XmlParser(reader);
-          Deserializer deserializer = new Deserializer(new TypeMapping[] { });
+          Deserializer deserializer = new Deserializer(new ReverseTypeCache());
           return deserializer.Deserialize(new AsyncBuffer<ISerializationToken>(parser));
         }

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default/Xml/XmlStringConstants.cs

@@ -30 +30 @@
     public const string TYPECACHE = "TYPECACHE";
     public const string TYPE = "TYPE";
+    public const string SERIALIZER = "SERIALIZER";
     public const string METAINFO = "METAINFO";
   }