Changeset 15986 for branches/PersistenceReintegration/HeuristicLab.Persistence

Timestamp:

07/05/18 17:22:34 (6 years ago)

Author:

jkarder

Message:

#2520: worked on new persistence

• removed type version
• removed conversions
• execute AfterDeserialization hooks after all objects have been populated
• worked on transformers

Location:

branches/PersistenceReintegration/HeuristicLab.Persistence/4.0

Files:

• Core/Index.cs (modified) (1 diff)
• Core/Mapper.cs (modified) (3 diffs)
• Core/StaticCache.cs (modified) (3 diffs)
• Core/StorableConversionAttribute.cs (deleted)
• Core/StorableTypeAttribute.cs (modified) (2 diffs)
• Core/TypeInfo.cs (modified) (2 diffs)
• HeuristicLab.Persistence-4.0.csproj (modified) (1 diff)
• Protos/PersistenceMessages.proto (modified) (1 diff)
• Transformers/Transformers.cs (modified) (10 diffs)

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

@@ -59 +59 @@
     }
 
+    public bool TryGetValue(uint index, out T value) {
+      return values.TryGetValue(index, out value);
+    }
+
     public IEnumerable<T> GetValues() {
       return values.Values;

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

@@ -93 +93 @@
     public Type GetType(uint typeId) {
       return types.GetValue(typeId);
+    }
+
+    public bool TryGetType(uint typeId, out Type type) {
+      return types.TryGetValue(typeId, out type);
     }
     #endregion
@@ -132 +136 @@
         o = transformer.ToObject(box, this);
         boxId2Object.Add(boxId, o);
-        transformer.FillFromBox(o, box, this);
+        if (o != null) transformer.FillFromBox(o, box, this);
       }
 
@@ -176 +180 @@
       mapper.strings = new Index<string>(bundle.Strings);
 
-      return mapper.GetObject(bundle.RootBoxId);
+      var root = mapper.GetObject(bundle.RootBoxId);
+
+      ExecuteAfterDeserializationHooks(mapper.boxId2Object.Values.ToArray());
+
+      return root;
+    }
+
+    private static void ExecuteAfterDeserializationHooks(object[] objects) {
+      var emptyArgs = new object[0];
+
+      foreach (var obj in objects) {
+        if (!StorableTypeAttribute.IsStorableType(obj.GetType())) continue; // TODO: performance
+
+        var typeStack = new Stack<Type>();
+        for (var type = obj.GetType(); type != null; type = type.BaseType) {
+          typeStack.Push(type);
+        }
+
+        while (typeStack.Any()) {
+          var type = typeStack.Pop();
+          if (!StorableTypeAttribute.IsStorableType(type)) continue; // object <- mytype (has hooks) or object <- valuetype <- mystruct
+
+          var typeInfo = staticCache.GetTypeInfo(type);
+          foreach (var hook in typeInfo.AfterDeserializationHooks) {
+            hook.Invoke(obj, emptyArgs);
+          }
+        }
+      }
     }
   }

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

@@ -68 +68 @@
       RegisterType(new Guid("724A2D49-7E7B-455B-BBA9-4214C64E8A21"), typeof(TimeSpan));
       RegisterType(new Guid("ECC12A57-DA8D-43D9-9EC7-FCAC878A4D69"), typeof(Font));
+      RegisterType(new Guid("494C1352-A1C3-47A3-8754-A0B19B8F1567"), typeof(FontStyle));
+      RegisterType(new Guid("41147B67-4C7A-4907-9F6C-509568395EDB"), typeof(GraphicsUnit));
       RegisterType(new Guid("E8348C94-9817-4164-9C98-377689F83F30"), typeof(Bitmap));
       RegisterType(new Guid("05551382-E894-4218-B860-FEE1D92CA07D"), typeof(Nullable<>));
@@ -111 +113 @@
             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);
-              }
             }
           }
@@ -194 +191 @@
       }
     }
-
-    public IEnumerable<MethodInfo> GetStorableConversions(Guid guid) {
-      List<MethodInfo> conversionMethods;
-      if (guid2ConversionMethods.TryGetValue(guid, out conversionMethods)) return conversionMethods;
-      return Enumerable.Empty<MethodInfo>();
-    }
-
-    public IEnumerable<MethodInfo> GetStorableConversions(IList<Tuple<Guid, uint>> typeChain) {
-      foreach (var type in typeChain) {
-        var conversionMethod = (from methodInfo in GetStorableConversions(type.Item1)
-                                let attrib = StorableConversionAttribute.GetStorableConversionAttribute(methodInfo)
-                                where attrib.Version == type.Item2 && (attrib.Dependencies == null || 
-                                  attrib.Dependencies.All(x => typeChain.Any(y => y.Item1 == Guid.Parse(x.Key) && y.Item2 == x.Value)))
-                                select methodInfo).SingleOrDefault();
-        if (conversionMethod != null)
-          yield return conversionMethod;
-      }
-    }
   }
 }

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

@@ -37 +37 @@
 
     public Guid Guid { get; private set; }
-    public uint Version { get; private set; }
 
     /// <summary>
@@ -43 +42 @@
     /// </summary>
     /// <param name="memberSelection">The storable class memberSelection.</param>
-    public StorableTypeAttribute(StorableMemberSelection memberSelection, string guid, uint version = 1) {
+    public StorableTypeAttribute(StorableMemberSelection memberSelection, string guid) {
       MemberSelection = memberSelection;
       Guid = new Guid(guid);
-      Version = version;
     }
 
-    public StorableTypeAttribute(string guid, uint version = 1) {
+    public StorableTypeAttribute(string guid) {
       Guid = new Guid(guid);
-      Version = version;
     }
 

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

@@ -70 +70 @@
 
         if (StorableTypeAttribute.MemberSelection != StorableMemberSelection.AllProperties) {
-          var fieldInfos = type.GetFields(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic)
+          // TODO: improved performance for static fields
+          var fieldInfos = type.GetFields(BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic)
                                .Where(x => !x.Name.StartsWith("<") && !x.Name.EndsWith("k__BackingField")); // exclude backing fields
 
@@ -84 +85 @@
 
         if (StorableTypeAttribute.MemberSelection != StorableMemberSelection.AllFields) {
-          var propertyInfos = type.GetProperties(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic)
+          // TODO: improved performance for static properties
+          var propertyInfos = type.GetProperties(BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic)
                                   .Where(x => !x.GetIndexParameters().Any());  // exclude indexed properties
 

branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/HeuristicLab.Persistence-4.0.csproj

@@ -65 +65 @@
     <Compile Include="Core\StorableTypeAttribute.cs" />
     <Compile Include="Core\Transformer.cs" />
-    <Compile Include="Core\StorableConversionAttribute.cs" />
     <Compile Include="Core\TransformerAttribute.cs" />
     <Compile Include="Core\TypeInfo.cs" />

branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Protos/PersistenceMessages.proto

@@ -17 +17 @@
 
   uint32 type_id = 10;
-  uint32 type_version = 11;
-  repeated uint32 generic_type_box_ids = 12;
+  repeated uint32 generic_type_box_ids = 11;
 
   bool bool = 20;

branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Transformers/Transformers.cs

@@ -48 +48 @@
 
     public override object ToObject(Box box, Mapper mapper) {
-      return Extract(box, (Type)mapper.GetObject(box.TypeBoxId), mapper);
+      var type = (Type)mapper.GetObject(box.TypeBoxId);
+      return type == null ? default(T) : Extract(box, type, mapper);
     }
 
@@ -80 +81 @@
         box.TypeId = mapper.GetTypeId(type);
       }
-
-      if (StorableTypeAttribute.IsStorableType(type))
-        box.TypeVersion = StorableTypeAttribute.GetStorableTypeAttribute(type).Version;
     }
 
     public override object ToObject(Box box, Mapper mapper) {
-      return Extract(box, mapper.GetType(box.TypeId), mapper);
+      Type type;
+      return mapper.TryGetType(box.TypeId, out type) ? Extract(box, type, mapper) : null;
     }
 
     private object Extract(Box box, Type type, Mapper mapper) {
       if (type.IsGenericType) {
-        return type.MakeGenericType(box.GenericTypeBoxIds.Select(x => (Type)mapper.GetObject(x)).ToArray());
+        var genericArgumentTypes = box.GenericTypeBoxIds.Select(x => (Type)mapper.GetObject(x)).ToArray();
+        return genericArgumentTypes.Any(x => x == null) ? null : type.MakeGenericType(genericArgumentTypes);
       } else if (type == typeof(Array)) {
-        return ((Type)mapper.GetObject(box.GenericTypeBoxIds[0])).MakeArrayType();
+        var arrayType = (Type)mapper.GetObject(box.GenericTypeBoxIds[0]);
+        return arrayType?.MakeArrayType();
       } else {
         return type;
@@ -526 +527 @@
         var box = new Box {
           TransformerId = mapper.GetTransformerId(this),
-          TypeId = mapper.GetStringId(o.GetType().AssemblyQualifiedName),
-          UInt = mapper.GetStringId(Enum.Format(o.GetType(), o, "G")),
+          TypeBoxId = mapper.GetBoxId(o.GetType()),
+          UInt = mapper.GetStringId(Enum.Format(o.GetType(), o, "G")) // TODO: introduce old names for enum values to enable refactoring
         };
         return box;
@@ -533 +534 @@
 
       public override object ToObject(Box box, Mapper mapper) {
-        return Enum.Parse(Type.GetType(mapper.GetString(box.TypeId)), mapper.GetString(box.UInt));
+        var type = (Type)mapper.GetObject(box.TypeBoxId);
+        return type == null ? null : Enum.Parse(type, mapper.GetString(box.UInt));
       }
     }
@@ -784 +786 @@
     protected override void Populate(Box box, object value, Mapper mapper) {
       var kvps = box.KeyValuePairs;
-      var parentTypeVersions = box.UInts;
       var emptyArgs = new object[0];
 
@@ -815 +816 @@
         }
 
-        if (type != originalType) {
-          parentTypeVersions.AddRange(new[] { mapper.GetStringId(guid.ToString()), attribute.Version });
-        }
-
         type = type.BaseType;
       }
@@ -829 +826 @@
     public override void FillFromBox(object obj, Box box, Mapper mapper) {
       var kvps = box.KeyValuePairs;
-      var parentTypeVersions = box.UInts;
       var emptyArgs = new object[0];
 
@@ -840 +836 @@
 
       var type = (Type)mapper.GetObject(box.TypeBoxId);
-      var typeBox = mapper.GetBox(box.TypeBoxId);
       var typeInfo = Mapper.StaticCache.GetTypeInfo(type);
-
-      var typeVersions = new List<Tuple<Guid, uint>>();
-      typeVersions.Add(Tuple.Create(typeInfo.StorableTypeAttribute.Guid, typeBox.TypeVersion));
-      for (int i = 0; i < parentTypeVersions.Count; i += 2)
-        typeVersions.Add(Tuple.Create(Guid.Parse(mapper.GetString(parentTypeVersions[i])), parentTypeVersions[i + 1]));
-
-      while (true) {
-        var applicableConversion = Mapper.StaticCache.GetStorableConversions(typeVersions).FirstOrDefault();
-        if (applicableConversion == null) break;
-
-        Dictionary<string, object> newDict;
-        List<Tuple<string, uint>> typeChain = null;
-
-        var conversionParameters = applicableConversion.GetParameters();
-        if (conversionParameters.Length == 1) {
-          newDict = (Dictionary<string, object>)applicableConversion.Invoke(null, new object[] { dict });
-        } else if (conversionParameters.Length == 2) {
-          var parameters = new object[] { dict, typeChain };
-          newDict = (Dictionary<string, object>)applicableConversion.Invoke(null, parameters);
-          typeChain = (List<Tuple<string, uint>>)parameters[1];
-        } else throw new PersistenceException("Conversion method has an invalid signature.");
-
-        foreach (var kvp in newDict) dict[kvp.Key] = kvp.Value;
-
-        var convertedType = StorableConversionAttribute.GetGuid(applicableConversion);
-        var convertedVersion = StorableConversionAttribute.GetVersion(applicableConversion);
-
-        var index = typeVersions.FindIndex(x => x.Item1 == convertedType);
-        typeVersions.RemoveAt(index);
-        typeVersions.Insert(index, Tuple.Create(convertedType, convertedVersion + 1));
-
-        if (typeChain != null && typeChain.Any()) {
-          typeVersions.RemoveRange(index + 1, typeVersions.Count - (index + 1));
-          typeVersions.AddRange(typeChain.Select(x => Tuple.Create(Guid.Parse(x.Item1), x.Item2)));
-        }
-      }
-
       var typeStack = new Stack<Tuple<Type, TypeInfo>>();
 
@@ -905 +863 @@
         }
 
-        // set all members as generated by conversion method chain
+        // set all members
         foreach (var kvp in dict) {
           string key = kvp.Key;
@@ -940 +898 @@
         //    typeInfo.StorableTypeAttribute.Version,
         //    string.Join(", ", undefinedMembers.Select(x => x.Key))));
-
-        foreach (var hook in typeInfo.AfterDeserializationHooks) {
-          hook.Invoke(obj, emptyArgs);
-        }
       }
     }