Changeset 3029 for trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers

Timestamp:

03/15/10 12:02:00 (15 years ago)

Author:

epitzer

Message:

add support for automatic serialization of fields and properties (#548)

Location:

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

Files:

• StorableClassAttribute.cs (modified) (1 diff)
• StorableClassType.cs (added)
• StorableMemberInfo.cs (added)
• StorableReflection.cs (added)
• StorableSerializer.cs (modified) (8 diffs)

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

@@ -4 +4 @@
 using System.Linq;
 
-namespace HeuristicLab.Persistence.Default.CompositeSerializers.Storable {
-
-
-  /// <summary>
-  /// Specifies which memebrs are selected for serialization by the StorableSerializer
-  /// </summary>
-  public enum StorableClassType {
-
-    /// <summary>
-    /// Serialize only fields and properties that have been marked
-    /// with the [Storable] attribute. This is the default value.
-    /// </summary>
-    MarkedOnly,
-
-    /// <summary>
-    /// Serialize all fields but ignore the 
-    /// [Storable] attribute on properties.
-    /// </summary>
-    [Obsolete("not implemented yet")]
-    AllFields,
-
-    /// <summary>
-    /// Serialize all properties but ignore the
-    /// [Storable] attirbute on fields.
-    /// </summary>
-    [Obsolete("not implemented yet")]
-    AllProperties,
-
-    /// <summary>
-    /// Serialize all fields and all properties
-    /// but ignore the [Storable] on all members.
-    /// </summary>
-    [Obsolete("not implemnted yet")]
-    AllFieldsAndAllProperties
-  };
-
+namespace HeuristicLab.Persistence.Default.CompositeSerializers.Storable {  
 
   /// <summary>

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

@@ -12 +12 @@
   /// <summary>
   /// Intended for serialization of all custom classes. Classes should have the
-  /// <c>[StorableClass]</c> attribute set and a serialization mode set.
-  /// Optionally selected fields and properties can be marked with the
-  /// <c>[Storable]</c> attribute.
+  /// <c>[StorableClass]</c> attribute set. The default mode is to serialize
+  /// members with the <c>[Storable]</c> attribute set. Alternatively the
+  /// storable mode can be set to <c>AllFields</c>, <c>AllProperties</c>
+  /// or <c>AllFieldsAndAllProperties</c>.
   /// </summary>
-  [StorableClass]    
+  [StorableClass]
   public class StorableSerializer : ICompositeSerializer {
-
 
     #region ICompositeSerializer implementation
@@ -30 +30 @@
         GetStorableConstructor(type) == null)
         return false;
-      return IsEmptyOrStorableType(type, true);
+      return StorableReflection.IsEmptyOrStorableType(type, true);
     }
 
@@ -37 +37 @@
         GetStorableConstructor(type) == null)
         return "no default constructor and no storable constructor";
-      if (!IsEmptyOrStorableType(type, true))
+      if (!StorableReflection.IsEmptyOrStorableType(type, true))
         return "class is not marked with the storable class attribute";
       return "no reason";
@@ -71 +71 @@
       while (iter.MoveNext()) {
         memberDict.Add(iter.Current.Name, iter.Current);
-      }      
+      }
       foreach (var accessor in GetStorableAccessors(instance)) {
         if (memberDict.ContainsKey(accessor.Name)) {
@@ -84 +84 @@
     #endregion
 
-    #region constances & private data types
+    #region constants & private data types
 
     private const BindingFlags ALL_CONSTRUCTORS =
       BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
-
-    private const BindingFlags DECLARED_INSTANCE_MEMBERS =
-      BindingFlags.Instance |
-      BindingFlags.Public |
-      BindingFlags.NonPublic |
-      BindingFlags.DeclaredOnly;
-
-    private sealed class StorableMemberInfo {
-      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;
-        this.MemberInfo = memberInfo;
-      }
-      public override string ToString() {
-        return new StringBuilder()
-          .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;
-      }
-    }
 
     private sealed class TypeQuery {
@@ -141 +105 @@
 
     private MemberCache storableMemberCache = new MemberCache();
-    private Dictionary<Type, ConstructorInfo> constructorCache = 
+    private Dictionary<Type, ConstructorInfo> constructorCache =
       new Dictionary<Type, ConstructorInfo>();
 
     #endregion
 
-    #region auxiliary attribute reflection tools
+    #region attribute access
 
     private IEnumerable<StorableMemberInfo> GetStorableMembers(Type type) {
@@ -157 +121 @@
         if (storableMemberCache.ContainsKey(query))
           return storableMemberCache[query];
-        var storablesMembers = GenerateStorableMembers(type, inherited);
+        var storablesMembers = StorableReflection.GenerateStorableMembers(type, inherited);
         storableMemberCache[query] = storablesMembers;
         return storablesMembers;
       }
-    }
-
-    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));
-      foreach (MemberInfo memberInfo in type.GetMembers(DECLARED_INSTANCE_MEMBERS)) {
-        foreach (StorableAttribute attribute in memberInfo.GetCustomAttributes(typeof(StorableAttribute), false)) {
-          storableMembers.Add(new StorableMemberInfo(attribute, memberInfo));
-        }
-      }
-      return DisentangleNameMapping(storableMembers);
-    }
-
-    private 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 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 {
-          memberInfos.AddRange(MergePropertyAccessors(storableMemberInfoGroup));
-        }
-      }
-      return memberInfos;
-    }
-
-    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;
-        }
-      }
-    }
-
-    private static bool IsEmptyOrStorableType(Type type, bool recusrive) {
-      if (IsEmptyType(type, recusrive)) return true;
-      if (!HastStorableClassAttribute(type)) return false;
-      return !recusrive || type.BaseType == null || IsEmptyOrStorableType(type.BaseType, true);
-    }
-
-    private static bool HastStorableClassAttribute(Type type) {
-      return type.GetCustomAttributes(typeof(StorableClassAttribute), false).Length > 0;
-    }
-
-    private static bool IsEmptyType(Type type, bool recursive) {
-      foreach (MemberInfo memberInfo in type.GetMembers(DECLARED_INSTANCE_MEMBERS)) {
-        if (IsModifiableMember(memberInfo)) return false;
-      }
-      return !recursive || type.BaseType == null || IsEmptyType(type.BaseType, true);
-    }
-
-    private static bool IsModifiableMember(MemberInfo memberInfo) {
-      return memberInfo.MemberType == MemberTypes.Field && IsModifiableField((FieldInfo)memberInfo) ||
-                memberInfo.MemberType == MemberTypes.Property && IsModifiableProperty((PropertyInfo)memberInfo);
-    }
-
-    private static bool IsModifiableField(FieldInfo fi) {
-      return !fi.IsLiteral && !fi.IsInitOnly;
-    }
-
-    private static bool IsModifiableProperty(PropertyInfo pi) {
-      return pi.CanWrite;
-    }
+    }    
 
     private ConstructorInfo GetStorableConstructor(Type type) {
@@ -273 +145 @@
     }
 
+    private IEnumerable<DataMemberAccessor> GetStorableAccessors(object obj) {
+      return GetStorableMembers(obj.GetType())
+        .Select(mi => new DataMemberAccessor(mi.MemberInfo, mi.DisentangledName, mi.DefaultValue, obj));
+    }
+
     #endregion
+    
   }
+  
 }