source: branches/New Persistence Exploration/Persistence/Persistence/Serializer.cs @ 1314

using System.Collections.Generic;
using System.Collections;
using System;

namespace Persistence {

  public class Serializer : IEnumerable<ISerializationToken> {

    private object obj;
    private string rootName;
    private Dictionary<object, int> obj2id;
    private Dictionary<Type, IPrimitiveSerializer> primitiveSerializers;
    private List<ICompoundSerializer> customSerializers;

    public Serializer(object obj, IEnumerable<IPrimitiveSerializer> primitiveSerializers) :
      this(obj, primitiveSerializers, "ROOT") { }

    public Serializer(object obj, IEnumerable<IPrimitiveSerializer> primitiveSerializers, string rootName) {
      this.obj = obj;
      this.rootName = rootName;
      this.primitiveSerializers = new Dictionary<Type, IPrimitiveSerializer>();
      foreach (IPrimitiveSerializer serializer in primitiveSerializers) {
        this.primitiveSerializers.Add(serializer.Type, serializer);
      }
      this.customSerializers = new List<ICompoundSerializer>();
      customSerializers.Add(new EnumerableSerializer());
      customSerializers.Add(new ArraySerializer());
      this.obj2id = new Dictionary<object, int>();
      obj2id.Add(new object(), 0);
    }

    IEnumerator IEnumerable.GetEnumerator() {
      return this.GetEnumerator();
    }

    public IEnumerator<ISerializationToken> GetEnumerator() {
      DataMemberAccessor rootAccessor = new DataMemberAccessor(
        this.rootName, obj.GetType(), null, () => this.obj, null);
      IEnumerator<ISerializationToken> iterator = Serialize(rootAccessor);
      while (iterator.MoveNext())
        yield return iterator.Current;
    }

    private IEnumerator<ISerializationToken> Serialize(DataMemberAccessor accessor) {
      object value = accessor.Get();
      if (value == null) {
        yield return new NullReferenceToken(accessor.Name);
      } else if (this.primitiveSerializers.ContainsKey(value.GetType())) {
        yield return new PrimitiveToken(accessor, this.primitiveSerializers[value.GetType()].Serialize(value));
      } else if (this.obj2id.ContainsKey(value)) {
        yield return new ReferenceToken(accessor.Name, this.obj2id[value]);
      } else {
        int id = obj2id.Count;
        this.obj2id.Add(value, id);
        yield return new BeginToken(accessor, id);
        ICompoundSerializer customSerializer = this.FindCustomSerializer(value.GetType());
        if (customSerializer != null) {
          foreach (object obj in customSerializer.Serialize(value)) {
            IEnumerator<ISerializationToken> iterator = this.Serialize(new DataMemberAccessor(obj));
            while (iterator.MoveNext())
              yield return iterator.Current;
          }
        } else { // composite serialization
          foreach (KeyValuePair<string, DataMemberAccessor> mapping in
            StorableAttribute.GetAutostorableAccessors(value)) {
            IEnumerator<ISerializationToken> iterator = this.Serialize(mapping.Value);
            while (iterator.MoveNext())
              yield return iterator.Current;
          }
        }
        yield return new EndToken(accessor, id);
      }
    }

    private ICompoundSerializer FindCustomSerializer(Type type) {
      foreach (ICompoundSerializer s in customSerializers) {
        if (s.CanSerialize(type))
          return s;
      }
      return null;
    }
  }
}