Free cookie consent management tool by TermsFeed Policy Generator

Changeset 3004


Ignore:
Timestamp:
03/11/10 12:54:14 (14 years ago)
Author:
epitzer
Message:

add complete persistence API docs (#548)

Location:
trunk/sources/HeuristicLab.Persistence/3.3
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Persistence/3.3/Auxiliary/TypeLoader.cs

    r1823 r3004  
    1010namespace HeuristicLab.Persistence.Auxiliary {
    1111
    12   public class TypeLoader {
     12  internal class TypeLoader {
    1313
    1414    public static Type Load(string typeNameString) {

  • trunk/sources/HeuristicLab.Persistence/3.3/Auxiliary/TypeName.cs

    r2859 r3004  
    44using System.Reflection.Emit;
    55using System.Collections.Generic;
     6using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    67
    78namespace HeuristicLab.Persistence.Auxiliary {
    89 
     10  /// <summary>
     11  /// Contains a more modular representation of type names that can
     12  /// be used to compare versions and ignore extended assembly
     13  /// attributes.
     14  /// </summary>
     15  [StorableClass(StorableClassType.MarkedOnly)]
    916  public class TypeName {
     17
     18    [Storable]
    1019    public string Namespace { get; private set; }
     20
     21    [Storable]
    1122    public string ClassName { get; private set; }
     23
     24    [Storable]
    1225    public List<TypeName> GenericArgs { get; internal set; }
    1326    public bool IsGeneric { get { return GenericArgs.Count > 0; } }
     27
     28    [Storable]
    1429    public string MemoryMagic { get; internal set; }
     30
     31    [Storable]
    1532    public string AssemblyName { get; internal set; }
     33
     34    [Storable]
    1635    public Dictionary<string, string> AssemblyAttribues { get; internal set; }
     36
     37    [Storable]
    1738    public bool IsReference { get; internal set; }
    1839
    … …  
    2546    }
    2647
     48    /// <param name="full">include assembly properties and generic parameters</param>   
    2749    public string ToString(bool full) {
    2850      return ToString(full, true);
    2951    }
    3052
    31     public string ToString(bool full, bool includeAssembly) {
     53
     54    /// <param name="full">include assembly properties and generic parameters</param>   
     55    public string ToString(bool full, bool includeAssembly) {     
    3256      StringBuilder sb = new StringBuilder();
    3357      if (!string.IsNullOrEmpty(Namespace))
    … …  
    6084    }
    6185
    62     public bool IsNewerThan(TypeName t) {
     86
     87    /// <summary>
     88    /// Lexicographically compare version information and make sure type and assembly
     89    /// names are identical. This function recursively checks generic type arguments.
     90    /// </summary>   
     91    public bool IsNewerThan(TypeName typeName) {
    6392      try {
    64         if (this.ClassName != t.ClassName ||
    65           this.Namespace != t.Namespace ||
    66           this.AssemblyName != t.AssemblyName)
     93        if (this.ClassName != typeName.ClassName ||
     94          this.Namespace != typeName.Namespace ||
     95          this.AssemblyName != typeName.AssemblyName)
    6796          throw new Exception("Cannot compare versions of different types");
    6897        if (CompareVersions(
    6998          this.AssemblyAttribues["Version"],
    70           t.AssemblyAttribues["Version"]) > 0)
     99          typeName.AssemblyAttribues["Version"]) > 0)
    71100          return true;
    72101        IEnumerator<TypeName> thisIt = this.GenericArgs.GetEnumerator();
    73         IEnumerator<TypeName> tIt = t.GenericArgs.GetEnumerator();
     102        IEnumerator<TypeName> tIt = typeName.GenericArgs.GetEnumerator();
    74103        while (thisIt.MoveNext()) {
    75104          tIt.MoveNext();
    … …  
    83112    }
    84113
    85     public bool IsCompatible(TypeName t) {
     114
     115    /// <summary>
     116    /// Make sure major and minor version number are identical. This function
     117    /// recursively checks generic type arguments.
     118    /// </summary>
     119    public bool IsCompatible(TypeName typeName) {
    86120      try {
    87         if (this.ClassName != t.ClassName ||
    88           this.Namespace != t.Namespace ||
    89           this.AssemblyName != t.AssemblyName)
     121        if (this.ClassName != typeName.ClassName ||
     122          this.Namespace != typeName.Namespace ||
     123          this.AssemblyName != typeName.AssemblyName)
    90124          throw new Exception("Cannot compare versions of different types");
    91125        Version thisVersion = new Version(this.AssemblyAttribues["Version"]);
    92         Version tVersion = new Version(t.AssemblyAttribues["Version"]);
     126        Version tVersion = new Version(typeName.AssemblyAttribues["Version"]);
    93127        if (thisVersion.Major != tVersion.Major ||
    94128          thisVersion.Minor != tVersion.Minor)
    95129          return false;
    96130        IEnumerator<TypeName> thisIt = this.GenericArgs.GetEnumerator();
    97         IEnumerator<TypeName> tIt = t.GenericArgs.GetEnumerator();
     131        IEnumerator<TypeName> tIt = typeName.GenericArgs.GetEnumerator();
    98132        while (thisIt.MoveNext()) {
    99133          tIt.MoveNext();

  • trunk/sources/HeuristicLab.Persistence/3.3/Auxiliary/TypeNameParser.cs

    r2859 r3004  
    1111  }
    1212
     13
     14  /// <summary>
     15  /// Parse a .NET type name using the following grammar: 
     16  ///   
     17  /// <para><code>
     18  /// TypeSpec := SimpleTypeSpec '&amp;'? 
     19  /// </code></para>
     20  ///
     21  /// <para><code>
     22  /// SimpleTypeSpec := (IDENTIFIER '.')*
     23  ///                   (IDENTIFIER '+')*
     24  ///                    IDENTIFIER
     25  ///                   ( '`\d+[' Generics ']' )?
     26  ///                   (\*|\[(\d+\.\.\d+|\d+\.\.\.|(|\*)(,(|\*))*)\])*
     27  ///                   (',\s*' IDENTIFIER (',\s*' AssemblyProperty)* )? 
     28  /// </code></para>
     29  ///
     30  /// <para><code>
     31  /// Generics := '[' SimpleTypeSpec ']' (',[' SimpleTypeSpec ']')
     32  /// </code></para>
     33  ///
     34  /// <para><code>
     35  /// AssemblyProperty := 'Version=' Version
     36  ///                  |  'PublicKey(Token)?=[a-fA-F0-9]+'
     37  ///                  |  'Culture=[a-zA-F0-9]+'
     38  /// </code></para>
     39  ///
     40  /// <para><code>
     41  /// Version := \d+\.\d+\.\d+\.\d+
     42  /// </code></para>
     43  ///
     44  /// <para><code>
     45  /// IDENTIFIER = [_a-zA-Z][_a-ZA-Z0-9]* 
     46  /// </code></para>
     47  /// </summary>
    1348  public class TypeNameParser {
    1449
    … …  
    3570
    3671
    37     class Token {
     72    private class Token {
    3873      private static Dictionary<string, string> tokens =
    3974        new Dictionary<string, string> {
    … …  
    68103        }
    69104      }
    70       public static IEnumerable<Token> Tokenize(string s) {
     105      public static IEnumerable<Token> Tokenize(string s) {       
    71106        int pos = 0;
    72107        foreach (Match m in TokenRegex.Matches(s)) {

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

    r2994 r3004  
    66namespace HeuristicLab.Persistence.Core {
    77
     8  /// <summary>
     9  /// Defines the set of primitive and composite serializers that are to be used
     10  /// for a certain seraial format. The configuration can be obtained from the
     11  /// <code>ConfigurationService</code>.
     12  /// </summary>
    813  [StorableClass(StorableClassType.MarkedOnly)]   
    914  public class Configuration {

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

    r2876 r3004  
    1313namespace HeuristicLab.Persistence.Core {
    1414
     15  /// <summary>
     16  /// Provides a persistable configuration of primitive and composite serializers for
     17  /// all registered serial formats. Custom formats can be defined and will be saved
     18  /// for future sessions. A default configuration can be generated through reflection.
     19  ///
     20  /// This class has only a single instance.
     21  /// </summary>
    1522  public class ConfigurationService {
    1623
    1724    private static ConfigurationService instance;
    1825    private readonly Dictionary<IFormat, Configuration> customConfigurations;
     26
     27    /// <summary>
     28    /// List of all available primitive serializers.
     29    /// </summary>
    1930    public Dictionary<Type, List<IPrimitiveSerializer>> PrimitiveSerializers { get; private set; }
     31
     32    /// <summary>
     33    /// List of all available composite serializers (discovered through reflection).
     34    /// </summary>
    2035    public List<ICompositeSerializer> CompositeSerializers { get; private set; }
     36
     37    /// <summary>
     38    /// List of all available formats (discovered through reflection).   
     39    /// </summary>
    2140    public List<IFormat> Formats { get; private set; }
    2241
    … …  
    92111    }
    93112
     113
     114    /// <summary>
     115    /// Rediscover available serializers and discard all custom configurations.
     116    /// </summary>
    94117    public void Reset() {
    95118      customConfigurations.Clear();
    … …  
    108131    }
    109132
    110     class PriortiySorter : IComparer<ICompositeSerializer> {
     133    private class PriortiySorter : IComparer<ICompositeSerializer> {
    111134      public int Compare(ICompositeSerializer x, ICompositeSerializer y) {
    112135        return y.Priority - x.Priority;
    … …  
    169192    }
    170193
     194    /// <summary>
     195    /// Get the default (automatically discovered) configuration for a certain format.
     196    /// </summary>   
    171197    public Configuration GetDefaultConfig(IFormat format) {
    172198      Dictionary<Type, IPrimitiveSerializer> primitiveConfig = new Dictionary<Type, IPrimitiveSerializer>();
    … …  
    188214    }
    189215
     216
     217    /// <summary>
     218    /// Get a configuration for a certain format. This returns a custom configuration
     219    /// if defined, otherwise returns the default (automatically discovered) configuration.
     220    /// </summary>   
    190221    public Configuration GetConfiguration(IFormat format) {
    191222      if (customConfigurations.ContainsKey(format))
    … …  
    194225    }
    195226
     227    /// <summary>
     228    /// Define a new custom configuration for a ceratin format.
     229    /// </summary>   
    196230    public void DefineConfiguration(Configuration configuration) {
    197231      customConfigurations[configuration.Format] = configuration;

  • trunk/sources/HeuristicLab.Persistence/3.3/Core/DeSerializer.cs

    r2873 r3004  
    99namespace HeuristicLab.Persistence.Core {
    1010
     11  /// <summary>
     12  /// Core hub for deserialization. Reads the serialization token stream,
     13  /// instantiates objects and fills in values.
     14  /// </summary>
    1115  public class Deserializer {
    1216
    13     class Midwife {
     17    /// <summary>
     18    /// Helps in delivering the class instance and acts as proxy while
     19    /// the object cannot yet be instantiate.
     20    /// </summary>
     21    private class Midwife {
    1422
    1523      public int? Id { get; private set; }
    … …  
    5361      }
    5462    }
    55 
     63   
    5664    private readonly Dictionary<int, object> id2obj;
    5765    private readonly Dictionary<Type, object> serializerMapping;
    … …  
    5967    private readonly Dictionary<int, Type> typeIds;
    6068
     69    /// <summary>
     70    /// Instantiates a new deserializer with the given type cache,
     71    /// that contains information about the serializers to use
     72    /// for every type and their type ids.
     73    /// </summary>   
    6174    public Deserializer(
    6275      IEnumerable<TypeMapping> typeCache) {
    … …  
    92105    }
    93106
    94 
     107    /// <summary>
     108    /// Process the token stream and deserialize an instantate a new object graph.
     109    /// </summary>   
    95110    public object Deserialize(IEnumerable<ISerializationToken> tokens) {
    96111      foreach (ISerializationToken token in tokens) {

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

    r2994 r3004  
    44namespace HeuristicLab.Persistence.Interfaces {
    55
     6  /// <summary>
     7  /// Common base class for defining a new serialization format.
     8  /// </summary> 
    69  [StorableClass(StorableClassType.Empty)]
    710  public abstract class FormatBase<SerialDataFormat> : IFormat<SerialDataFormat> where SerialDataFormat : ISerialData {
    8 
     11   
    912    public abstract string Name { get; }
    1013
     14   
     15    /// <summary>
     16    /// Datatype that describes the atoms used for serialization serialization.
     17    /// </summary>
    1118    public Type SerialDataType { get { return typeof(SerialDataFormat); } }
    1219
     20    /// <summary>
     21    /// Compares formats by name.
     22    /// </summary>   
    1323    public bool Equals(FormatBase<SerialDataFormat> f) {
    1424      if (f == null)
    … …  
    1727    }
    1828
     29    /// <summary>
     30    /// Compares foramts by name.
     31    /// </summary>
    1932    public override bool Equals(object obj) {
    2033      FormatBase<SerialDataFormat> f = obj as FormatBase<SerialDataFormat>;

  • trunk/sources/HeuristicLab.Persistence/3.3/Core/GeneratorBase.cs

    r2718 r3004  
    1111namespace HeuristicLab.Persistence.Core {
    1212
     13  /// <summary>
     14  /// Base class for serialization generators. Provides a common entry point
     15  /// <code>Format</code> and dispatches to different abstract methods for
     16  /// every token type.
     17  /// </summary> 
    1318  public abstract class GeneratorBase<T> {
    1419

  • trunk/sources/HeuristicLab.Persistence/3.3/Core/PrimitiveSerializerBase.cs

    r2994 r3004  
    55namespace HeuristicLab.Persistence.Interfaces {
    66
     7  /// <summary>
     8  /// Base class for primitive serializers. These are serializers that map
     9  /// directly to a single datatype and directly produce a serializable object.
     10  /// </summary>
    711  [StorableClass(StorableClassType.Empty)]
    812  public abstract class PrimitiveSerializerBase<Source, SerialData> :

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

    r2993 r3004  
    1313namespace HeuristicLab.Persistence.Core {
    1414
     15  /// <summary>
     16  /// The core hub for serialization. This class transforms an object graph
     17  /// into a tree and later into a stream of serialization tokens using
     18  /// the given configuration.
     19  ///
     20  /// <para>Primitive serializers directly format an object to a serializable type.</para>
     21  ///
     22  /// <para>Composite serializers decompose an object into other object that are then
     23  /// recursively serialized.</para> 
     24  ///
     25  /// A constructed serializer is enumerable and continuously analyses
     26  /// and traverses the object graph while the enumerator is iterated
     27  /// </summary> 
    1528  public class Serializer : IEnumerable<ISerializationToken> {
    1629
    17     class ReferenceEqualityComparer : IEqualityComparer<object> {
     30    private class ReferenceEqualityComparer : IEqualityComparer<object> {
    1831
    1932      public new bool Equals(object a, object b) {
    … …  
    3750    private readonly List<Exception> exceptions;
    3851
     52    /// <summary>
     53    /// Contains a mapping of type id to type and serializer.
     54    /// </summary>
    3955    public List<TypeMapping> TypeCache {
    4056      get {
    … …  
    4359      }
    4460    }
    45 
     61   
     62    /// <summary>
     63    /// Contains a list of files (mostly assemblies) that are
     64    /// necessary to deserialize the object graph again.   
     65    /// </summary>
    4666    public List<string> RequiredFiles {
    4767      get {
    … …  
    7696      requiredFiles = new List<string>(files.Keys);
    7797    }
    78 
     98   
    7999    public Serializer(object obj, Configuration configuration) :
    80100      this(obj, configuration, "ROOT") { }
    … …  
    83103      : this(obj, configuration, rootName, false) { }
    84104
     105    /// <param name="isTestRun">Try to complete the whole object graph,
     106    /// don't stop at the first exception</param>
    85107    public Serializer(object obj, Configuration configuration, string rootName, bool isTestRun) {
    86108      this.obj = obj;
    … …  
    106128    }
    107129
    108     public IEnumerator<ISerializationToken> AddExceptionCompiler(IEnumerator<ISerializationToken> enumerator) {
     130    private IEnumerator<ISerializationToken> AddExceptionCompiler(IEnumerator<ISerializationToken> enumerator) {
    109131      while (enumerator.MoveNext())
    110132        yield return enumerator.Current;

  • trunk/sources/HeuristicLab.Persistence/3.3/Core/Tag.cs

    r1623 r3004  
    33namespace HeuristicLab.Persistence.Core {
    44
     5  /// <summary>
     6  /// Vehicle used inside the serialization/deserizalisation process
     7  /// between composite serializers and the core.
     8  /// </summary> 
    59  public class Tag {
    610    public string Name { get; private set; }

  • trunk/sources/HeuristicLab.Persistence/3.3/Core/Tokens/BeginToken.cs

    r1562 r3004  
    33namespace HeuristicLab.Persistence.Core.Tokens {
    44
     5
     6  /// <summary>
     7  /// Marks the beginning of a composite element.
     8  /// </summary>
    59  public class BeginToken : CompositeTokenBase {
    610    public BeginToken(string name, int typeId, int? id) : base(name, typeId, id) { }

  • trunk/sources/HeuristicLab.Persistence/3.3/Core/Tokens/CompositeTokenBase.cs

    r1562 r3004  
    22namespace HeuristicLab.Persistence.Core.Tokens {
    33
     4  /// <summary>
     5  /// Common base class of <code>BeginToken</code> and <code>EndToken</code>
     6  /// that surround a composite element.
     7  /// </summary>
    48  public abstract class CompositeTokenBase : SerializationTokenBase {
    59    public readonly int TypeId;

  • trunk/sources/HeuristicLab.Persistence/3.3/Core/Tokens/EndToken.cs

    r1562 r3004  
    33namespace HeuristicLab.Persistence.Core.Tokens {
    44
     5  /// <summary>
     6  /// Marks the end of a composite element.
     7  /// </summary>
    58  public class EndToken : CompositeTokenBase {
    69    public EndToken(string name, int typeId, int? id) : base(name, typeId, id) { }

  • trunk/sources/HeuristicLab.Persistence/3.3/Core/Tokens/MetaInfoBeginToken.cs

    r1556 r3004  
    22
    33namespace HeuristicLab.Persistence.Core.Tokens {
    4 
     4 
    55  public class MetaInfoBeginToken : ISerializationToken { }
    66

  • trunk/sources/HeuristicLab.Persistence/3.3/Core/Tokens/NulLReferenceToken.cs

    r1566 r3004  
    22
    33namespace HeuristicLab.Persistence.Core.Tokens {
    4 
     4 
    55  public class NullReferenceToken : SerializationTokenBase {
    66    public NullReferenceToken(string name) : base(name) { }

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

    r1566 r3004  
    33namespace HeuristicLab.Persistence.Core.Tokens {
    44
     5  /// <summary>
     6  /// Encapsulated the serialization of a single primitive value.
     7  /// </summary>
    58  public class PrimitiveToken : SerializationTokenBase {
    69    public readonly int TypeId;

  • trunk/sources/HeuristicLab.Persistence/3.3/Core/Tokens/ReferenceToken.cs

    r1566 r3004  
    33namespace HeuristicLab.Persistence.Core.Tokens {
    44
     5
     6  /// <summary>
     7  /// References a previously used token (composite or primitive).
     8  /// </summary>
    59  public class ReferenceToken : SerializationTokenBase {
    610    public readonly int Id;

  • trunk/sources/HeuristicLab.Persistence/3.3/Core/Tokens/SerializationTokenBase.cs

    r1615 r3004  
    44
    55namespace HeuristicLab.Persistence.Core.Tokens {
    6 
     6 
    77  public abstract class SerializationTokenBase : ISerializationToken {
    88    public readonly string Name;

  • trunk/sources/HeuristicLab.Persistence/3.3/Core/TypeMapping.cs

    r1623 r3004  
    33namespace HeuristicLab.Persistence.Core {
    44
     5  /// <summary>
     6  /// Association of id, type name and serializer
     7  /// </summary>
    58  public class TypeMapping {
    69

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

    r1938 r3004  
    55namespace HeuristicLab.Persistence.Default.CompositeSerializers.Storable {
    66
     7  /// <summary>
     8  /// Encapsulation and abstraction for access a data member of an object
     9  /// regardless of it being a property or field. Addicionally a
     10  /// default value and an alternate name can be specified.
     11  /// </summary>
    712  public class DataMemberAccessor {
    813
    … …  
    1217    public readonly object DefaultValue;
    1318
     19
     20    /// <summary>
     21    /// Create a DataMemberAccessor from a FieldInfo or PropertyInfo for the give object.
     22    /// </summary>
    1423    public DataMemberAccessor(MemberInfo memberInfo, string name, object defaultvalue, object obj) {
    1524      Name = name;
    … …  
    3342    }
    3443
     44    /// <summary>
     45    /// Wrap existing getter and setter functions.
     46    /// </summary>
    3547    public DataMemberAccessor(string name, object defaultValue,
    3648        Func<object> getter, Action<object> setter) {
    … …  
    4052      Set = setter;
    4153    }
    42 
     54   
     55    /// <summary>
     56    /// Create an empty accessor that just encapsulates an object
     57    /// without access.
     58    /// </summary>
    4359    public DataMemberAccessor(object o) {
    4460      Name = null;
    … …  
    4864    }
    4965
     66    /// <summary>
     67    /// Create an empty accessor that just encapsulates an object
     68    /// without access.
     69    /// </summary>
    5070    public DataMemberAccessor(object o, string name) {
    5171      Name = name;
    … …  
    5474      Set = null;
    5575    }
    56 
    5776
    5877    public override string ToString() {

  • trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/Primitive/System.Drawing/Bitmap2XmlSerializer.cs

    r2965 r3004  
    1111
    1212namespace HeuristicLab.Persistence.Default.Xml.Primitive {
    13   public class Bitmap2XmlSerializer :PrimitiveXmlSerializerBase<Bitmap>{
    14     private static Regex re = new Regex(@"<!\[CDATA\[((?:[^]]|\](?!\]>))*)\]\]>", RegexOptions.Singleline);
     13  public class Bitmap2XmlSerializer : PrimitiveXmlSerializerBase<Bitmap> {
    1514
    1615    public override XmlString Format(Bitmap o) {
    1716      MemoryStream stream = new MemoryStream();
    18       o.Save(stream,ImageFormat.Png);
     17      o.Save(stream, ImageFormat.Png);
    1918      byte[] array = stream.ToArray();
    2019      Byte1DArray2XmlSerializer serializer = new Byte1DArray2XmlSerializer();
    … …  
    3231      Bitmap bitmap = new Bitmap(stream);
    3332      return bitmap;
    34   }
     33    }
    3534  }
    3635}

  • trunk/sources/HeuristicLab.Persistence/3.3/Default/Xml/XmlGenerator.cs

    r2718 r3004  
    1111namespace HeuristicLab.Persistence.Default.Xml {
    1212
     13
     14  /// <summary>
     15  /// Main entry point of persistence to XML. Use the static methods to serialize
     16  /// to a file or to a stream.
     17  /// </summary>
    1318  public class XmlGenerator : GeneratorBase<string> {
    1419
    … …  
    155160    }
    156161
     162    /// <summary>
     163    /// Serialize an object into a file.
     164    ///
     165    /// The XML configuration is obtained from the <code>ConfigurationService</code>.
     166    /// The file is actually a ZIP file.
     167    /// Compression level is set to 5 and needed assemblies are not included.
     168    /// </summary>   
    157169    public static void Serialize(object o, string filename) {
    158       Serialize(o, filename, ConfigurationService.Instance.GetDefaultConfig(new XmlFormat()), false, 5);
    159     }
    160 
     170      Serialize(o, filename, ConfigurationService.Instance.GetConfiguration(new XmlFormat()), false, 5);
     171    }
     172
     173    /// <summary>
     174    /// Serialize an object into a file.
     175    ///
     176    /// The XML configuration is obtained from the <code>ConfigurationService</code>.
     177    /// Needed assemblies are not included.
     178    /// </summary>
     179    /// <param name="compression">ZIP file compression level</param>
    161180    public static void Serialize(object o, string filename, int compression) {
    162181      Serialize(o, filename, ConfigurationService.Instance.GetConfiguration(new XmlFormat()), false, compression);
    163182    }
     183
    164184
    165185    public static void Serialize(object obj, string filename, Configuration config) {

  • trunk/sources/HeuristicLab.Persistence/3.3/Interfaces/ISerialData.cs

    r1823 r3004  
    22
    33namespace HeuristicLab.Persistence.Interfaces {
    4 
    54
    65  /// <summary>
Note: See TracChangeset for help on using the changeset viewer.