Changeset 15529 for branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Core

Timestamp:

12/15/17 13:26:49 (6 years ago)

Author:

jkarder

Message:

#2520: worked on new persistence

• changed message definitions
• updated transformers
• worked on conversions
• cleaned up

Location:

branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Core

Files:

• ComponentInfo.cs (modified) (2 diffs)
• Mapper.cs (modified) (5 diffs)
• StaticCache.cs (modified) (6 diffs)
• StorableConversionAttribute.cs (modified) (2 diffs)
• TypeInfo.cs (modified) (3 diffs)

branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Core/ComponentInfo.cs

@@ -25 +25 @@
   public sealed class ComponentInfo {
     public string Name { get; private set; }
+    public string FullName { get; private set; }
     public MemberInfo MemberInfo { get; private set; }
     public StorableAttribute StorableAttribute { get; private set; }
@@ -30 +31 @@
     public bool Writeable { get; private set; }
 
-    public ComponentInfo(string name, MemberInfo memberInfo, StorableAttribute storableAttribute, bool readable, bool writeable) {
+    public ComponentInfo(string name, string fullName, MemberInfo memberInfo, StorableAttribute storableAttribute, bool readable, bool writeable) {
       Name = name;
+      FullName = fullName;
       MemberInfo = memberInfo;
       StorableAttribute = storableAttribute;

branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Core/Mapper.cs

@@ -60 +60 @@
     private Dictionary<object, uint> object2BoxId;
     private Dictionary<uint, object> boxId2Object;
-    private Index<TypeBox> typeBoxes;
-
     private Index<string> strings;
 
-    private Index<BoolArrayBox> boolArrayBoxes;
-    private Index<IntArrayBox> intArrayBoxes;
-    private Index<UnsignedIntArrayBox> unsignedIntArrayBoxes;
-    private Index<LongArrayBox> longArrayBoxes;
-    private Index<UnsignedLongArrayBox> unsignedLongArrayBoxes;
-    private Index<FloatArrayBox> floatArrayBoxes;
-    private Index<DoubleArrayBox> doubleArrayBoxes;
-
-    private Index<DictionaryBox> dictionaryBoxes;
-    private Index<StorableClassBox> storableClassBoxes;
-
     public uint BoxCount { get; private set; }
-
 
     public Mapper() {
@@ -85 +71 @@
       object2BoxId = new Dictionary<object, uint>(new MappingEqualityComparer());
       boxId2Object = new Dictionary<uint, object>();
-      typeBoxes = new Index<TypeBox>();
-
       strings = new Index<string>();
-
-      boolArrayBoxes = new Index<BoolArrayBox>();
-      intArrayBoxes = new Index<IntArrayBox>();
-      unsignedIntArrayBoxes = new Index<UnsignedIntArrayBox>();
-      longArrayBoxes = new Index<LongArrayBox>();
-      unsignedLongArrayBoxes = new Index<UnsignedLongArrayBox>();
-      floatArrayBoxes = new Index<FloatArrayBox>();
-      doubleArrayBoxes = new Index<DoubleArrayBox>();
-
-      dictionaryBoxes = new Index<DictionaryBox>();
-      storableClassBoxes = new Index<StorableClassBox>();
 
       BoxCount = 0;
@@ -164 +137 @@
       return o;
     }
-
-    #region Referenced Boxes
-    #region TypeBoxes
-    public uint GetTypeBoxId(TypeBox typeBox) { return typeBoxes.GetIndex(typeBox); }
-    public TypeBox GetTypeBox(uint typeBoxId) { return typeBoxes.GetValue(typeBoxId); }
-    #endregion
-
-    #region BoolArrayBox
-    public uint GetBoolArrayBoxId(BoolArrayBox boolArrayBox) { return boolArrayBoxes.GetIndex(boolArrayBox); }
-    public BoolArrayBox GetBoolArrayBox(uint boolArrayBoxId) { return boolArrayBoxes.GetValue(boolArrayBoxId); }
-    #endregion
-
-    #region IntArrayBox
-    public uint GetIntArrayBoxId(IntArrayBox intArrayBox) { return intArrayBoxes.GetIndex(intArrayBox); }
-    public IntArrayBox GetIntArrayBox(uint intArrayBoxId) { return intArrayBoxes.GetValue(intArrayBoxId); }
-    #endregion
-
-    #region UnsignedIntArrayBox
-    public uint GetUnsignedIntArrayBoxId(UnsignedIntArrayBox unsignedIntArrayBox) { return unsignedIntArrayBoxes.GetIndex(unsignedIntArrayBox); }
-    public UnsignedIntArrayBox GetUnsignedIntArrayBox(uint unsignedIntArrayBoxId) { return unsignedIntArrayBoxes.GetValue(unsignedIntArrayBoxId); }
-    #endregion
-
-    #region LongArrayBox
-    public uint GetLongArrayBoxId(LongArrayBox longArrayBox) { return longArrayBoxes.GetIndex(longArrayBox); }
-    public LongArrayBox GetLongArrayBox(uint longArrayBoxId) { return longArrayBoxes.GetValue(longArrayBoxId); }
-    #endregion
-
-    #region UnsignedLongArrayBox
-    public uint GetUnsignedLongArrayBoxId(UnsignedLongArrayBox unsignedLongArrayBox) { return unsignedLongArrayBoxes.GetIndex(unsignedLongArrayBox); }
-    public UnsignedLongArrayBox GetUnsignedLongArrayBox(uint unsignedLongArrayBoxId) { return unsignedLongArrayBoxes.GetValue(unsignedLongArrayBoxId); }
-    #endregion
-
-    #region FloatArrayBox
-    public uint GetFloatArrayBoxId(FloatArrayBox floatArrayBox) { return floatArrayBoxes.GetIndex(floatArrayBox); }
-    public FloatArrayBox GetFloatArrayBox(uint floatArrayBoxId) { return floatArrayBoxes.GetValue(floatArrayBoxId); }
-    #endregion
-
-    #region DoubleArrayBox
-    public uint GetDoubleArrayBoxId(DoubleArrayBox doubleArrayBox) { return doubleArrayBoxes.GetIndex(doubleArrayBox); }
-    public DoubleArrayBox GetDoubleArrayBox(uint doubleArrayBoxId) { return doubleArrayBoxes.GetValue(doubleArrayBoxId); }
-    #endregion
-
-    #region DictionaryBox
-    public uint GetDictionaryBoxId(DictionaryBox dictionaryBox) { return dictionaryBoxes.GetIndex(dictionaryBox); }
-    public DictionaryBox GetDictionaryBox(uint dictionaryBoxId) { return dictionaryBoxes.GetValue(dictionaryBoxId); }
-    #endregion
-
-    #region StorableClassBox
-    public uint GetStorableClassBoxId(StorableClassBox storableClassBox) { return storableClassBoxes.GetIndex(storableClassBox); }
-    public StorableClassBox GetStorableClassBox(uint storableClassBoxId) { return storableClassBoxes.GetValue(storableClassBoxId); }
-    #endregion
-    #endregion
     #endregion
 
@@ -243 +164 @@
       bundle.TypeGuids.AddRange(mapper.types.GetValues().Select(x => ByteString.CopyFrom(StaticCache.GetGuid(x).ToByteArray())));
       bundle.Boxes.AddRange(mapper.boxId2Box.OrderBy(x => x.Key).Select(x => x.Value));
-      bundle.TypeBoxes.AddRange(mapper.typeBoxes.GetValues());
-
       bundle.Strings.AddRange(mapper.strings.GetValues());
-
-      bundle.BoolArrayBoxes.AddRange(mapper.boolArrayBoxes.GetValues());
-      bundle.IntArrayBoxes.AddRange(mapper.intArrayBoxes.GetValues());
-      bundle.UnsignedIntArrayBoxes.AddRange(mapper.unsignedIntArrayBoxes.GetValues());
-      bundle.LongArrayBoxes.AddRange(mapper.longArrayBoxes.GetValues());
-      bundle.UnsignedLongArrayBoxes.AddRange(mapper.unsignedLongArrayBoxes.GetValues());
-      bundle.FloatArrayBoxes.AddRange(mapper.floatArrayBoxes.GetValues());
-      bundle.DoubleArrayBoxes.AddRange(mapper.doubleArrayBoxes.GetValues());
-
-      bundle.DictionaryBoxes.AddRange(mapper.dictionaryBoxes.GetValues());
-      bundle.StorableClassBoxes.AddRange(mapper.storableClassBoxes.GetValues());
 
       return bundle;
@@ -265 +173 @@
       mapper.transformers = new Index<ITransformer>(bundle.TransformerGuids.Select(x => new Guid(x.ToByteArray())).Select(StaticCache.GetTransformer));
       mapper.types = new Index<Type>(bundle.TypeGuids.Select(x => StaticCache.GetType(new Guid(x.ToByteArray()))));
-
       mapper.boxId2Box = bundle.Boxes.Select((b, i) => new { Box = b, Index = i }).ToDictionary(k => (uint)k.Index + 1, v => v.Box);
-      mapper.typeBoxes = new Index<TypeBox>(bundle.TypeBoxes);
-
       mapper.strings = new Index<string>(bundle.Strings);
-
-      mapper.boolArrayBoxes = new Index<BoolArrayBox>(bundle.BoolArrayBoxes);
-      mapper.intArrayBoxes = new Index<IntArrayBox>(bundle.IntArrayBoxes);
-      mapper.unsignedIntArrayBoxes = new Index<UnsignedIntArrayBox>(bundle.UnsignedIntArrayBoxes);
-      mapper.longArrayBoxes = new Index<LongArrayBox>(bundle.LongArrayBoxes);
-      mapper.unsignedLongArrayBoxes = new Index<UnsignedLongArrayBox>(bundle.UnsignedLongArrayBoxes);
-      mapper.floatArrayBoxes = new Index<FloatArrayBox>(bundle.FloatArrayBoxes);
-      mapper.doubleArrayBoxes = new Index<DoubleArrayBox>(bundle.DoubleArrayBoxes);
-
-      mapper.dictionaryBoxes = new Index<DictionaryBox>(bundle.DictionaryBoxes);
-      mapper.storableClassBoxes = new Index<StorableClassBox>(bundle.StorableClassBoxes);
 
       return mapper.GetObject(bundle.RootBoxId);

branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Core/StaticCache.cs

@@ -25 +25 @@
 using System.Drawing;
 using System.Linq;
+using System.Reflection;
 using HeuristicLab.PluginInfrastructure;
 
@@ -36 +37 @@
     private readonly Dictionary<Type, Guid> type2Guid;
     private readonly Dictionary<Type, TypeInfo> typeInfos;
+    private readonly Dictionary<Guid, List<MethodInfo>> guid2ConversionMethods;
 
     internal StaticCache() {
@@ -43 +45 @@
       type2Guid = new Dictionary<Type, Guid>();
       typeInfos = new Dictionary<Type, TypeInfo>();
+      guid2ConversionMethods = new Dictionary<Guid, List<MethodInfo>>();
 
       foreach (var transformer in ApplicationManager.Manager.GetInstances<ITransformer>())
@@ -108 +111 @@
             if (StorableTypeAttribute.IsStorableType(t)) {
               RegisterType(StorableTypeAttribute.GetStorableTypeAttribute(t).Guid, t);
+            }
+            foreach (var mi in t.GetMethods(BindingFlags.NonPublic | BindingFlags.Static)) {
+              if (StorableConversionAttribute.IsStorableConversionMethod(mi)) {
+                RegisterStorableConversion(StorableConversionAttribute.GetStorableConversionAttribute(mi).Guid, mi);
+              }
             }
           }
@@ -149 +157 @@
       }
     }
+    public void RegisterStorableConversion(Guid guid, MethodInfo methodInfo) {
+      lock (locker) {
+        List<MethodInfo> conversionMethods;
+        if (!guid2ConversionMethods.TryGetValue(guid, out conversionMethods))
+          guid2ConversionMethods.Add(guid, conversionMethods = new List<MethodInfo>());
+        conversionMethods.Add(methodInfo);
+      }
+    }
 
     // mainly for testing
@@ -186 +202 @@
       }
     }
+
+    public IEnumerable<MethodInfo> GetStorableConversions(Guid guid) {
+      List<MethodInfo> conversionMethods;
+      if (guid2ConversionMethods.TryGetValue(guid, out conversionMethods)) return conversionMethods;
+      return Enumerable.Empty<MethodInfo>();
+    }
   }
 }

branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Core/StorableConversionAttribute.cs

@@ -27 +27 @@
   public sealed class StorableConversionAttribute : Attribute {
     public Guid Guid { get; private set; }
-    public uint SrcVersion { get; private set; }
+    public uint Version { get; private set; }
 
-    public StorableConversionAttribute(string guid, uint srcVersion) {
+    public StorableConversionAttribute(string guid, uint version) {
       this.Guid = new Guid(guid);
-      this.SrcVersion = srcVersion;
+      this.Version = version;
     }
 
@@ -45 +45 @@
     }
     public static uint GetVersion(MethodInfo mi) {
-      return GetStorableConversionAttribute(mi).SrcVersion;
+      return GetStorableConversionAttribute(mi).Version;
     }
   }

branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Core/TypeInfo.cs

@@ -58 +58 @@
       StorableTypeAttribute = StorableTypeAttribute.GetStorableTypeAttribute(type);
       if (StorableTypeAttribute != null) {
-        // check constructors (
+        string guidPrefix = StorableTypeAttribute.Guid.ToString().ToUpper();
+        // check constructors
         if (!type.IsValueType && !type.IsEnum && !type.IsInterface &&
           GetStorableConstructor() == null && GetDefaultConstructor() == null)
           throw new PersistenceException("No storable constructor or parameterless constructor found.");
-
-        // traverse type hierarchy from base type to sub types
-        Stack<Type> types = new Stack<Type>();
-        while (type != null) {
-          types.Push(type);
-          type = type.BaseType;
-        }
 
         var fields = new List<ComponentInfo>();
@@ -74 +68 @@
         var beforeSerializationHooks = new List<MethodInfo>();
         var afterDeserializationHooks = new List<MethodInfo>();
-        while (types.Count > 0) {
-          type = types.Pop();
-          if (StorableTypeAttribute.MemberSelection != StorableMemberSelection.AllProperties) {
-            var fieldInfos = type.GetFields(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic)
-                                 .Where(x => !x.Name.StartsWith("<") && !x.Name.EndsWith("k__BackingField")); // exclude backing fields
-            if (StorableTypeAttribute.MemberSelection == StorableMemberSelection.MarkedOnly)
-              fieldInfos = fieldInfos.Where(x => StorableAttribute.IsStorable(x)).ToArray();
-            foreach (var field in fieldInfos) {
-              var attrib = StorableAttribute.GetStorableAttribute(field);
-              var name = attrib == null || string.IsNullOrEmpty(attrib.Name) ? field.Name : attrib.Name;
-              fields.Add(new ComponentInfo(type.Name + '.' + name, field, attrib, true, true));
-            }
-          }
 
-          if (StorableTypeAttribute.MemberSelection != StorableMemberSelection.AllFields) {
-            var propertyInfos = type.GetProperties(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic).
-                        Where(x => x.GetIndexParameters().Length == 0);  // exclude indexed properties
-            if (StorableTypeAttribute.MemberSelection == StorableMemberSelection.MarkedOnly)
-              propertyInfos = propertyInfos.Where(x => StorableAttribute.IsStorable(x)).ToArray();
-            foreach (var property in propertyInfos) {
-              var attrib = StorableAttribute.GetStorableAttribute(property);
-              if ((!property.CanRead || !property.CanWrite) && (attrib == null || !attrib.AllowOneWay))
-                throw new PersistenceException("Properties must be readable and writable or explicity enable one way serialization.");
+        if (StorableTypeAttribute.MemberSelection != StorableMemberSelection.AllProperties) {
+          var fieldInfos = type.GetFields(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic)
+                               .Where(x => !x.Name.StartsWith("<") && !x.Name.EndsWith("k__BackingField")); // exclude backing fields
 
-              var name = attrib == null || string.IsNullOrEmpty(attrib.Name) ? property.Name : attrib.Name;
-              properties.Add(new ComponentInfo(type.Name + '.' + name, property, attrib, property.CanRead, property.CanWrite));
-            }
-          }
+          if (StorableTypeAttribute.MemberSelection == StorableMemberSelection.MarkedOnly)
+            fieldInfos = fieldInfos.Where(StorableAttribute.IsStorable).ToArray();
 
-          var methodInfos = type.GetMethods(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic).
-                            Where(x => StorableHookAttribute.IsStorableHook(x)).
-                            Where(x => (x.ReturnType == typeof(void)) && (x.GetParameters().Length == 0));
-          foreach (var method in methodInfos) {
-            foreach (var attrib in StorableHookAttribute.GetStorableHookAttributes(method)) {
-              if (attrib.HookType == HookType.BeforeSerialization)
-                beforeSerializationHooks.Add(method);
-              if (attrib.HookType == HookType.AfterDeserialization)
-                afterDeserializationHooks.Add(method);
-            }
+          foreach (var field in fieldInfos) {
+            var attrib = StorableAttribute.GetStorableAttribute(field);
+            var name = attrib == null || string.IsNullOrEmpty(attrib.Name) ? field.Name : attrib.Name;
+            fields.Add(new ComponentInfo(name, guidPrefix + "." + name, field, attrib, true, true));
           }
         }
+
+        if (StorableTypeAttribute.MemberSelection != StorableMemberSelection.AllFields) {
+          var propertyInfos = type.GetProperties(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic)
+                                  .Where(x => !x.GetIndexParameters().Any());  // exclude indexed properties
+
+          if (StorableTypeAttribute.MemberSelection == StorableMemberSelection.MarkedOnly)
+            propertyInfos = propertyInfos.Where(StorableAttribute.IsStorable).ToArray();
+
+          foreach (var property in propertyInfos) {
+            var attrib = StorableAttribute.GetStorableAttribute(property);
+            if ((!property.CanRead || !property.CanWrite) && (attrib == null || !attrib.AllowOneWay))
+              throw new PersistenceException("Properties must be readable and writable or have one way serialization explicitly enabled.");
+
+            var name = attrib == null || string.IsNullOrEmpty(attrib.Name) ? property.Name : attrib.Name;
+            properties.Add(new ComponentInfo(name, guidPrefix + "." + name, property, attrib, property.CanRead, property.CanWrite));
+          }
+        }
+
+        var methodInfos = type.GetMethods(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic)
+                              .Where(StorableHookAttribute.IsStorableHook)
+                              .Where(x => x.ReturnType == typeof(void) && !x.GetParameters().Any());
+
+        foreach (var method in methodInfos) {
+          foreach (var attrib in StorableHookAttribute.GetStorableHookAttributes(method)) {
+            if (attrib.HookType == HookType.BeforeSerialization)
+              beforeSerializationHooks.Add(method);
+            if (attrib.HookType == HookType.AfterDeserialization)
+              afterDeserializationHooks.Add(method);
+          }
+        }
+
         Fields = fields;
         Properties = properties;
@@ -155 +153 @@
 
     private ConstructorInfo GetStorableConstructor() {
-      return Type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
-               .Where(x => StorableConstructorAttribute.IsStorableConstructor(x))
-               .Where(x => (x.GetParameters().Length == 1) && (x.GetParameters()[0].ParameterType == typeof(StorableConstructorFlag)))
-               .FirstOrDefault();
+      return (from ctor in Type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+              let parameters = ctor.GetParameters()
+              where StorableConstructorAttribute.IsStorableConstructor(ctor)
+                 && parameters.Length == 1
+                 && parameters[0].ParameterType == typeof(StorableConstructorFlag)
+              select ctor).FirstOrDefault();
     }
 
     private ConstructorInfo GetDefaultConstructor() {
-      return Type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
-                             null, Type.EmptyTypes, null);
+      return Type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
     }
   }