Changeset 5324 for trunk/sources/HeuristicLab.Persistence/3.3/Default

Timestamp:

01/18/11 15:50:23 (14 years ago)

Author:

epitzer

Message:

Implement one-way serialization that allows either only loading or only saving of storable members by setting a new property called AllowOneWay on the [Storable] attribute (#1385)

Location:

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

Files:

• StorableAttribute.cs (modified) (1 diff)
• StorableMemberInfo.cs (modified) (3 diffs)
• StorableReflection.cs (modified) (3 diffs)
• StorableSerializer.cs (modified) (2 diffs)

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

@@ -56 +56 @@
 
     /// <summary>
+    /// Allow storable attribute on properties with only a getter or a setter. These
+    /// properties will then by either only serialized but not deserialized or only
+    /// deserialized (if stored) but not serialized again.
+    /// </summary>
+    public bool AllowOneWay { get; set; }
+
+    /// <summary>
     /// Returns a <see cref="System.String"/> that represents this instance.
     /// </summary>

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

@@ -23 +23 @@
 using System.Reflection;
 using System.Text;
+using HeuristicLab.Persistence.Core;
 
 namespace HeuristicLab.Persistence.Default.CompositeSerializers.Storable {
@@ -43 +44 @@
       DefaultValue = attribute.DefaultValue;
       MemberInfo = memberInfo;
+      if (!attribute.AllowOneWay)
+        CheckPropertyAccess(memberInfo as PropertyInfo);
     }
-    public StorableMemberInfo(MemberInfo memberInfo) {
+    public StorableMemberInfo(MemberInfo memberInfo, bool allowOneWay) {
       MemberInfo = memberInfo;
+      if (!allowOneWay)
+        CheckPropertyAccess(memberInfo as PropertyInfo);
+    }
+    private static void CheckPropertyAccess(PropertyInfo propertyInfo) {
+      if (propertyInfo == null)
+        return;
+      if (!propertyInfo.CanRead || !propertyInfo.CanWrite)
+        throw new PersistenceException("Properties must be readable and writable or explicity enable one way serialization.");
     }
     public void SetDisentangledName(string name) {
@@ -51 +62 @@
         DisentangledName = name;
     }
+    /// <summary>
+    /// Gets the type who first defined this property in the class hierarchy when the
+    /// property has subsequently been overridden but not shadowed with <code>new</code>.
+    /// </summary>
+    /// <returns>The properties base type.</returns>
     public Type GetPropertyDeclaringBaseType() {
-      return ((PropertyInfo)MemberInfo).GetGetMethod(true).GetBaseDefinition().DeclaringType;
+      PropertyInfo pi = MemberInfo as PropertyInfo;
+      if (pi == null)
+        throw new PersistenceException("fields don't have a declaring base type, directly use FullyQualifiedMemberName instead");
+      if (pi.CanRead)
+        return pi.GetGetMethod(true).GetBaseDefinition().DeclaringType;
+      if (pi.CanWrite)
+        return pi.GetSetMethod(true).GetBaseDefinition().DeclaringType;
+      throw new InvalidOperationException("property has neigher a getter nor a setter.");
     }
   }

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

@@ -58 +58 @@
         }
       }
-
       return DisentangleNameMapping(storableMembers);
     }
@@ -108 +107 @@
             !memberInfo.Name.StartsWith("<") &&
             !memberInfo.Name.EndsWith("k__BackingField"))
-          storableMembers.Add(new StorableMemberInfo(memberInfo));
-      }
-    }
-
-
+          storableMembers.Add(new StorableMemberInfo(memberInfo, false));
+      }
+    }
+
+    /// <summary>
+    /// Ascertain distinct names for all fields and properties. This method takes care
+    /// of disentangling equal names from different class hiarachy levels.
+    /// 
+    /// Field names are replaced with their fully qualified name which includes
+    /// the class names where they were declared.
+    /// 
+    /// Property names are first reduced to unqiue accessors that are not overrides of
+    /// each other and the replaced with their fully qualified name if more than one
+    /// accessor remains.
+    /// </summary>
+    /// <param name="storableMemberInfos"></param>
+    /// <returns></returns>
     private static IEnumerable<StorableMemberInfo> DisentangleNameMapping(
         IEnumerable<StorableMemberInfo> storableMemberInfos) {
@@ -138 +149 @@
     }
 
+    /// <summary>
+    /// Merges property accessors that are overrides of each other but differentiates if a new
+    /// property that shadows older implementations has been introduced with <code>new</code>.
+    /// </summary>
+    /// <param name="members">A list of <code>StorableMemberInfo</code>s for properties of the same type.</param>
+    /// <returns>A fieltered <code>IEnumerable</code> of propery infos.</returns>
     private static IEnumerable<StorableMemberInfo> MergePropertyAccessors(List<StorableMemberInfo> members) {
       var uniqueAccessors = new Dictionary<Type, StorableMemberInfo>();

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

@@ -118 +118 @@
     public IEnumerable<Tag> Decompose(object obj) {
       foreach (var accessor in GetStorableAccessors(obj.GetType())) {
-        yield return new Tag(accessor.Name, accessor.Get(obj));
+        if (accessor.Get != null)
+          yield return new Tag(accessor.Name, accessor.Get(obj));
       }
     }
@@ -151 +152 @@
       }
       foreach (var accessor in GetStorableAccessors(instance.GetType())) {
-        if (memberDict.ContainsKey(accessor.Name)) {
-          accessor.Set(instance, memberDict[accessor.Name].Value);
-        } else if (accessor.DefaultValue != null) {
-          accessor.Set(instance, accessor.DefaultValue);
+        if (accessor.Set != null) {
+          if (memberDict.ContainsKey(accessor.Name)) {
+            accessor.Set(instance, memberDict[accessor.Name].Value);
+          } else if (accessor.DefaultValue != null) {
+            accessor.Set(instance, accessor.DefaultValue);
+          }
         }
       }