Changeset 2993

Timestamp:

03/10/10 16:37:52 (14 years ago)

Author:

epitzer

Message:

add justifications for rejecting a type for serialization in ICompositeSerializer (#548)

Location:

trunk/sources/HeuristicLab.Persistence/3.3

Files:

• Core/Serializer.cs (modified) (2 diffs)
• Default/CompositeSerializers/ArraySerializer.cs (modified) (2 diffs)
• Default/CompositeSerializers/CompactNumberArray2StringSerializer.cs (modified) (1 diff)
• Default/CompositeSerializers/DictionarySerializer.cs (modified) (1 diff)
• Default/CompositeSerializers/EnumSerializer.cs (modified) (1 diff)
• Default/CompositeSerializers/EnumerableSerializer.cs (modified) (1 diff)
• Default/CompositeSerializers/KeyValuePairSerializer.cs (modified) (1 diff)
• Default/CompositeSerializers/Number2StringSerializer.cs (modified) (2 diffs)
• Default/CompositeSerializers/NumberEnumerable2StringSerializer.cs (modified) (1 diff)
• Default/CompositeSerializers/StackSerializer.cs (modified) (1 diff)
• Default/CompositeSerializers/Storable/StorableSerializer.cs (modified) (2 diffs)
• Default/CompositeSerializers/StructSerializer.cs (modified) (1 diff)
• Default/CompositeSerializers/TypeSerializer.cs (modified) (1 diff)
• Interfaces/ICompositeSerializer.cs (modified) (1 diff)
• Tests/UseCases.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Persistence/3.3/Core/Serializer.cs

@@ -137 +137 @@
         if (compositeSerializer != null)
           return CompositeEnumerator(accessor.Name, compositeSerializer.Decompose(value), id, typeId, compositeSerializer.CreateMetaInfo(value));
-        throw new PersistenceException(
-            String.Format(
-            "No suitable method for serializing values of type \"{0}\" found\r\n" +
-            "primitive serializers:\r\n{1}\r\n" +
-            "composite serializers:\r\n{2}",
-            value.GetType().VersionInvariantName(),
-            string.Join("\r\n", configuration.PrimitiveSerializers.Select(f => f.GetType().VersionInvariantName()).ToArray()),
-            string.Join("\r\n", configuration.CompositeSerializers.Select(d => d.GetType().VersionInvariantName()).ToArray())
-            ));
+        throw CreatePersistenceException(type);
       } catch (Exception x) {
         if (isTestRun) {
@@ -154 +146 @@
         }
       }
+    }
+
+    private PersistenceException CreatePersistenceException(Type type) {
+      StringBuilder sb = new StringBuilder();
+      sb.Append("Could not determine how to serialize a value of type \"")
+        .Append(type.VersionInvariantName())
+        .AppendLine("\"");
+      sb.AppendLine("No registered primitive serializer for this type:");
+      foreach (var ps in configuration.PrimitiveSerializers)
+        sb.Append(ps.SourceType.VersionInvariantName())
+          .Append(" ---- (")
+          .Append(ps.GetType().VersionInvariantName())
+          .AppendLine(")");          
+      sb.AppendLine("Rejected by all composite serializers:");
+      foreach (var cs in configuration.CompositeSerializers)
+        sb.Append("\"")
+          .Append(cs.JustifyRejection(type))
+          .Append("\" ---- (")
+          .Append(cs.GetType().VersionInvariantName())
+          .AppendLine(")");
+      return new PersistenceException(sb.ToString());              
     }
 

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/ArraySerializer.cs

@@ -4 +4 @@
 using System.Collections.Generic;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Text;
 
 namespace HeuristicLab.Persistence.Default.CompositeSerializers {
@@ -16 +17 @@
     public bool CanSerialize(Type type) {
       return type.IsArray || type == typeof(Array);
+    }
+
+    public string JustifyRejection(Type type) {
+      return "not an array and not of type System.Array";
     }
 

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/CompactNumberArray2StringSerializer.cs

@@ -24 +24 @@
         (type.IsArray || type == typeof(Array)) &&
         numberConverter.CanSerialize(type.GetElementType());
+    }
+
+    public string JustifyRejection(Type type) {
+      if (!type.IsArray && type != typeof(Array))
+        return "not an array";
+      return string.Format("number converter cannot serialize elements: " +
+        numberConverter.JustifyRejection(type.GetElementType()));
     }
 

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/DictionarySerializer.cs

@@ -20 +20 @@
       return ReflectionTools.HasDefaultConstructor(type) &&
         type.GetInterface(typeof(IDictionary).FullName) != null;
+    }
+
+    public string JustifyRejection(Type type) {
+      if (!ReflectionTools.HasDefaultConstructor(type))
+        return "no default constructor";
+      return "interface IDictionary not implemented";
     }
 

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/EnumSerializer.cs

@@ -16 +16 @@
     public bool CanSerialize(Type type) {
       return type.IsEnum || type == typeof(Enum);
+    }
+
+    public string JustifyRejection(Type type) {
+      return "not an enum and not System.Enum";
     }
 

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/EnumerableSerializer.cs

@@ -26 +26 @@
     }
 
+    public string JustifyRejection(Type type) {
+      if (!ReflectionTools.HasDefaultConstructor(type))
+        return "no default constructor";
+      if (type.GetInterface(typeof(IEnumerable).FullName) == null)
+        return "interface IEnumerable not implemented";
+      if (type.GetMethod("Add") == null)
+        return "no 'Add()' method";      
+      return "no 'Add()' method with one argument";
+    }
+
     public IEnumerable<Tag> CreateMetaInfo(object o) {
       return new Tag[] { };

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/KeyValuePairSerializer.cs

@@ -16 +16 @@
     }
 
+    private static readonly Type genericKeyValuePairType =
+      typeof(KeyValuePair<int, int>).GetGenericTypeDefinition();
 
     public bool CanSerialize(Type type) {
       return type.IsGenericType &&
-             type.GetGenericTypeDefinition() ==
-             typeof(KeyValuePair<int, int>).GetGenericTypeDefinition();
+             type.GetGenericTypeDefinition() == genericKeyValuePairType;             
+    }
+
+    public string JustifyRejection(Type type) {
+      if (!type.IsGenericType)
+        return "not even generic";      
+      return "not generic KeyValuePair<,>";
     }
 

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Number2StringSerializer.cs

@@ -1 +1 @@
 using System;
+using System.Linq;
 using HeuristicLab.Persistence.Interfaces;
 using HeuristicLab.Persistence.Core;
@@ -43 +44 @@
     public bool CanSerialize(Type type) {
       return numberParsers.ContainsKey(type);
+    }
+
+    public string JustifyRejection(Type type) {
+      return string.Format("not a number type (one of {0})",
+        string.Join(", ", numberTypes.Select(n => n.Name).ToArray()));
     }
 

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/NumberEnumerable2StringSerializer.cs

@@ -60 +60 @@
     }
 
+    public string JustifyRejection(Type type) {
+      if (!ReflectionTools.HasDefaultConstructor(type))
+        return "no default constructor";
+      if (!ImplementsGenericEnumerable(type))
+        return "IEnumerable<> not implemented";
+      return "no Add method with one parameter";
+    }
+
     public IEnumerable<Tag> CreateMetaInfo(object o) {
       return new Tag[] { };

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/StackSerializer.cs

@@ -22 +22 @@
         type.IsGenericType &&
         type.GetGenericTypeDefinition() == typeof(Stack<>);
+    }
+
+    public string JustifyRejection(Type type) {
+        return "not Stack or generic Stack<>";
     }
 

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

@@ -17 +17 @@
 
     public bool CanSerialize(Type type) {
-      if (!ReflectionTools.HasDefaultConstructor(type))
+      if (!ReflectionTools.HasDefaultConstructor(type) &&
+        StorableConstructorAttribute.GetStorableConstructor(type) == null)
         return false;
       while (type != null) {
@@ -26 +27 @@
       }
       return true;
+    }
+
+    public string JustifyRejection(Type type) {
+      if (!ReflectionTools.HasDefaultConstructor(type) &&
+        StorableConstructorAttribute.GetStorableConstructor(type) == null)
+        return "no default constructor and no storable constructor";
+      while (type != null) {
+        if (StorableAttribute.GetStorableMembers(type, false).Count() == 0 &&
+            !EmptyStorableClassAttribute.IsEmptyStorable(type))
+          return string.Format("{0} has no storable members and is not marked [EmtpyStorableClass]",
+            type);
+        type = type.BaseType;
+      }
+      return "no reason";
     }
 

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/StructSerializer.cs

@@ -19 +19 @@
     public bool CanSerialize(Type type) {
       return type.IsValueType && !type.IsPrimitive && !type.IsEnum && type.IsSealed;      
+    }
+
+    public string JustifyRejection(Type type) {
+      if (!type.IsValueType)
+        return "not a value type";
+      if (type.IsPrimitive)
+        return "type is primitive (int, float, ...)";
+      if (type.IsEnum)
+        return "type is enum";
+      return "type is not sealed";
     }
 

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/TypeSerializer.cs

@@ -18 +18 @@
       return type == typeof(Type) ||
              type.VersionInvariantName() == "System.RuntimeType, mscorlib";
+    }
+
+    public string JustifyRejection(Type type) {
+      return "not System.Type nor System.RuntimeType";
     }
 

trunk/sources/HeuristicLab.Persistence/3.3/Interfaces/ICompositeSerializer.cs

@@ -20 +20 @@
     /// </summary>    
     bool CanSerialize(Type type);
+
+    /// <summary>
+    /// Give a reason if possibly why the given type cannot be serialized by this
+    /// ICompositeSerializer.
+    /// </summary>
+    string JustifyRejection(Type type);
 
     /// <summary>

trunk/sources/HeuristicLab.Persistence/3.3/Tests/UseCases.cs

@@ -736 +736 @@
     }
 
+    [TestMethod]
+    public void TestRejectionJustifications() { 
+      NonSerializable ns = new NonSerializable();
+      try {
+        XmlGenerator.Serialize(ns, tempFile);
+        Assert.Fail("PersistenceException expected");
+      } catch (PersistenceException x) {
+        Assert.IsTrue(x.Message.Contains(new StorableSerializer().JustifyRejection(typeof(NonSerializable))));        
+      }
+    }
+
     [ClassInitialize]
     public static void Initialize(TestContext testContext) {