Changeset 1564 for trunk/sources/HeuristicLab.Persistence/3.3/Core

Timestamp:

04/16/09 12:40:41 (15 years ago)

Author:

epitzer

Message:

Stronger typing for formatters with the help of generics. Separate format and serial data type. (#548)

Location:

trunk/sources/HeuristicLab.Persistence/3.3/Core

Files:

• Configuration.cs (modified) (2 diffs)
• ConfigurationService.cs (modified) (7 diffs)
• FormatBase.cs (modified) (1 diff)
• FormatterBase.cs (added)
• GeneratorBase.cs (added)
• Serializer.cs (modified) (2 diffs)
• Tokens/PrimitiveToken.cs (modified) (1 diff)

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

@@ -9 +9 @@
     [Storable]
     private readonly Dictionary<Type, IFormatter> formatters;
+
     [Storable]
     private readonly List<IDecomposer> decomposers;
     private readonly Dictionary<Type, IDecomposer> decomposerCache;
-    [Storable]
-    public IFormat Format { get; set; }
+
+    [Storable]    
+    public IFormat Format { get; private set; }
 
     private Configuration() {
@@ -19 +21 @@
     }
 
-    public Configuration(Dictionary<Type, IFormatter> formatters, IEnumerable<IDecomposer> decomposers) {      
+    public Configuration(IFormat format, Dictionary<Type, IFormatter> formatters, IEnumerable<IDecomposer> decomposers) {
+      this.Format = format;
       this.formatters = new Dictionary<Type, IFormatter>();
       foreach ( var pair in formatters ) {
-        if (Format == null) {
-          Format = pair.Value.Format;
-        } else if (pair.Value.Format != Format ) {
+        if (pair.Value.SerialDataType != format.SerialDataType ) {
           throw new ArgumentException("All formatters must have the same IFormat.");
         }

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

@@ -15 +15 @@
     private static ConfigurationService instance;
     private readonly Dictionary<IFormat, Configuration> customConfigurations;
-    public Dictionary<IFormat, List<IFormatter>> Formatters { get; private set; }
+    public Dictionary<Type, List<IFormatter>> Formatters { get; private set; }
     public List<IDecomposer> Decomposers { get; private set; }
+    public List<IFormat> Formats { get; private set; }
     
     public static ConfigurationService Instance {
@@ -27 +28 @@
 
     private ConfigurationService() {
-      Formatters = new Dictionary<IFormat, List<IFormatter>>();
+      Formatters = new Dictionary<Type, List<IFormatter>>();
       Decomposers = new List<IDecomposer>();
-      customConfigurations = new Dictionary<IFormat, Configuration>();      
+      customConfigurations = new Dictionary<IFormat, Configuration>();
+      Formats = new List<IFormat>();
       Reset();
       LoadSettings();
@@ -59 +61 @@
       Serializer serializer = new Serializer(
         customConfigurations,
-        GetDefaultConfig(XmlFormat.Instance),
+        GetDefaultConfig(new XmlFormat()),
         "CustomConfigurations");
       XmlGenerator generator = new XmlGenerator();
@@ -103 +105 @@
           try {
             IFormatter formatter = (IFormatter) Activator.CreateInstance(t, true);
-            if ( ! Formatters.ContainsKey(formatter.Format) ) {
-              Formatters.Add(formatter.Format, new List<IFormatter>());
+            if ( ! Formatters.ContainsKey(formatter.SerialDataType) ) {
+              Formatters.Add(formatter.SerialDataType, new List<IFormatter>());
             }
-            Formatters[formatter.Format].Add(formatter);
-            Logger.Debug("discovered formatter " + t.VersionInvariantName());
+            Formatters[formatter.SerialDataType].Add(formatter);
+            Logger.Debug(String.Format("discovered formatter {0} ({1} -> {2})",
+              t.VersionInvariantName(),
+              formatter.SourceType.VersionInvariantName(),
+              formatter.SerialDataType.VersionInvariantName()));
           } catch (MissingMethodException e) {
             Logger.Warn("Could not instantiate " + t.VersionInvariantName(), e);            
@@ -124 +129 @@
           }
         }
+        if (t.GetInterface(typeof(IFormat).FullName) != null) {
+          try {
+            IFormat format = (IFormat)Activator.CreateInstance(t, true);
+            Formats.Add(format);
+            Logger.Debug(String.Format("discovered format {0} ({2}) with serial data {1}.",
+              format.Name,
+              format.SerialDataType,
+              t.VersionInvariantName()));              
+          } catch (MissingMethodException e) {
+            Logger.Warn("Could not instantiate " + t.VersionInvariantName(), e);          
+          } catch (ArgumentException e) {
+            Logger.Warn("Could not instantiate " + t.VersionInvariantName(), e);
+          }          
+        }
       }
     }
@@ -129 +148 @@
     public Configuration GetDefaultConfig(IFormat format) {
       Dictionary<Type, IFormatter> formatterConfig = new Dictionary<Type, IFormatter>();
-      foreach ( IFormatter f in Formatters[format] ) {
-        if ( ! formatterConfig.ContainsKey(f.Type) )
-          formatterConfig.Add(f.Type, f);
+      foreach ( IFormatter f in Formatters[format.SerialDataType] ) {
+        if ( ! formatterConfig.ContainsKey(f.SourceType) )
+          formatterConfig.Add(f.SourceType, f);
       }
-      return new Configuration(formatterConfig, Decomposers);
+      return new Configuration(format, formatterConfig, Decomposers);
     }
 
@@ -142 +161 @@
     }
 
-    public void DefineConfiguration(IFormat format, Configuration configuration) {
-      customConfigurations[format] = configuration;
+    public void DefineConfiguration(Configuration configuration) {      
+      customConfigurations[configuration.Format] = configuration;
       SaveSettings();
     }

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

@@ -3 +3 @@
 namespace HeuristicLab.Persistence.Interfaces {
 
-  public abstract class FormatBase : IFormat {
-    public abstract string Name { get;  }
+  public abstract class FormatBase<SerialDataFormat> : IFormat<SerialDataFormat> where SerialDataFormat : ISerialData {
+
+    public abstract string Name { get; }
+
+    public Type SerialDataType { get { return typeof(SerialDataFormat); } }
+
+    public bool Equals(FormatBase<SerialDataFormat> f) {
+      if (f == null)
+        return false;
+      return f.Name == this.Name;
+    }
+
     public override bool Equals(object obj) {
-      if (obj as IFormat == null)
-        return false;
-      return this.Equals((FormatBase)obj);      
+      FormatBase<SerialDataFormat> f = obj as FormatBase<SerialDataFormat>;      
+      return Equals(f);
     }
-    public bool Equals(FormatBase f) {
-      return Name.Equals(f.Name);
-    }
-    public override int GetHashCode() {
-      return Name.GetHashCode();
-    }
+    
   }
+
 }

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

@@ -69 +69 @@
       IFormatter formatter = configuration.GetFormatter(value.GetType());
       if (formatter != null)
-        return PrimitiveEnumerator(accessor.Name, typeId, formatter.DoFormat(value), id);
+        return PrimitiveEnumerator(accessor.Name, typeId, formatter.Format(value), id);
       IDecomposer decomposer = configuration.GetDecomposer(value.GetType()); 
       if (decomposer != null)
@@ -88 +88 @@
 
     private IEnumerator<ISerializationToken> PrimitiveEnumerator(string name,
-        int typeId, object serializedValue, int? id) {
+        int typeId, ISerialData serializedValue, int? id) {
       yield return new PrimitiveToken(name, typeId, id, serializedValue);
     }

trunk/sources/HeuristicLab.Persistence/3.3/Core/Tokens/PrimitiveToken.cs

@@ -6 +6 @@
     public readonly int TypeId;
     public readonly int? Id;
-    public readonly object SerialData;
-    public PrimitiveToken(string name, int typeId, int? id, object serialData)
+    public readonly ISerialData SerialData;
+    public PrimitiveToken(string name, int typeId, int? id, ISerialData serialData)
       : base(name) {
       TypeId = typeId;