Changeset 15509 for branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Core/Mapper.cs

Timestamp:

12/11/17 17:46:11 (6 years ago)

Author:

jkarder

Message:

#2520: worked on new persistence

• changed message definitions
• updated transformers
• cleaned up

File:

• branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Core/Mapper.cs (modified) (6 diffs)

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

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Linq;
-using Google.ProtocolBuffers;
+using Google.Protobuf;
 
 namespace HeuristicLab.Persistence {
@@ -43 +43 @@
     }
 
-    private static StaticCache staticCache = null;
+    private static StaticCache staticCache;
     private static object locker = new object();
     public static StaticCache StaticCache {
@@ -56 +56 @@
     private Index<ITransformer> transformers;
     private Index<Type> types;
-    private Index<string> strings;
+
     private Dictionary<uint, Box> boxId2Box;
     private Dictionary<object, uint> object2BoxId;
-    private Dictionary<uint, object> boxId2object;
+    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() {
       transformers = new Index<ITransformer>();
       types = new Index<Type>();
-      strings = new Index<string>();
+
       boxId2Box = new Dictionary<uint, Box>();
       object2BoxId = new Dictionary<object, uint>(new MappingEqualityComparer());
-      boxId2object = new Dictionary<uint, object>();
+      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;
     }
 
+    #region Transformers
     public uint GetTransformerId(ITransformer transformer) {
       return transformers.GetIndex(transformer);
     }
+
     public ITransformer GetTransformer(uint transformerId) {
       return transformers.GetValue(transformerId);
     }
-
+    #endregion
+
+    #region Types
     public uint GetTypeId(Type type) {
       return types.GetIndex(type);
     }
+
     public Type GetType(uint typeId) {
       return types.GetValue(typeId);
     }
-
-    public uint GetStringId(string str) {
-      return strings.GetIndex(str);
-    }
-    public string GetString(uint stringId) {
-      return strings.GetValue(stringId);
-    }
-
-    public Box GetBox(uint boxId) {
-      return boxId2Box[boxId];
-    }
+    #endregion
+
+    #region Boxes
     public uint GetBoxId(object o) {
       uint boxId;
@@ -115 +141 @@
       return boxId;
     }
+
+    public Box GetBox(uint boxId) {
+      return boxId2Box[boxId];
+    }
+
     public object GetObject(uint boxId) {
       object o;
-      if (boxId2object.TryGetValue(boxId, out o)) return o;
+      if (boxId2Object.TryGetValue(boxId, out o)) return o;
 
       Box box;
@@ -127 +158 @@
         var transformer = transformers.GetValue(box.TransformerId);
         o = transformer.ToObject(box, this);
-        boxId2object.Add(boxId, o);
+        boxId2Object.Add(boxId, o);
         transformer.FillFromBox(o, box, this);
       }
+
       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
+
+    #region Strings
+    public uint GetStringId(string str) {
+      return strings.GetIndex(str);
+    }
+    public string GetString(uint stringId) {
+      return strings.GetValue(stringId);
+    }
+    #endregion
 
     public object CreateInstance(Type type) {
@@ -143 +237 @@
     public static Bundle ToBundle(object o) {
       var mapper = new Mapper();
-      var bundle = Bundle.CreateBuilder();
+      var bundle = new Bundle();
+
       bundle.RootBoxId = mapper.GetBoxId(o);
-      bundle.AddRangeTransformerGuids(mapper.transformers.GetValues().Select(x => x.Guid).Select(x => ByteString.CopyFrom(x.ToByteArray())));
-      bundle.AddRangeTypeGuids(mapper.types.GetValues().Select(x => ByteString.CopyFrom(StaticCache.GetGuid(x).ToByteArray())));
-      bundle.AddRangeStrings(mapper.strings.GetValues());
-      bundle.AddRangeBoxes(mapper.boxId2Box.OrderBy(x => x.Key).Select(x => x.Value));
-      return bundle.Build();
+      bundle.TransformerGuids.AddRange(mapper.transformers.GetValues().Select(x => x.Guid).Select(x => ByteString.CopyFrom(x.ToByteArray())));
+      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;
     }
     public static object ToObject(Bundle bundle) {
       var mapper = new Mapper();
-      mapper.types = new Index<Type>(bundle.TypeGuidsList.Select(x => StaticCache.GetType(new Guid(x.ToByteArray()))));
-      mapper.strings = new Index<string>(bundle.StringsList);
-      mapper.boxId2Box = bundle.BoxesList.Select((b, i) => new { Box = b, Index = i }).ToDictionary(k => (uint)k.Index + 1, v => v.Box);
-      mapper.transformers = new Index<ITransformer>(bundle.TransformerGuidsList.Select(x => new Guid(x.ToByteArray())).Select(x => StaticCache.GetTransformer(x)));
+
+      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);
     }