source: branches/New Persistence Exploration/Persistence/Persistence/StorableAttribute.cs @ 1357

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

namespace HeuristicLab.Persistence {

  [AttributeUsage(
    AttributeTargets.Field | AttributeTargets.Property,
    AllowMultiple=false,
    Inherited=false)]
  public class StorableAttribute : Attribute {

    public string Name { get; set; }
    public object DefaultValue { get; set; }

    private const BindingFlags instanceMembers =
      BindingFlags.Instance |
      BindingFlags.Public |
      BindingFlags.NonPublic;
    
    public static IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>> GetStorableMembers(Type type) {
      return GetStorableMembers(type, true);      
    }

    public static IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>>
        GetStorableMembers(Type type, bool inherited) {
      if (type.BaseType != null)
        foreach ( var pair in GetStorableMembers(type.BaseType) )
          yield return pair;
      foreach (MemberInfo memberInfo in type.GetMembers(instanceMembers)) {
        foreach (object attribute in memberInfo.GetCustomAttributes(false)) {          
          StorableAttribute storableAttribute =
            attribute as StorableAttribute;
          if (storableAttribute != null) {
            yield return new KeyValuePair<StorableAttribute, MemberInfo>(storableAttribute, memberInfo);            
          }
        }
      }      
    }

    public static Dictionary<string, DataMemberAccessor> GetAutostorableAccessors(object obj) {
      Dictionary<string, DataMemberAccessor> storableAccessors =
        new Dictionary<string, DataMemberAccessor>();
      foreach (KeyValuePair<StorableAttribute, MemberInfo> pair in GetStorableMembers(obj.GetType())) {
        storableAccessors.Add(pair.Value.Name,
          new DataMemberAccessor(pair.Value, pair.Key, obj));
      }            
      return storableAccessors;
    }    
  }

  public class CloningFactory {

    private static readonly CloningFactory instance = new CloningFactory();

    public static T DefaultClone<T>(T obj) {
      return instance.Clone(obj);
    }

    private readonly List<IDecomposer> compoundSerializers;

    public CloningFactory(IEnumerable<IDecomposer> compoundSerializers) {
      this.compoundSerializers = new List<IDecomposer>(compoundSerializers);
    }

    public CloningFactory() :
      this(InterfaceInstantiatior.InstantiateAll<IDecomposer>()) { }

    delegate object CloneMethod(object obj, Dictionary<object, object> twins);

    readonly Dictionary<Type, CloneMethod> cloneMethods = new Dictionary<Type, CloneMethod>();

    public T Clone<T>(T obj) {
      Dictionary<object, object> twins = new Dictionary<object, object>();
      return Clone(obj, twins);
    }

    public T Clone<T>(T obj, Dictionary<object, object> twins) {
      ValueType t = obj as ValueType;
      if (t != null)
        return obj;

      // ReSharper disable CompareNonConstrainedGenericWithNull
      if (obj == null)
      // ReSharper restore CompareNonConstrainedGenericWithNull
        return default(T);

      if (twins.ContainsKey(obj))
        return (T)twins[obj];

      ICloneable c = obj as ICloneable;
      if (c != null) {
        T newClone = (T)c.Clone();
        twins[obj] = newClone;
        return newClone;
      }

      Type type = obj.GetType();
      if (!cloneMethods.ContainsKey(type))
        cloneMethods[type] = CreateCloneMethod(type);
      return (T)cloneMethods[type](obj, twins);
    }

    private CloneMethod CreateCloneMethod(Type type) {
      if (type.GetConstructor(new[] { type }) != null)
        return CopyConstructorCloneMethod.Create(type);
      foreach (IDecomposer serializer in compoundSerializers)
        if (serializer.CanSerialize(type))
          return CompoundSerializerCloneMethod.Create(serializer, type, this);
      return StorableAccessorCloneMethod.Create(type, this);      
    }

    class CopyConstructorCloneMethod {
      public static CloneMethod Create(Type type) {
        return new CopyConstructorCloneMethod(type).method;
      }
      private readonly ConstructorInfo constructorInfo;
      public CopyConstructorCloneMethod(Type type) {
        constructorInfo = type.GetConstructor(new[] { type });
      }
      object method(object obj, Dictionary<object, object> twins) {
        object newInstance = constructorInfo.Invoke(new[] { obj });
        twins.Add(obj, newInstance);
        return newInstance;
      }
    }

    class CompoundSerializerCloneMethod {
      public static CloneMethod Create(IDecomposer serializer,
          Type type, CloningFactory factory) {
        return new CompoundSerializerCloneMethod(serializer, type, factory).method;
      }
      private readonly IDecomposer serializer;
      private readonly Type type;
      private readonly CloningFactory factory;
      public CompoundSerializerCloneMethod(IDecomposer serializer,
          Type type, CloningFactory factory) {
        this.serializer = serializer;
        this.type = type;
        this.factory = factory;
      }
      object method(object obj, Dictionary<object, object> twins) {
        return serializer.DeSerialize(
          serializer.Serialize(obj)
          .OfType<object>()
          .Select(o => factory.Clone(o, twins)),
          type);          
      }
    }

    class StorableAccessorCloneMethod {

      delegate object GetterMethod(object target);
      delegate void SetterMethod(object target, object value);

      struct FieldAccessor {      
        public readonly GetterMethod Getter;
        public readonly SetterMethod Setter;
        public FieldAccessor(GetterMethod getter, SetterMethod setter) {
          Getter = getter;
          Setter = setter;
        }
      }

      private const BindingFlags INSTANCE_MEMBERS =
        BindingFlags.Instance |
        BindingFlags.Public |
        BindingFlags.NonPublic;

      public static CloneMethod Create(Type type, CloningFactory factory) {
        return new StorableAccessorCloneMethod(type, factory).method;
      }

      private readonly List<FieldAccessor> fieldAccessors;
      private readonly CloningFactory factory;
         
      public StorableAccessorCloneMethod(Type type, CloningFactory factory) {
        this.factory = factory;
        fieldAccessors = new List<FieldAccessor>();
        foreach (MemberInfo memberInfo in type.GetMembers(INSTANCE_MEMBERS)) {
          foreach (object attribute in memberInfo.GetCustomAttributes(false)) {
            StorableAttribute autoStorableAttribute =
              attribute as StorableAttribute;
            if (autoStorableAttribute != null) {
              if (memberInfo.MemberType == MemberTypes.Field) {
                FieldInfo fi = (FieldInfo)memberInfo;
                fieldAccessors.Add(new FieldAccessor(
                  fi.GetValue,
                  fi.SetValue));
              } else if (memberInfo.MemberType == MemberTypes.Property) {
                PropertyInfo pi = (PropertyInfo)memberInfo;
                fieldAccessors.Add(new FieldAccessor(
                  target => pi.GetValue(target, null),
                  (target, value) => pi.SetValue(target, value, null)));
              }
            }
          }
        }
      }
      object method(object obj, Dictionary<object, object> twins) {
        object newInstance = Activator.CreateInstance(obj.GetType(), true);
        twins.Add(obj, newInstance);
        foreach (FieldAccessor fa in fieldAccessors) {
          fa.Setter(newInstance, factory.Clone(fa.Getter(obj), twins));
        }
        return newInstance;
      }
    }
  }  
    
  public class DataMemberAccessor {

    public delegate object Getter();
    public delegate void Setter(object value);

    public readonly Getter Get;
    public readonly Setter Set;
    public readonly string Name;
    public readonly Type Type;
    public readonly object DefaultValue;

    public DataMemberAccessor(
        MemberInfo memberInfo,
        StorableAttribute autoStorableAttribute,
        object obj) {
      if (memberInfo.MemberType == MemberTypes.Field) {
        FieldInfo fieldInfo = (FieldInfo)memberInfo;
        Get = () => fieldInfo.GetValue(obj);
        Set = value => fieldInfo.SetValue(obj, value);
        Type = fieldInfo.FieldType;
      } else if (memberInfo.MemberType == MemberTypes.Property) {
        PropertyInfo propertyInfo = (PropertyInfo)memberInfo;
        if (!propertyInfo.CanRead || !propertyInfo.CanWrite) {
          throw new NotSupportedException(
            "Storable properties must implement both a Get and a Set Accessor. ");
        }
        Get = () => propertyInfo.GetValue(obj, null);
        Set = value => propertyInfo.SetValue(obj, value, null);
        Type = propertyInfo.PropertyType;
      } else {
        throw new NotSupportedException(
                "The Storable attribute can only be applied to fields and properties.");
      }      
      Name = autoStorableAttribute.Name ?? memberInfo.Name;      
      DefaultValue = autoStorableAttribute.DefaultValue;                  
    }

    public DataMemberAccessor(
        string name, Type type, object defaultValue,
        Getter getter, Setter setter) {
      Name = name;
      Type = type;
      DefaultValue = defaultValue;
      Get = getter;
      Set = setter;
    }

    public DataMemberAccessor(object o) {      
      Name = null;
      Type = o.GetType();
      DefaultValue = null;
      Get = () => o;
      Set = null;
    }        
    public override string ToString() {
      return String.Format("DataMember({0}, {1}, {2}, {3}, {4}",
        Name,
        Type == null ? "<null>" : Type.FullName,
        DefaultValue ?? "<null>",
        Get.Method,
        Set.Method);
    }
  }

}