Changeset 1938

Timestamp:

05/28/09 18:06:43 (15 years ago)

Author:

epitzer

Message:

Resolve name clashes of overridden and shadowed properties (#659)

Location:

trunk/sources/HeuristicLab.Persistence

Files:

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

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

@@ -12 +12 @@
     public readonly object DefaultValue;
 
-    public DataMemberAccessor(
-        MemberInfo memberInfo,
-        StorableAttribute storableAttribute,
-        object obj) {
+    public DataMemberAccessor(MemberInfo memberInfo, string name, object defaultvalue, object obj) {
+      Name = name;
+      DefaultValue = defaultvalue;
       if (memberInfo.MemberType == MemberTypes.Field) {
         FieldInfo fieldInfo = (FieldInfo)memberInfo;
@@ -32 +31 @@
           "The Storable attribute can only be applied to fields and properties.");
       }
-      Name = storableAttribute.Name ?? memberInfo.Name;
-      DefaultValue = storableAttribute.DefaultValue;
     }
 
-    public DataMemberAccessor(
-        string name, object defaultValue,
+    public DataMemberAccessor(string name, object defaultValue,
         Func<object> getter, Action<object> setter) {
       Name = name;
@@ -61 +57 @@
 
     public override string ToString() {
-      return String.Format("DataMember({0}, {1}, {2}, {3})",
+      return String.Format("DataMemberAccessor({0}, {1}, {2}, {3})",
         Name,
         DefaultValue ?? "<null>",

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

@@ -2 +2 @@
 using System.Collections.Generic;
 using System.Reflection;
+using System.Text;
 
 namespace HeuristicLab.Persistence.Default.CompositeSerializers.Storable {
@@ -14 +15 @@
     public object DefaultValue { get; set; }
 
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      sb.Append("[Storable");
+      if (Name != null || DefaultValue != null)
+        sb.Append('(');
+      if (Name != null) {
+        sb.Append("Name = \"").Append(Name).Append("\"");
+        if (DefaultValue != null)
+          sb.Append(", ");
+      }
+      if (DefaultValue != null)
+        sb.Append("DefaultValue = \"").Append(DefaultValue).Append("\"");
+      if (Name != null || DefaultValue != null)
+        sb.Append(')');
+      sb.Append(']');
+      return sb.ToString();
+    }
+
     private const BindingFlags instanceMembers =
       BindingFlags.Instance |
@@ -20 +39 @@
       BindingFlags.DeclaredOnly;
 
-    private static Dictionary<KeyValuePair<Type, bool>, IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>>> memberCache =
-      new Dictionary<KeyValuePair<Type, bool>, IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>>>();
+    public sealed class StorableMemberInfo {
+      public StorableAttribute Attribute { get; private set; }
+      public MemberInfo MemberInfo { get; private set; }
+      public StorableMemberInfo(StorableAttribute attribute, MemberInfo memberInfo) {
+        this.Attribute = attribute;
+        this.MemberInfo = memberInfo;
+      }
+      public override string ToString() {
+        return new StringBuilder()
+          .Append('[').Append(Attribute).Append(", ")
+          .Append(MemberInfo).Append('}').ToString();
+      }
+    }
 
-    public static IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>> GetStorableMembers(Type type) {
+    sealed class TypeQuery {
+      public Type Type { get; private set; }
+      public bool Inherited { get; private set; }
+      public TypeQuery(Type type, bool inherited) {
+        this.Type = type;
+        this.Inherited = inherited;
+      }
+    }
+
+    sealed class MemberCache : Dictionary<TypeQuery, IEnumerable<StorableMemberInfo>> { }
+
+    private static MemberCache memberCache = new MemberCache();
+
+    public static IEnumerable<StorableMemberInfo> GetStorableMembers(Type type) {
       return GetStorableMembers(type, true);
     }
 
-    public static IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>>
-        GetStorableMembers(Type type, bool inherited) {
-      var query = new KeyValuePair<Type, bool>(type, inherited);
+    public static IEnumerable<StorableMemberInfo> GetStorableMembers(Type type, bool inherited) {
+      var query = new TypeQuery(type, inherited);
       if (memberCache.ContainsKey(query))
         return memberCache[query];
-      IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>> storablesMembers = GenerateStorableMembers(type, inherited);
+      var storablesMembers = GenerateStorableMembers(type, inherited);
       memberCache[query] = storablesMembers;
       return storablesMembers;
     }
 
-    public static IEnumerable<KeyValuePair<StorableAttribute, MemberInfo>>
-        GenerateStorableMembers(Type type, bool inherited) {
-      List<KeyValuePair<StorableAttribute, MemberInfo>> storableMembers =
-        new List<KeyValuePair<StorableAttribute, MemberInfo>>();
+    private static IEnumerable<StorableMemberInfo> GenerateStorableMembers(Type type, bool inherited) {
+      var storableMembers = new List<StorableMemberInfo>();
       if (inherited && type.BaseType != null)
-        storableMembers.AddRange(GenerateStorableMembers(type.BaseType, true));        
+        storableMembers.AddRange(GenerateStorableMembers(type.BaseType, true));
       foreach (MemberInfo memberInfo in type.GetMembers(instanceMembers)) {
         foreach (object attribute in memberInfo.GetCustomAttributes(false)) {
-          StorableAttribute storableAttribute =
-            attribute as StorableAttribute;
+          StorableAttribute storableAttribute = attribute as StorableAttribute;
           if (storableAttribute != null) {
-            storableMembers.Add(new KeyValuePair<StorableAttribute, MemberInfo>(storableAttribute, memberInfo));
+            storableMembers.Add(new StorableMemberInfo(storableAttribute, memberInfo));
           }
         }
@@ -56 +95 @@
 
     public static Dictionary<string, DataMemberAccessor> GetStorableAccessors(object obj) {
-      Dictionary<string, DataMemberAccessor> storableAccessors =
-        new Dictionary<string, DataMemberAccessor>();
-      foreach (KeyValuePair<StorableAttribute, MemberInfo> pair in GetStorableMembers(obj.GetType())) {
-        storableAccessors.Add(pair.Value.Name,
-          new DataMemberAccessor(pair.Value, pair.Key, 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;
     }
+
+    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;
+          }
+        } 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;
+            }
+          }
+        }
+      }
+      return finalNameMapping;
+    }
+
+    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);
+      }
+      return nameMapping;
+    }
   }
 }

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

@@ -34 +34 @@
     public IEnumerable<Tag> Decompose(object obj) {
       foreach (var mapping in StorableAttribute.GetStorableAccessors(obj)) {
-        yield return new Tag(mapping.Value.Name ?? mapping.Key, mapping.Value.Get());
+        yield return new Tag(mapping.Key, mapping.Value.Get());
       }
     }
@@ -49 +49 @@
       }
       foreach (var mapping in StorableAttribute.GetStorableAccessors(instance)) {
-        string name = mapping.Value.Name ?? mapping.Key;
+        string name = mapping.Key;
         if (memberDict.ContainsKey(name)) {
           mapping.Value.Set(memberDict[name].Value);

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

@@ -4 +4 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Reflection;
 
 namespace HeuristicLab.Persistence.Test {
@@ -19 +20 @@
   }
 
+  class Base {
+    public string baseName;
+    [Storable]
+    public virtual string Name {
+      get { return "Base"; }
+      set { baseName = value; }
+    }
+  }
+
+  class Override : Base {
+    [Storable]
+    public override string Name {
+      get { return "Override"; }
+      set { base.Name = value; }
+    }
+  }
+
+  [EmptyStorableClass]
+  class Intermediate : Override {
+  }
+
+  class New : Intermediate {
+    public string newName;
+    [Storable]
+    public new string Name {
+      get { return "New"; }
+      set { newName = value; }
+    }
+  }
+
   [TestClass]
   public class AttributeTest {
@@ -26 +57 @@
       DemoClass t = new DemoClass();
       Dictionary<string, DataMemberAccessor> accessors = StorableAttribute.GetStorableAccessors(t);
-      Assert.IsTrue(accessors.ContainsKey("o"));
+      Assert.IsTrue(accessors.ContainsKey("TestProperty"));
       Assert.IsTrue(accessors.ContainsKey("x"));
       Assert.IsFalse(accessors.ContainsKey("y"));
       object o = new object();
       t.o = o;
-      Assert.AreSame(accessors["o"].Get(), o);
+      Assert.AreSame(accessors["TestProperty"].Get(), o);
       t.x = 12;
       Assert.AreEqual(accessors["x"].Get(), 12);
       t.y = 312890;
-      accessors["o"].Set(null);
+      accessors["TestProperty"].Set(null);
       Assert.IsNull(t.o);
       accessors["x"].Set(123);
@@ -41 +72 @@
     }
 
+    [TestMethod]
+    public void TestInheritance() {
+      New n = new New();
+      var accessors = StorableAttribute.GetStorableAccessors(n);
+      var accessDict = new Dictionary<string, DataMemberAccessor>();
+      foreach (var accessor in accessors) // assert uniqueness
+        accessDict.Add(accessor.Key, accessor.Value);
+      Assert.IsTrue(accessDict.ContainsKey(typeof(New).FullName + ".Name"));
+      Assert.IsTrue(accessDict.ContainsKey(typeof(Override).FullName + ".Name"));
+      Assert.AreEqual("New", accessDict[typeof(New).FullName + ".Name"].Get());
+      Assert.AreEqual("Override", accessDict[typeof(Override).FullName + ".Name"].Get());
+    }
+
   }
 

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

@@ -16 +16 @@
 using HeuristicLab.Persistence.Auxiliary;
 using System.Text.RegularExpressions;
+using HeuristicLab.Persistence.Test;
 
 namespace HeuristicLab.Persistence.UnitTest {
@@ -541 +542 @@
     }
 
+    [TestMethod]
+    public void InheritanceTest() {
+      New n = new New();
+      XmlGenerator.Serialize(n, tempFile);
+      New nn = (New)XmlParser.Deserialize(tempFile);
+      Assert.AreEqual(n.Name, nn.Name);
+      Assert.AreEqual(((Override)n).Name, ((Override)nn).Name);
+    }
+
     [ClassInitialize]
     public static void Initialize(TestContext testContext) {