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

Timestamp:

04/14/09 13:23:08 (16 years ago)

Author:

epitzer

Message:

Replace final fixes for broken parent references with separation of instance creation with meta information. (#548)

Location:

trunk/sources/HeuristicLab.Persistence/3.3/Core

Files:

• DeSerializer.cs (modified) (4 diffs)
• Serializer.cs (modified) (2 diffs)
• Tag.cs (modified) (2 diffs)

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

@@ -8 +8 @@
   public class ParentReference {}  
 
-  class CompositeObject {
+  class Midwife {
+    
+    public int? Id { get; private set; }    
+    public bool MetaMode { get; set; }
+    public object Obj { get; private set; }
 
-    public object Obj { get; private set; }
-    public List<Tag> customValues;
+    private List<Tag> metaInfo;
+    private List<Tag> customValues;
+    private Type type;
+    private IDecomposer decomposer;
 
-    public CompositeObject(object obj) {
-      Obj = obj;
-      customValues = new List<Tag>();
+    public Midwife(object value) {
+      this.Obj = value;
+    }
+        
+    public Midwife(Type type, IDecomposer decomposer, int? id) {    
+      this.type = type;
+      this.decomposer = decomposer;      
+      this.Id = id;
+      MetaMode = false;      
+      metaInfo = new List<Tag>();
+      customValues = new List<Tag>();            
     }
 
-    public void AddValue(string name, object value, List<Thunk> finalFixes) {
-      Tag t = new Tag(name, value) {globalFinalFixes = finalFixes};
-      customValues.Add(t);
+    public void CreateInstance() {
+      if (Obj != null)
+        throw new ApplicationException("object already instantiated");
+      Obj = decomposer.CreateInstance(type, metaInfo);      
     }
 
-    public Setter GetSetterForLastAddedValue(string name) {            
-      Tag t = customValues[customValues.Count - 1];      
-      return value => t.Value = value;
+    public void AddValue(string name, object value) {
+      if (MetaMode) {
+        metaInfo.Add(new Tag(name, value));
+      } else {
+        customValues.Add(new Tag(name, value));
+      }
     }
-  }
 
-  public delegate void Thunk();
+    public void Populate() {
+      decomposer.Populate(Obj, customValues, type);
+    }
+  }  
 
   public class Deserializer {
     
     private readonly Dictionary<int, object> id2obj;
-    private readonly Dictionary<Type, object> serializerMapping;    
-    private readonly Stack<CompositeObject> parentStack;    
-    private readonly Dictionary<int, Type> typeIds;    
-    private List<Thunk> finalFixes;
+    private readonly Dictionary<Type, object> serializerMapping;
+    private readonly Stack<Midwife> parentStack;    
+    private readonly Dictionary<int, Type> typeIds;
 
     public Deserializer(
-      IEnumerable<TypeMapping> typeCache) {      
+      IEnumerable<TypeMapping> typeCache) {
       id2obj = new Dictionary<int, object>();
-      parentStack = new Stack<CompositeObject>();
+      parentStack = new Stack<Midwife>();
       typeIds = new Dictionary<int, Type>();
       serializerMapping = CreateSerializers(typeCache);
@@ -60 +79 @@
     }
 
-    public object Deserialize(IEnumerable<ISerializationToken> tokens) {
-      finalFixes = new List<Thunk>();      
+    public object Deserialize(IEnumerable<ISerializationToken> tokens) {      
       foreach (ISerializationToken token in tokens) {
         Type t = token.GetType();
@@ -74 +92 @@
         } else if (t == typeof(NullReferenceToken)) {
           NullHandler((NullReferenceToken)token);
+        } else if (t == typeof(MetaInfoBeginToken)) {
+          MetaInfoBegin((MetaInfoBeginToken)token);
+        } else if (t == typeof(MetaInfoEndToken)) {
+          MetaInfoEnd((MetaInfoEndToken)token);
         } else {
           throw new ApplicationException("invalid token type");
         }
       }
-      foreach (Thunk fix in finalFixes) {
-        fix();
-      }
       return parentStack.Pop().Obj;
     }
 
-    private void CompositeStartHandler(BeginToken token) {      
+    private void CompositeStartHandler(BeginToken token) {
       Type type = typeIds[(int)token.TypeId];
       IDecomposer decomposer = null;
       if ( serializerMapping.ContainsKey(type) )
-        decomposer = serializerMapping[type] as IDecomposer;      
+        decomposer = serializerMapping[type] as IDecomposer;
       if (decomposer == null)
         throw new ApplicationException(String.Format(
           "No suitable method for deserialization of type \"{0}\" found.",
           type.VersionInvariantName()));
-      object instance = 
-        decomposer.CreateInstance(type) ??
-        new ParentReference();
-      parentStack.Push(new CompositeObject(instance));              
-      if ( token.Id != null )
-        id2obj.Add((int)token.Id, instance);
+      parentStack.Push(new Midwife(type, decomposer, token.Id));
     }
 
-    private void CompositeEndHandler(EndToken token) {      
+    private void CompositeEndHandler(EndToken token) {
       Type type = typeIds[(int)token.TypeId];
-      IDecomposer decomposer = null;
-      if (serializerMapping.ContainsKey(type))
-        decomposer = serializerMapping[type] as IDecomposer;            
-      if (decomposer == null)
-        throw new ApplicationException(String.Format(
-          "No suitable method for deserialization of type \"{0}\" found.",
-          type.VersionInvariantName()));
-      CompositeObject customComposite = parentStack.Pop();
-      object deserializedObject =          
-        decomposer.Populate(customComposite.Obj, customComposite.customValues, type);
-      if ( token.Id != null )
-        id2obj[(int)token.Id] = deserializedObject;        
-      SetValue(token.Name, deserializedObject);          
+      Midwife midwife = parentStack.Pop();
+      midwife.Populate();
+      SetValue(token.Name, midwife.Obj);
     }
 
-    private void PrimitiveHandler(PrimitiveToken token) {      
+    private void PrimitiveHandler(PrimitiveToken token) {
       Type type = typeIds[(int)token.TypeId];
       object value = ((IFormatter) serializerMapping[type]).Parse(token.SerialData);
@@ -126 +130 @@
     }
 
-    private void ReferenceHandler(ReferenceToken token) {      
+    private void ReferenceHandler(ReferenceToken token) {
       object referredObject = id2obj[token.Id];
-      SetValue(token.Name, referredObject);      
-      if (referredObject is ParentReference) {
-        Setter set = parentStack.Peek().GetSetterForLastAddedValue(token.Name);                
-        finalFixes.Add(() => set(id2obj[token.Id]));
-      } 
+      SetValue(token.Name, referredObject);
     }
 
-    private void NullHandler(NullReferenceToken token) {      
+    private void NullHandler(NullReferenceToken token) {
       SetValue(token.Name, null);
-    }    
+    }
+
+    private void MetaInfoBegin(MetaInfoBeginToken token) {
+      parentStack.Peek().MetaMode = true;
+    }
+
+    private void MetaInfoEnd(MetaInfoEndToken token) {
+      Midwife m = parentStack.Peek();      
+      m.MetaMode = false;
+      CreateInstance(m);
+    }
+
+    private void CreateInstance(Midwife m) {
+      m.CreateInstance();
+      if (m.Id != null)
+        id2obj.Add((int)m.Id, m.Obj);      
+    }
 
     private void SetValue(string name, object value) {
       if (parentStack.Count == 0) {        
-        parentStack.Push(new CompositeObject(value));
-      } else {        
-        parentStack.Peek().AddValue(name, value, finalFixes);        
+        parentStack.Push(new Midwife(value));
+      } else {
+        Midwife m = parentStack.Peek();
+        if (m.MetaMode == false && m.Obj == null)
+          CreateInstance(m);
+        m.AddValue(name, value);        
       }
     }

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

@@ -72 +72 @@
       IDecomposer decomposer = configuration.GetDecomposer(value.GetType()); 
       if (decomposer != null)
-        return CompositeEnumerator(accessor.Name, decomposer.Decompose(value), id, typeId);                  
+        return CompositeEnumerator(accessor.Name, decomposer.Decompose(value), id, typeId, decomposer.CreateMetaInfo(value));
       throw new ApplicationException(
           String.Format(
@@ -92 +92 @@
     }
 
-    private IEnumerator<ISerializationToken> CompositeEnumerator(string name,
-        IEnumerable<Tag> tags, int? id, int typeId) {
+    private IEnumerator<ISerializationToken> CompositeEnumerator(
+        string name, IEnumerable<Tag> tags, int? id, int typeId, IEnumerable<Tag> metaInfo) {
       yield return new BeginToken(name, typeId, id);      
-        foreach (var tag in tags) {
-          IEnumerator<ISerializationToken> iterator = Serialize(            
-            new DataMemberAccessor(tag.Value, tag.Name));
-          while (iterator.MoveNext())
-            yield return iterator.Current;
+      bool first = true;
+      foreach (var tag in metaInfo) {
+        IEnumerator<ISerializationToken> metaIt = Serialize(new DataMemberAccessor(tag.Value, tag.Name));
+        while (metaIt.MoveNext()) {
+          if (first) {
+            yield return new MetaInfoBeginToken();
+            first = false;
+          }
+          yield return metaIt.Current;
         }
+      }
+      if (!first) {
+        yield return new MetaInfoEndToken();
+      }
+      foreach (var tag in tags) {
+        IEnumerator<ISerializationToken> it = Serialize(new DataMemberAccessor(tag.Value, tag.Name));
+        while (it.MoveNext())
+          yield return it.Current;
+      }
       yield return new EndToken(name, typeId, id);        
     }

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

@@ -4 +4 @@
 
   public class Tag {
-    internal List<Thunk> globalFinalFixes; // reference to final fixes of Deserializer
     public string Name { get; private set; }
     public object Value { get; set; }     
@@ -16 +15 @@
       Value = value;
     }
-    public void SafeSet(Setter setter) {
-      if ( Value as ParentReference != null)
-        globalFinalFixes.Add(() => setter(Value));
-      else
-        setter(Value);
-    }
-  }  
+  }
 
 }