source: branches/New Persistence Exploration/Persistence/Persistence/Decomposers.cs @ 1354

using System;
using System.Collections;
using System.Reflection;
using System.Collections.Generic;
namespace Persistence {
  

  public interface IDecomposer {
    bool CanSerialize(Type type);
    IEnumerable Serialize(object obj);
    object DeSerialize(IEnumerable objects, Type type);
  }


  public class EnumerableDecomposer : IDecomposer {

    public bool CanSerialize(Type type) {
      return
        type.GetInterface("IEnumerable") != null &&
        type.GetMethod("Add") != null &&
        type.GetMethod("Add").GetParameters().Length == 1 &&
        type.GetConstructor(
          BindingFlags.Public |
          BindingFlags.NonPublic |
          BindingFlags.Instance,
          null, Type.EmptyTypes, null) != null;        
    }    

    public IEnumerable Serialize(object obj) {
      return (IEnumerable)obj;
    }

    public object DeSerialize(IEnumerable objects, Type type) {
      object instance = Activator.CreateInstance(type, true);
      MethodInfo addMethod = type.GetMethod("Add");
      foreach (object o in objects) {
        addMethod.Invoke(instance, new[] {o});        
      }
      return instance;
    }

  }


  public class ArrayDecomposer : IDecomposer {

    public bool CanSerialize(Type type) {
      return type.IsArray || type == typeof(Array);
    }

    public IEnumerable Serialize(object array) {
      Array a = (Array)array;
      yield return a.Rank;
      for (int i = 0; i < a.Rank; i++) {
        yield return a.GetLength(i);
      }
      foreach (object o in (Array)array) {
        yield return o;
      }
    }

    public object DeSerialize(IEnumerable elements, Type t) {
      IEnumerator e = elements.GetEnumerator();
      e.MoveNext();
      int rank = (int)e.Current;
      int[] lengths = new int[rank];
      for (int i = 0; i < rank; i++) {
        e.MoveNext();
        lengths[i] = (int)e.Current;
      }
      Array a = Array.CreateInstance(t.GetElementType(), lengths);      
      int[] positions = new int[rank];
      while (e.MoveNext()) {
        a.SetValue(e.Current, positions);
        positions[0] += 1;
        for (int i = 0; i < rank-1; i++) {
          if (positions[i] >= lengths[i]) {
            positions[i] = 0;
            positions[i + 1] += 1;
          } else {
            break;
          }
        }
      }
      return a;
    }
  }


  public class KeyValuePairDecomposer : IDecomposer {    

    public bool CanSerialize(Type type) {
      return type.IsGenericType &&
             type.GetGenericTypeDefinition() == 
             typeof (KeyValuePair<int, int>).GetGenericTypeDefinition();
    }

    public IEnumerable Serialize(object o) {      
      Type t = o.GetType();
      yield return t.GetProperty("Key").GetValue(o, null);
      yield return t.GetProperty("Value").GetValue(o, null);
    }

    public object DeSerialize(IEnumerable o, Type t) {      
      return Activator.CreateInstance(t,
        new List<object>((IEnumerable<object>)o).ToArray());
    }    
  }


  public class DictionaryDecomposer : IDecomposer {
    public bool CanSerialize(Type type) {
      return type.GetInterface("IDictionary") != null;        
    }
    public IEnumerable Serialize(object o) {
      IDictionary dict = (IDictionary)o;      
      foreach ( DictionaryEntry entry in dict) {
        yield return entry.Key;
        yield return entry.Value;
      }
    }
    public object DeSerialize(IEnumerable o, Type t) {
      IDictionary dict = (IDictionary)Activator.CreateInstance(t, true);
      IEnumerator iter = o.GetEnumerator();
      while (iter.MoveNext()) {
        object key = iter.Current;
        iter.MoveNext();
        object value = iter.Current;
        dict.Add(key, value);
      }
      return dict;
    }
  }

}