Changeset 1960

Timestamp:

05/29/09 16:44:27 (16 years ago)

Author:

epitzer

Message:

Refactoring of storables. (#603)

Location:

trunk/sources/HeuristicLab.Persistence

Files:

• 3.3/Default/CompositeSerializers/Storable/StorableAttribute.cs (modified) (4 diffs)
• 3.3/Default/CompositeSerializers/Storable/StorableSerializer.cs (modified) (2 diffs)
• UnitTests/StorableAttributeTests.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableAttribute.cs

@@ -1 +1 @@
 using System;
+using System.Linq;
 using System.Collections.Generic;
 using System.Reflection;
@@ -42 +43 @@
       public StorableAttribute Attribute { get; private set; }
       public MemberInfo MemberInfo { get; private set; }
+      public string DisentangledName { get; private set; }
+      public string FullyQualifiedMemberName {
+        get {
+          return new StringBuilder()
+            .Append(MemberInfo.ReflectedType.FullName)
+            .Append('.')
+            .Append(MemberInfo.Name)
+            .ToString();
+        }
+      }
       public StorableMemberInfo(StorableAttribute attribute, MemberInfo memberInfo) {
         this.Attribute = attribute;
@@ -50 +61 @@
           .Append('[').Append(Attribute).Append(", ")
           .Append(MemberInfo).Append('}').ToString();
+      }
+      public void SetDisentangledName(string name) {
+        DisentangledName = Attribute.Name ?? name;
+      }
+      public Type GetPropertyDeclaringBaseType() {
+        return ((PropertyInfo)MemberInfo).GetGetMethod(true).GetBaseDefinition().DeclaringType;
       }
     }
@@ -91 +108 @@
         }
       }
-      return storableMembers;
+      return DisentangleNameMapping(storableMembers);
     }
 
-    public static Dictionary<string, DataMemberAccessor> GetStorableAccessors(object obj) {
-      var storableAccessors = new Dictionary<string, DataMemberAccessor>();
-      var nameMapping = createNameMapping(obj.GetType());
-      var finalNameMapping = analyzeNameMapping(nameMapping);
-      foreach (var mapping in finalNameMapping) {
-        storableAccessors.Add(mapping.Value.Attribute.Name ?? mapping.Key,
-          new DataMemberAccessor(
-            mapping.Value.MemberInfo,
-            mapping.Value.Attribute.Name ?? mapping.Key,
-            mapping.Value.Attribute.DefaultValue,
-            obj));
-      }
-      return storableAccessors;
+    public static IEnumerable<DataMemberAccessor> GetStorableAccessors(object obj) {      
+      foreach (var memberInfo in GetStorableMembers(obj.GetType()))
+        yield return new DataMemberAccessor(
+          memberInfo.MemberInfo,
+          memberInfo.DisentangledName,
+          memberInfo.Attribute.DefaultValue,
+          obj);      
     }
 
-    private static Dictionary<string, StorableMemberInfo> analyzeNameMapping(
-        Dictionary<string, List<StorableMemberInfo>> nameMapping) {
-      var finalNameMapping = new Dictionary<string, StorableMemberInfo>();
-      foreach (var attributes in nameMapping) {
-        if (attributes.Value.Count == 1) {
-          finalNameMapping[attributes.Key] = attributes.Value[0];
-        } else if (attributes.Value[0].MemberInfo.MemberType == MemberTypes.Field) {
-          foreach (var attribute in attributes.Value) {
-            StringBuilder sb = new StringBuilder();
-            sb.Append(attribute.MemberInfo.ReflectedType.FullName).Append('.')
-              .Append(attribute.MemberInfo.Name);
-            finalNameMapping[sb.ToString()] = attribute;
+    private static IEnumerable<StorableMemberInfo> DisentangleNameMapping(
+        IEnumerable<StorableMemberInfo> storableMemberInfos) {
+      var nameGrouping = new Dictionary<string, List<StorableMemberInfo>>();
+      foreach (StorableMemberInfo storable in storableMemberInfos) {
+        if (!nameGrouping.ContainsKey(storable.MemberInfo.Name))
+          nameGrouping[storable.MemberInfo.Name] = new List<StorableMemberInfo>();
+        nameGrouping[storable.MemberInfo.Name].Add(storable);
+      }
+      var memberInfos = new List<StorableMemberInfo>();
+      foreach (var storableMemberInfoGroup in nameGrouping.Values) {        
+        if (storableMemberInfoGroup.Count == 1) {
+          storableMemberInfoGroup[0].SetDisentangledName(storableMemberInfoGroup[0].MemberInfo.Name);
+          memberInfos.Add(storableMemberInfoGroup[0]);
+        } else if (storableMemberInfoGroup[0].MemberInfo.MemberType == MemberTypes.Field) {
+          foreach (var storableMemberInfo in storableMemberInfoGroup) {            
+            storableMemberInfo.SetDisentangledName(storableMemberInfo.FullyQualifiedMemberName);
+            memberInfos.Add(storableMemberInfo);
           }
-        } else {
-          var uniqueAccessors = new Dictionary<Type, StorableMemberInfo>();
-          foreach (var attribute in attributes.Value) {
-            uniqueAccessors[((PropertyInfo)attribute.MemberInfo).GetGetMethod(true).GetBaseDefinition().DeclaringType] =
-              attribute;
-          }
-          if (uniqueAccessors.Count == 1) {
-            var it = uniqueAccessors.Values.GetEnumerator();
-            it.MoveNext();
-            finalNameMapping[attributes.Key] = it.Current;
-          } else {
-            foreach (var attribute in uniqueAccessors.Values) {
-              StringBuilder sb = new StringBuilder();
-              sb.Append(attribute.MemberInfo.DeclaringType.FullName).Append('.')
-                .Append(attribute.MemberInfo.Name);
-              finalNameMapping[sb.ToString()] = attribute;
-            }
-          }
+        } else {          
+          memberInfos.AddRange(MergePropertyAccessors(storableMemberInfoGroup));
         }
       }
-      return finalNameMapping;
+      return memberInfos;
     }
-
-    private static Dictionary<string, List<StorableMemberInfo>> createNameMapping(Type type) {
-      var nameMapping = new Dictionary<string, List<StorableMemberInfo>>();
-      foreach (StorableMemberInfo storable in GetStorableMembers(type)) {
-        if (!nameMapping.ContainsKey(storable.MemberInfo.Name))
-          nameMapping[storable.MemberInfo.Name] = new List<StorableMemberInfo>();
-        nameMapping[storable.MemberInfo.Name].Add(storable);
+    
+    private static IEnumerable<StorableMemberInfo> MergePropertyAccessors(List<StorableMemberInfo> members) {
+      var uniqueAccessors = new Dictionary<Type, StorableMemberInfo>();
+      foreach (var member in members)
+        uniqueAccessors[member.GetPropertyDeclaringBaseType()] = member;                  
+      if (uniqueAccessors.Count == 1) {
+        var storableMemberInfo = uniqueAccessors.Values.First();
+        storableMemberInfo.SetDisentangledName(storableMemberInfo.MemberInfo.Name);
+        yield return storableMemberInfo;
+      } else {
+        foreach (var attribute in uniqueAccessors.Values) {
+          attribute.SetDisentangledName(attribute.FullyQualifiedMemberName);
+          yield return attribute;
+        }
       }
-      return nameMapping;
-    }
+    }    
   }
 }

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableSerializer.cs

@@ -33 +33 @@
 
     public IEnumerable<Tag> Decompose(object obj) {
-      foreach (var mapping in StorableAttribute.GetStorableAccessors(obj)) {
-        yield return new Tag(mapping.Key, mapping.Value.Get());
+      foreach (var accessor in StorableAttribute.GetStorableAccessors(obj)) {
+        yield return new Tag(accessor.Name, accessor.Get());
       }
     }
@@ -48 +48 @@
         memberDict.Add(iter.Current.Name, iter.Current);
       }
-      foreach (var mapping in StorableAttribute.GetStorableAccessors(instance)) {
-        string name = mapping.Key;
-        if (memberDict.ContainsKey(name)) {
-          mapping.Value.Set(memberDict[name].Value);
-        } else if (mapping.Value.DefaultValue != null) {
-          mapping.Value.Set(mapping.Value.DefaultValue);
+      foreach (var accessor in StorableAttribute.GetStorableAccessors(instance)) {        
+        if (memberDict.ContainsKey(accessor.Name)) {
+          accessor.Set(memberDict[accessor.Name].Value);          
+        } else if (accessor.DefaultValue != null) {
+          accessor.Set(accessor.DefaultValue);          
         }
       }

trunk/sources/HeuristicLab.Persistence/UnitTests/StorableAttributeTests.cs

@@ -56 +56 @@
     public void SimpleStorableAttributeTest() {
       DemoClass t = new DemoClass();
-      Dictionary<string, DataMemberAccessor> accessors = StorableAttribute.GetStorableAccessors(t);
+      IEnumerable<DataMemberAccessor> accessorList = StorableAttribute.GetStorableAccessors(t);
+      Dictionary<string, DataMemberAccessor> accessors = new Dictionary<string, DataMemberAccessor>();
+      foreach (var a in accessorList)
+        accessors.Add(a.Name, a);
       Assert.IsTrue(accessors.ContainsKey("TestProperty"));
       Assert.IsTrue(accessors.ContainsKey("x"));
@@ -78 +81 @@
       var accessDict = new Dictionary<string, DataMemberAccessor>();
       foreach (var accessor in accessors) // assert uniqueness
-        accessDict.Add(accessor.Key, accessor.Value);
+        accessDict.Add(accessor.Name, accessor);
       Assert.IsTrue(accessDict.ContainsKey(typeof(New).FullName + ".Name"));
       Assert.IsTrue(accessDict.ContainsKey(typeof(Override).FullName + ".Name"));