Changeset 3004 for trunk/sources/HeuristicLab.Persistence/3.3/Auxiliary

Timestamp:

03/11/10 12:54:14 (15 years ago)

Author:

epitzer

Message:

add complete persistence API docs (#548)

Location:

trunk/sources/HeuristicLab.Persistence/3.3/Auxiliary

Files:

• TypeLoader.cs (modified) (1 diff)
• TypeName.cs (modified) (4 diffs)
• TypeNameParser.cs (modified) (3 diffs)

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

@@ -10 +10 @@
 namespace HeuristicLab.Persistence.Auxiliary {
 
-  public class TypeLoader {
+  internal class TypeLoader {
 
     public static Type Load(string typeNameString) {

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

@@ -4 +4 @@
 using System.Reflection.Emit;
 using System.Collections.Generic;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Persistence.Auxiliary {
   
+  /// <summary>
+  /// Contains a more modular representation of type names that can
+  /// be used to compare versions and ignore extended assembly
+  /// attributes.
+  /// </summary>
+  [StorableClass(StorableClassType.MarkedOnly)]
   public class TypeName {
+
+    [Storable]
     public string Namespace { get; private set; }
+
+    [Storable]
     public string ClassName { get; private set; }
+
+    [Storable]
     public List<TypeName> GenericArgs { get; internal set; }
     public bool IsGeneric { get { return GenericArgs.Count > 0; } }
+
+    [Storable]
     public string MemoryMagic { get; internal set; }
+
+    [Storable]
     public string AssemblyName { get; internal set; }
+
+    [Storable]
     public Dictionary<string, string> AssemblyAttribues { get; internal set; }
+
+    [Storable]
     public bool IsReference { get; internal set; }
 
@@ -25 +46 @@
     }
 
+    /// <param name="full">include assembly properties and generic parameters</param>    
     public string ToString(bool full) {
       return ToString(full, true);
     }
 
-    public string ToString(bool full, bool includeAssembly) {
+
+    /// <param name="full">include assembly properties and generic parameters</param>    
+    public string ToString(bool full, bool includeAssembly) {      
       StringBuilder sb = new StringBuilder();
       if (!string.IsNullOrEmpty(Namespace))
@@ -60 +84 @@
     }
 
-    public bool IsNewerThan(TypeName t) {
+
+    /// <summary>
+    /// Lexicographically compare version information and make sure type and assembly
+    /// names are identical. This function recursively checks generic type arguments.
+    /// </summary>    
+    public bool IsNewerThan(TypeName typeName) {
       try {
-        if (this.ClassName != t.ClassName ||
-          this.Namespace != t.Namespace ||
-          this.AssemblyName != t.AssemblyName)
+        if (this.ClassName != typeName.ClassName ||
+          this.Namespace != typeName.Namespace ||
+          this.AssemblyName != typeName.AssemblyName)
           throw new Exception("Cannot compare versions of different types");
         if (CompareVersions(
           this.AssemblyAttribues["Version"],
-          t.AssemblyAttribues["Version"]) > 0)
+          typeName.AssemblyAttribues["Version"]) > 0)
           return true;
         IEnumerator<TypeName> thisIt = this.GenericArgs.GetEnumerator();
-        IEnumerator<TypeName> tIt = t.GenericArgs.GetEnumerator();
+        IEnumerator<TypeName> tIt = typeName.GenericArgs.GetEnumerator();
         while (thisIt.MoveNext()) {
           tIt.MoveNext();
@@ -83 +112 @@
     }
 
-    public bool IsCompatible(TypeName t) {
+
+    /// <summary>
+    /// Make sure major and minor version number are identical. This function
+    /// recursively checks generic type arguments.
+    /// </summary>
+    public bool IsCompatible(TypeName typeName) {
       try {
-        if (this.ClassName != t.ClassName ||
-          this.Namespace != t.Namespace ||
-          this.AssemblyName != t.AssemblyName)
+        if (this.ClassName != typeName.ClassName ||
+          this.Namespace != typeName.Namespace ||
+          this.AssemblyName != typeName.AssemblyName)
           throw new Exception("Cannot compare versions of different types");
         Version thisVersion = new Version(this.AssemblyAttribues["Version"]);
-        Version tVersion = new Version(t.AssemblyAttribues["Version"]);
+        Version tVersion = new Version(typeName.AssemblyAttribues["Version"]);
         if (thisVersion.Major != tVersion.Major ||
           thisVersion.Minor != tVersion.Minor)
           return false;
         IEnumerator<TypeName> thisIt = this.GenericArgs.GetEnumerator();
-        IEnumerator<TypeName> tIt = t.GenericArgs.GetEnumerator();
+        IEnumerator<TypeName> tIt = typeName.GenericArgs.GetEnumerator();
         while (thisIt.MoveNext()) {
           tIt.MoveNext();

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

@@ -11 +11 @@
   }
 
+
+  /// <summary>
+  /// Parse a .NET type name using the following grammar:  
+  ///   
+  /// <para><code>
+  /// TypeSpec := SimpleTypeSpec '&amp;'?  
+  /// </code></para>
+  /// 
+  /// <para><code>
+  /// SimpleTypeSpec := (IDENTIFIER '.')*
+  ///                   (IDENTIFIER '+')*
+  ///                    IDENTIFIER
+  ///                   ( '`\d+[' Generics ']' )?
+  ///                   (\*|\[(\d+\.\.\d+|\d+\.\.\.|(|\*)(,(|\*))*)\])* 
+  ///                   (',\s*' IDENTIFIER (',\s*' AssemblyProperty)* )?  
+  /// </code></para>
+  ///
+  /// <para><code>
+  /// Generics := '[' SimpleTypeSpec ']' (',[' SimpleTypeSpec ']')
+  /// </code></para>
+  ///
+  /// <para><code>
+  /// AssemblyProperty := 'Version=' Version
+  ///                  |  'PublicKey(Token)?=[a-fA-F0-9]+'
+  ///                  |  'Culture=[a-zA-F0-9]+'
+  /// </code></para>
+  ///
+  /// <para><code>
+  /// Version := \d+\.\d+\.\d+\.\d+
+  /// </code></para>
+  ///
+  /// <para><code>
+  /// IDENTIFIER = [_a-zA-Z][_a-ZA-Z0-9]*  
+  /// </code></para>
+  /// </summary>
   public class TypeNameParser {
 
@@ -35 +70 @@
 
 
-    class Token {
+    private class Token {
       private static Dictionary<string, string> tokens =
         new Dictionary<string, string> {
@@ -68 +103 @@
         }
       }
-      public static IEnumerable<Token> Tokenize(string s) {
+      public static IEnumerable<Token> Tokenize(string s) {        
         int pos = 0;
         foreach (Match m in TokenRegex.Matches(s)) {