Changeset 15857 for branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Transformers/Transformers.cs

Timestamp:

03/23/18 14:38:14 (6 years ago)

Author:

jkarder

Message:

#2520: worked on conversions

File:

• branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Transformers/Transformers.cs (modified) (1 diff)

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

@@ -848 +848 @@
         typeVersions.Add(Tuple.Create(Guid.Parse(mapper.GetString(parentTypeVersions[i])), parentTypeVersions[i + 1]));
 
-      var originalType = type;
-      var originalTypeInfo = typeInfo;
-
-      foreach (var entry in typeVersions) {
-        var guid = entry.Item1;
-        var version = entry.Item2;
-
-        var conversionMethods = (from methodInfo in Mapper.StaticCache.GetStorableConversions(guid)
-                                 let attrib = StorableConversionAttribute.GetStorableConversionAttribute(methodInfo)
-                                 where attrib.Version >= version
-                                 orderby attrib.Version
-                                 select methodInfo).ToList();
-
-        uint targetVersion;
-
-        try {
-          type = Mapper.StaticCache.GetType(guid);
-          typeInfo = Mapper.StaticCache.GetTypeInfo(type);
-          targetVersion = typeInfo.StorableTypeAttribute.Version;
-        } catch (KeyNotFoundException) {
-          targetVersion = 0;
-        }
-
-        Dictionary<string, object> lastDict = new Dictionary<string, object>();
-        foreach (var conversionMethod in conversionMethods) {
-          if (StorableConversionAttribute.GetVersion(conversionMethod) != version)
-            throw new PersistenceException(string.Format("No conversion method defined for type {0} version {1}", guid, version));
-
-          lastDict = (Dictionary<string, object>)conversionMethod.Invoke(null, new object[] { dict });
-          foreach (var kvp in lastDict) dict[kvp.Key] = kvp.Value;
-
-          version++;
-        }
-
-        if (version < targetVersion)
-          throw new PersistenceException(string.Format("Missing one or more conversion methods for type {0} version {1}", guid, version));
+      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>>();
-      type = originalType;
-      typeInfo = originalTypeInfo;
 
       while (StorableTypeAttribute.IsStorableType(type)) {