source: branches/New Persistence Exploration/Persistence/Persistence/Core/DeSerializer.cs @ 1434

using System.Collections.Generic;
using System;
using HeuristicLab.Persistence.Interfaces;

namespace HeuristicLab.Persistence.Core {  

  public struct ParentReference {}
  delegate void Setter(object value);  

  class CompositeObject {

    public object Obj { get; private set; }
    public List<Tag> customValues;

    public CompositeObject(object obj) {
      Obj = obj;
      customValues = new List<Tag>();
    }

    public void AddValue(string name, object value, List<DeSerializer.Thunk> finalFixes) {
      Tag t = new Tag(name, value);
      t.finalFixes = finalFixes;
      customValues.Add(t);
    }

    public Setter GetSetter(string name) {            
      Tag t = customValues[customValues.Count - 1];      
      return value => t.Value = value;
    }
  }  

  public class DeSerializer {

    private delegate void Handler(ISerializationToken token);
    public delegate void Thunk();

    private readonly Dictionary<int, object> id2obj;
    private readonly Dictionary<Type, object> serializerMapping;
    private readonly Dictionary<Type, Handler> handlers;
    private readonly Stack<CompositeObject> parentStack;    
    private readonly Dictionary<int, Type> typeIds;    
    private List<Thunk> finalFixes;

    public DeSerializer(
      IEnumerable<TypeMapping> typeCache) {      
      id2obj = new Dictionary<int, object>();
      parentStack = new Stack<CompositeObject>();
      handlers = new Dictionary<Type, Handler> {
                     {typeof (BeginToken), CompositeStartHandler},
                     {typeof (EndToken), CompositeEndHandler},
                     {typeof (PrimitiveToken), PrimitiveHandler},
                     {typeof (ReferenceToken), ReferenceHandler},
                     {typeof (NullReferenceToken), NullHandler}
                   };      
      typeIds = new Dictionary<int, 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));
        }
      }
    }

    public object DeSerialize(IEnumerable<ISerializationToken> tokens) {
      finalFixes = new List<Thunk>();      
      foreach (ISerializationToken token in tokens) {
        handlers[token.GetType()].Invoke(token);
      }
      foreach (Thunk fix in finalFixes) {
        fix();
      }
      return parentStack.Pop().Obj;
    }

    private void CompositeStartHandler(ISerializationToken token) {
      BeginToken start = (BeginToken)token;
      object instance;      
      Type type = typeIds[(int)start.TypeId];
      IDecomposer decomposer = null;
      if ( serializerMapping.ContainsKey(type) )
        decomposer = serializerMapping[type] as IDecomposer;      
      if (decomposer != null) {        
        instance = decomposer.CreateInstance(type);
        if (instance == null)
          instance = new ParentReference();
        parentStack.Push(new CompositeObject(instance));        
      } else {
        throw new ApplicationException(String.Format(
          "No suitable method for deserialization of type \"{0}\" found.",
          type.VersionInvariantName()));
      }
      if ( start.Id != null )
        id2obj.Add((int)start.Id, instance);
    }

    private void CompositeEndHandler(ISerializationToken token) {
      EndToken end = (EndToken)token;
      Type type = typeIds[(int)end.TypeId];
      IDecomposer decomposer = null;
      if (serializerMapping.ContainsKey(type))
        decomposer = serializerMapping[type] as IDecomposer;            
      if (decomposer != null) {
        CompositeObject customComposite = (CompositeObject)parentStack.Pop();
        object deserializedObject =          
          decomposer.Populate(customComposite.Obj, customComposite.customValues, type);
        if ( end.Id != null )
          id2obj[(int)end.Id] = deserializedObject;        
        SetValue(end.Name, deserializedObject);          
      } else {
        throw new ApplicationException(String.Format(
          "No suitable method for deserialization of type \"{0}\" found.",
          type.VersionInvariantName()));
      }
    }

    private void PrimitiveHandler(ISerializationToken token) {
      PrimitiveToken primitive = (PrimitiveToken)token;
      Type type = typeIds[(int)primitive.TypeId];
      object value = ((IFormatter) serializerMapping[type]).Parse(primitive.SerialData);
      if ( ! value.GetType().IsValueType )
        id2obj[(int)primitive.Id] = value;
      SetValue(primitive.Name, value);
    }

    private void ReferenceHandler(ISerializationToken token) {
      ReferenceToken reference = (ReferenceToken)token;
      object referredObject = id2obj[reference.Id];
      SetValue(reference.Name, id2obj[reference.Id]);
      if (referredObject is ParentReference) {
        Setter set = parentStack.Peek().GetSetter(reference.Name);        
        int id = reference.Id;
        finalFixes.Add(() => set(id2obj[id]));
      } 
    }

    private void NullHandler(ISerializationToken token) {
      NullReferenceToken nullToken = (NullReferenceToken)token;
      SetValue(nullToken.Name, null);
    }    

    private void SetValue(string name, object value) {
      if (parentStack.Count == 0) {        
        parentStack.Push(new CompositeObject(value));
      } else {        
        parentStack.Peek().AddValue(name, value, finalFixes);        
      }
    }
  }
}