Changeset 6214 for branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default/CompositeSerializers

Timestamp:

05/17/11 11:22:15 (14 years ago)

Author:

epitzer

Message:

Streamline persistence reflection and store into persistable data structure for caching (#1530)

Location:

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable

Files:

• Descriptors (added)
• Descriptors/FieldDescriptor.cs (added)
• Descriptors/HookDescriptor.cs (added)
• Descriptors/ITypeComponent.cs (added)
• Descriptors/PropertyDescriptor.cs (added)
• Descriptors/TypeDescriptor.cs (added)
• Descriptors/TypeSerializationCompiler.cs (added)
• StorableClassAnalyzer.cs (added)
• StorableMemberInfo.cs (deleted)
• StorableReflection.cs (deleted)
• StorableSerializer.cs (modified) (8 diffs)

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableSerializer.cs

@@ -24 +24 @@
 using System.Linq;
 using System.Reflection;
-using System.Reflection.Emit;
 using System.Text;
 using HeuristicLab.Persistence.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable.Descriptors;
 using HeuristicLab.Persistence.Interfaces;
 
@@ -41 +41 @@
   public sealed class StorableSerializer : ICompositeSerializer {
 
+    private StorableClassAnalyzer analyzer;
+
     public StorableSerializer() {
-      accessorListCache = new AccessorListCache();
-      accessorCache = new AccessorCache();
-      constructorCache = new Dictionary<Type, Constructor>();
-      hookCache = new Dictionary<HookDesignator, List<StorableReflection.Hook>>();
+      analyzer = new StorableClassAnalyzer();
     }
+
     [StorableConstructor]
     private StorableSerializer(bool deserializing) : this() { }
@@ -68 +68 @@
     /// </returns>
     public bool CanSerialize(Type type) {
-      bool markedStorable = StorableReflection.HasStorableClassAttribute(type);
-      if (GetConstructor(type) == null)
-        if (markedStorable)
-          throw new Exception("[Storable] type has no default constructor and no [StorableConstructor]");
+      TypeDescriptor desc = analyzer[type];
+      if (desc.IsInvalid)
+        return false;
+      if (desc.HasDefaultConstructor)
+        return true;
+      else if (desc.IsStorableClass)
+        if (desc.HasDefaultConstructor || desc.HasStorableConstructor)
+          return true;
         else
-          return false;
-      if (!StorableReflection.IsEmptyOrStorableType(type, true))
-        if (markedStorable)
-          throw new Exception("[Storable] type has non emtpy, non [Storable] base classes");
-        else
-          return false;
-      return true;
+          throw new PersistenceException("[Storable] type has no default constructor and no [StorableConstructor]");
+      return false;
     }
 
@@ -92 +91 @@
     public string JustifyRejection(Type type) {
       StringBuilder sb = new StringBuilder();
-      if (GetConstructor(type) == null)
-        sb.Append("class has no default constructor and no [StorableConstructor]");
-      if (!StorableReflection.IsEmptyOrStorableType(type, true))
-        sb.Append("class (or one of its bases) is not empty and not marked [Storable]; ");
+      TypeDescriptor desc = analyzer[type];
+      if (desc.IsInvalid)
+        sb.Append("class is not marked [StorableClass] but has mutable members.");
+      if (!desc.IsStorableClass)
+        sb.Append("class is not marked [StorableClass]");
+      if (!desc.HasDefaultConstructor)
+        sb.Append("class has no default constructor");
+      if (!desc.HasStorableConstructor)
+        sb.Append("class has no [StorableConstructor]");
       return sb.ToString();
     }
@@ -105 +109 @@
     /// <returns>A list of storable components.</returns>
     public IEnumerable<Tag> CreateMetaInfo(object o) {
-      InvokeHook(HookType.BeforeSerialization, o);
       return new Tag[] { };
     }
@@ -117 +120 @@
     /// <returns>An enumerable of <see cref="Tag"/>s.</returns>
     public IEnumerable<Tag> Decompose(object obj) {
-      foreach (var accessor in GetStorableAccessors(obj.GetType())) {
-        if (accessor.Get != null)
-          yield return new Tag(accessor.Name, accessor.Get(obj));
+      foreach (var kvp in analyzer[obj.GetType()].Decompose(obj)) {
+        yield return new Tag(kvp.Key, kvp.Value);
       }
     }
@@ -131 +133 @@
     public object CreateInstance(Type type, IEnumerable<Tag> metaInfo) {
       try {
-        return GetConstructor(type)();
+        return analyzer[type].CreateInstance();
       } catch (TargetInvocationException x) {
         throw new PersistenceException(
@@ -146 +148 @@
     /// <param name="type">The type.</param>
     public void Populate(object instance, IEnumerable<Tag> objects, Type type) {
-      var memberDict = new Dictionary<string, Tag>();
-      IEnumerator<Tag> iter = objects.GetEnumerator();
-      while (iter.MoveNext()) {
-        memberDict.Add(iter.Current.Name, iter.Current);
-      }
-      foreach (var accessor in GetStorableAccessors(instance.GetType())) {
-        if (accessor.Set != null) {
-          if (memberDict.ContainsKey(accessor.Name)) {
-            accessor.Set(instance, memberDict[accessor.Name].Value);
-          } else if (accessor.DefaultValue != null) {
-            accessor.Set(instance, accessor.DefaultValue);
-          }
-        }
-      }
-      InvokeHook(HookType.AfterDeserialization, instance);
+      analyzer[type].Populate(instance, objects.ToDictionary(kvp => kvp.Name, kvp => kvp.Value));
     }
 
     #endregion
 
-    #region constants & private data types
-
-    private const BindingFlags ALL_CONSTRUCTORS =
-      BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
-
-    private static readonly object[] emptyArgs = new object[] { };
-    private static readonly object[] trueArgs = new object[] { true };
-
-    private sealed class HookDesignator {
-      public Type Type { get; private set; }
-      public HookType HookType { get; private set; }
-      public HookDesignator() { }
-      public HookDesignator(Type type, HookType hookType) {
-        Type = type;
-        HookType = HookType;
-      }
-    }
-
-    private sealed class AccessorListCache : Dictionary<Type, IEnumerable<DataMemberAccessor>> { }
-    private sealed class AccessorCache : Dictionary<MemberInfo, DataMemberAccessor> { }
-    private delegate object Constructor();
-
-    #endregion
-
-    #region caches
-
-    private AccessorListCache accessorListCache;
-    private AccessorCache accessorCache;
-    private Dictionary<Type, Constructor> constructorCache;
-    private Dictionary<HookDesignator, List<StorableReflection.Hook>> hookCache;
-
-    #endregion
-
-    #region attribute access
-
-    private IEnumerable<DataMemberAccessor> GetStorableAccessors(Type type) {
-      lock (accessorListCache) {
-        if (accessorListCache.ContainsKey(type))
-          return accessorListCache[type];
-        var storableMembers = StorableReflection
-          .GenerateStorableMembers(type)
-          .Select(mi => GetMemberAccessor(mi));
-        accessorListCache[type] = storableMembers;
-        return storableMembers;
-      }
-    }
-
-    private DataMemberAccessor GetMemberAccessor(StorableMemberInfo mi) {
-      lock (accessorCache) {
-        if (accessorCache.ContainsKey(mi.MemberInfo))
-          return new DataMemberAccessor(accessorCache[mi.MemberInfo], mi.DisentangledName, mi.DefaultValue);
-        DataMemberAccessor dma = new DataMemberAccessor(mi.MemberInfo, mi.DisentangledName, mi.DefaultValue);
-        accessorCache[mi.MemberInfo] = dma;
-        return dma;
-      }
-    }
-
-    private Constructor GetConstructor(Type type) {
-      lock (constructorCache) {
-        if (constructorCache.ContainsKey(type))
-          return constructorCache[type];
-        Constructor c = FindStorableConstructor(type) ?? GetDefaultConstructor(type);
-        constructorCache.Add(type, c);
-        return c;
-      }
-    }
-
-    private Constructor GetDefaultConstructor(Type type) {
-      ConstructorInfo ci = type.GetConstructor(ALL_CONSTRUCTORS, null, Type.EmptyTypes, null);
-      if (ci == null)
-        return null;
-      DynamicMethod dm = new DynamicMethod("", typeof(object), null, type, true);
-      ILGenerator ilgen = dm.GetILGenerator();
-      ilgen.Emit(OpCodes.Newobj, ci);
-      ilgen.Emit(OpCodes.Ret);
-      return (Constructor)dm.CreateDelegate(typeof(Constructor));
-    }
-
-    private Constructor FindStorableConstructor(Type type) {
-      foreach (ConstructorInfo ci in type.GetConstructors(ALL_CONSTRUCTORS)) {
-        if (ci.GetCustomAttributes(typeof(StorableConstructorAttribute), false).Length > 0) {
-          if (ci.GetParameters().Length != 1 ||
-              ci.GetParameters()[0].ParameterType != typeof(bool))
-            throw new PersistenceException("StorableConstructor must have exactly one argument of type bool");
-          DynamicMethod dm = new DynamicMethod("", typeof(object), null, type, true);
-          ILGenerator ilgen = dm.GetILGenerator();
-          ilgen.Emit(OpCodes.Ldc_I4_1); // load true
-          ilgen.Emit(OpCodes.Newobj, ci);
-          ilgen.Emit(OpCodes.Ret);
-          return (Constructor)dm.CreateDelegate(typeof(Constructor));
-        }
-      }
-      return null;
-    }
-
-    private void InvokeHook(HookType hookType, object obj) {
-      if (obj == null)
-        throw new ArgumentNullException("Cannot invoke hooks on null");
-      foreach (StorableReflection.Hook hook in GetHooks(hookType, obj.GetType())) {
-        hook(obj);
-      }
-    }
-
-    private IEnumerable<StorableReflection.Hook> GetHooks(HookType hookType, Type type) {
-      lock (hookCache) {
-        List<StorableReflection.Hook> hooks;
-        var designator = new HookDesignator(type, hookType);
-        hookCache.TryGetValue(designator, out hooks);
-        if (hooks != null)
-          return hooks;
-        hooks = new List<StorableReflection.Hook>(StorableReflection.CollectHooks(hookType, type));
-        hookCache.Add(designator, hooks);
-        return hooks;
-      }
-    }
-
-    #endregion
-
-
-
   }