Changeset 9363 for branches/OaaS/HeuristicLab.Persistence

Timestamp:

04/16/13 13:13:41 (12 years ago)

Author:

spimming

Message:

#1888:

• Merged revisions from trunk

Location:

branches/OaaS

Files:

• . (modified) (2 props)
• HeuristicLab.Persistence (modified) (1 prop)
• HeuristicLab.Persistence/3.3/Auxiliary/ObjectEqualityComparer.cs (copied) (copied from trunk/sources/HeuristicLab.Persistence/3.3/Auxiliary/ObjectEqualityComparer.cs)
• HeuristicLab.Persistence/3.3/Auxiliary/StringExtensions.cs (modified) (1 diff)
• HeuristicLab.Persistence/3.3/Auxiliary/TypeLoader.cs (modified) (2 diffs)
• HeuristicLab.Persistence/3.3/Auxiliary/TypeName.cs (modified) (8 diffs)
• HeuristicLab.Persistence/3.3/Auxiliary/TypeNameParser.cs (modified) (17 diffs)
• HeuristicLab.Persistence/3.3/Core/DeSerializer.cs (deleted)
• HeuristicLab.Persistence/3.3/Core/Deserializer.cs (copied) (copied from trunk/sources/HeuristicLab.Persistence/3.3/Core/Deserializer.cs)
• HeuristicLab.Persistence/3.3/Core/Tokens/NulLReferenceToken.cs (deleted)
• HeuristicLab.Persistence/3.3/Core/Tokens/NullReferenceToken.cs (copied) (copied from trunk/sources/HeuristicLab.Persistence/3.3/Core/Tokens/NullReferenceToken.cs)
• HeuristicLab.Persistence/3.3/Default/CompositeSerializers/TypeSerializer.cs (modified) (1 diff)
• HeuristicLab.Persistence/3.3/HeuristicLab.Persistence-3.3.csproj (modified) (3 diffs)
• HeuristicLab.Persistence/3.3/Plugin.cs.frame (modified) (1 diff)
• HeuristicLab.Persistence/3.3/Properties/AssemblyInfo.cs.frame (modified) (1 diff)

branches/OaaS

@@ -21 +21 @@
 protoc.exe
 _ReSharper.HeuristicLab 3.3 Tests
+Google.ProtocolBuffers-2.4.1.473.dll
 packages

@@ -21 +21 @@
 protoc.exe
 _ReSharper.HeuristicLab 3.3 Tests
+Google.ProtocolBuffers-2.4.1.473.dll
 packages

branches/OaaS/HeuristicLab.Persistence/3.3/Auxiliary/StringExtensions.cs

@@ -1 @@
-using System.Collections.Generic;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
 
 namespace HeuristicLab.Persistence.Auxiliary {

branches/OaaS/HeuristicLab.Persistence/3.3/Auxiliary/TypeLoader.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections.Generic;
 using System.Reflection;
 using HeuristicLab.Persistence.Core;
@@ -26 +27 @@
 
 namespace HeuristicLab.Persistence.Auxiliary {
+  internal class TypeLoader {
+    #region Mono Compatibility
+    private static TypeName cachedMonoRuntimeType;
+    private static TypeName cachedWindowsRuntimeType;
+    private static TypeName cachedMonoObjectEqualityComparerType;
+    private static TypeName cachedWindowsObjectEqualityComparerType;
 
-  internal class TypeLoader {
+    private static bool MonoInstalled {
+      get { return Type.GetType("Mono.Runtime") != null; }
+    }
+
+    static TypeLoader() {
+      // we use Int32 here because we get all the information about Mono's mscorlib and just have to change the class name
+      cachedMonoRuntimeType = TypeNameParser.Parse(typeof(System.Int32).AssemblyQualifiedName);
+      cachedMonoRuntimeType = new TypeName(cachedMonoRuntimeType, "MonoType");
+
+      cachedWindowsRuntimeType = TypeNameParser.Parse(typeof(System.Int32).AssemblyQualifiedName);
+      cachedWindowsRuntimeType = new TypeName(cachedWindowsRuntimeType, "RuntimeType");
+
+      // we need the information about the Persistence assembly, so we use TypeName here because it is contained in this assembly
+      cachedMonoObjectEqualityComparerType = TypeNameParser.Parse(typeof(TypeName).AssemblyQualifiedName);
+      cachedMonoObjectEqualityComparerType = new TypeName(cachedMonoObjectEqualityComparerType, "ObjectEqualityComparer", "HeuristicLab.Persistence.Mono");
+
+      cachedWindowsObjectEqualityComparerType = TypeNameParser.Parse(typeof(System.Int32).AssemblyQualifiedName);
+      cachedWindowsObjectEqualityComparerType = new TypeName(cachedWindowsObjectEqualityComparerType, "ObjectEqualityComparer", "System.Collections.Generic");
+    }
+    #endregion
 
     public static Type Load(string typeNameString) {
+      TypeName typeName = null;
+      try {
+        typeName = TypeNameParser.Parse(typeNameString);
+      }
+      catch (Exception) {
+        throw new PersistenceException(String.Format(
+           "Could not parse type string \"{0}\"",
+           typeNameString));
+      }
+
+      try {
+        // try to load type normally
+        return LoadInternal(typeName);
+      }
+      catch (PersistenceException) {
+        #region Mono Compatibility
+        // if that fails, try to convert to the corresponding Mono or .NET type
+        if (MonoInstalled) {
+          typeName = GetMonoType(typeName);
+          Logger.Info(String.Format(@"Trying to load Mono type ""{0}"" instead of .NET type ""{1}""",
+                                    typeName, typeNameString));
+        } else {
+          typeName = GetDotNetType(typeName);
+          Logger.Info(String.Format(@"Trying to load .NET type ""{0}"" instead of Mono type ""{1}""",
+                                    typeName, typeNameString));
+
+        }
+        return LoadInternal(typeName);
+        #endregion
+      }
+    }
+
+    private static Type LoadInternal(TypeName typeName) {
       Type type;
       try {
-        type = Type.GetType(typeNameString, true);
+        type = Type.GetType(typeName.ToString(true, true), true);
       }
       catch (Exception) {
         Logger.Warn(String.Format(
-          "Cannot load type \"{0}\", falling back to partial name", typeNameString));
-        try {
-          TypeName typeName = TypeNameParser.Parse(typeNameString);
-#pragma warning disable 0618
-          Assembly a = Assembly.LoadWithPartialName(typeName.AssemblyName);
-          // the suggested Assembly.Load() method fails to load assemblies outside the GAC
-#pragma warning restore 0618
-          type = a.GetType(typeName.ToString(false, false), true);
-        }
-        catch (Exception) {
-          throw new PersistenceException(String.Format(
-            "Could not load type \"{0}\"",
-            typeNameString));
-        }
-        try {
-          TypeName requestedTypeName = TypeNameParser.Parse(typeNameString);
-          TypeName loadedTypeName = TypeNameParser.Parse(type.AssemblyQualifiedName);
-          if (!requestedTypeName.IsCompatible(loadedTypeName))
-            throw new PersistenceException(String.Format(
-              "Serialized type is incompatible with available type: serialized: {0}, loaded: {1}",
-              typeNameString,
-              type.AssemblyQualifiedName));
-          if (requestedTypeName.IsNewerThan(loadedTypeName))
-            throw new PersistenceException(String.Format(
-              "Serialized type is newer than available type: serialized: {0}, loaded: {1}",
-              typeNameString,
-              type.AssemblyQualifiedName));
-        }
-        catch (PersistenceException) {
-          throw;
-        }
-        catch (Exception e) {
-          Logger.Warn(String.Format(
-            "Could not perform version check requested type was {0} while loaded type is {1}:",
-            typeNameString,
-            type.AssemblyQualifiedName),
-            e);
-        }
+          "Cannot load type \"{0}\", falling back to partial name", typeName.ToString(true, true)));
+        type = LoadWithPartialName(typeName);
+        CheckCompatibility(typeName, type);
       }
       return type;
     }
+
+    private static Type LoadWithPartialName(TypeName typeName) {
+      try {
+#pragma warning disable 0618
+        Assembly a = Assembly.LoadWithPartialName(typeName.AssemblyName);
+        // the suggested Assembly.Load() method fails to load assemblies outside the GAC
+#pragma warning restore 0618
+        return a.GetType(typeName.ToString(false, false), true);
+      }
+      catch (Exception) {
+        throw new PersistenceException(String.Format(
+          "Could not load type \"{0}\"",
+          typeName.ToString(true, true)));
+      }
+    }
+
+    private static void CheckCompatibility(TypeName typeName, Type type) {
+      try {
+        TypeName loadedTypeName = TypeNameParser.Parse(type.AssemblyQualifiedName);
+        if (!typeName.IsCompatible(loadedTypeName))
+          throw new PersistenceException(String.Format(
+            "Serialized type is incompatible with available type: serialized: {0}, loaded: {1}",
+            typeName.ToString(true, true),
+            type.AssemblyQualifiedName));
+        if (typeName.IsNewerThan(loadedTypeName))
+          throw new PersistenceException(String.Format(
+            "Serialized type is newer than available type: serialized: {0}, loaded: {1}",
+            typeName.ToString(true, true),
+            type.AssemblyQualifiedName));
+      }
+      catch (PersistenceException) {
+        throw;
+      }
+      catch (Exception e) {
+        Logger.Warn(String.Format(
+          "Could not perform version check requested type was {0} while loaded type is {1}:",
+          typeName.ToString(true, true),
+          type.AssemblyQualifiedName),
+                    e);
+      }
+    }
+
+    #region Mono Compatibility
+    /// <summary>
+    /// Returns the corresponding type for the Mono runtime
+    /// </summary>
+    /// <returns>
+    /// The remapped typeName, or the original typeName if no mapping was found
+    /// </returns>
+    private static TypeName GetMonoType(TypeName typeName) {
+      // map System.RuntimeType to System.MonoType
+      if (typeName.Namespace == "System" && typeName.ClassName == "RuntimeType") {
+        return cachedMonoRuntimeType;
+        // map System.Collections.Generic.ObjectEqualityComparer to HeuristicLab.Mono.ObjectEqualityComparer
+      } else if (typeName.Namespace == "System.Collections.Generic" && typeName.ClassName == "ObjectEqualityComparer") {
+        TypeName newTypeName = new TypeName(cachedMonoObjectEqualityComparerType);
+        newTypeName.GenericArgs = new List<TypeName>(typeName.GenericArgs);
+        return newTypeName;
+      }
+      return typeName;
+    }
+
+    /// <summary>
+    /// Returns the corresponding type for the .NET runtime
+    /// </summary>
+    /// <returns>
+    /// The remapped typeName, or the original typeName if no mapping was found
+    /// </returns>
+    private static TypeName GetDotNetType(TypeName typeName) {
+      // map System.MonoType to System.RuntimeType
+      if (typeName.Namespace == "System" && typeName.ClassName == "MonoType") {
+        return cachedWindowsRuntimeType;
+        // maps Mono's string comparer to System.Collections.Generic.ObjectEqualityComparer<string>
+      } else if (typeName.Namespace == "System.Collections.Generic" && typeName.ClassName == "InternalStringComparer") {
+        TypeName newTypeName = new TypeName(cachedWindowsObjectEqualityComparerType);
+        var genericArgsList = new List<TypeName>();
+        genericArgsList.Add(new TypeName(typeof(String).Namespace, "String"));
+        newTypeName.GenericArgs = genericArgsList;
+        return newTypeName;
+      } else if (typeName.Namespace == "System.Collections.Generic" && typeName.ClassName == "EqualityComparer+DefaultComparer") {
+        TypeName newTypeName = new TypeName(cachedWindowsObjectEqualityComparerType);
+        newTypeName.GenericArgs = new List<TypeName>(typeName.GenericArgs);
+        return newTypeName;
+      }
+      return typeName;
+    }
+    #endregion
   }
 }

branches/OaaS/HeuristicLab.Persistence/3.3/Auxiliary/TypeName.cs

@@ -51 +51 @@
 
     /// <summary>
+    /// Gets or sets the number of generic args for
+    /// each class in a series of nested classes.
+    /// </summary>
+    [Storable]
+    public List<int> GenericArgCounts { get; private set; }
+
+      /// <summary>
     /// Gets or sets the generic args.
     /// </summary>
@@ -103 +110 @@
     /// <param name="nameSpace">The namespace.</param>
     /// <param name="className">Name of the class.</param>
-    internal TypeName(string nameSpace, string className) {
+    internal TypeName(string nameSpace, string className, List<int> genericArgCounts=null) {
       Namespace = nameSpace;
       ClassName = className;
@@ -109 +116 @@
       MemoryMagic = "";
       AssemblyAttribues = new Dictionary<string, string>();
-    }
-
+      if (genericArgCounts != null)
+        GenericArgCounts = genericArgCounts.ToList();
+    }
+
+    internal TypeName(TypeName typeName, string className = null, string nameSpace = null) {
+      Namespace = nameSpace ?? typeName.Namespace;
+      ClassName = className ?? typeName.ClassName;
+      GenericArgs = new List<TypeName>(typeName.GenericArgs);
+      AssemblyAttribues = new Dictionary<string, string>(typeName.AssemblyAttribues);
+      MemoryMagic = typeName.MemoryMagic;
+      AssemblyName = typeName.AssemblyName;
+      IsReference = typeName.IsReference;
+      if (typeName.GenericArgCounts != null)
+        GenericArgCounts = typeName.GenericArgCounts.ToList();
+    }
 
     /// <summary>
@@ -135 +155 @@
     /// </returns>
     public string ToString(bool full, bool includeAssembly) {
-      StringBuilder sb = new StringBuilder();
+      var sb = new StringBuilder();
       if (!string.IsNullOrEmpty(Namespace))
         sb.Append(Namespace).Append('.');
-      sb.Append(ClassName);
+      if (GenericArgCounts != null) {
+        sb.Append(string.Join("+",
+          ClassName
+          .Split('+')
+          .Zip(GenericArgCounts, (n, c) =>
+            c > 0 ? String.Format("{0}`{1}", n, c) : n)));
+      } else {
+        sb.Append(ClassName);
+        if (IsGeneric)
+          sb.Append('`').Append(GenericArgs.Count);
+      }
       if (IsGeneric) {
-        sb.Append('`').Append(GenericArgs.Count).Append('[');
-        bool first = true;
-        foreach (TypeName t in GenericArgs) {
-          if (first)
-            first = false;
-          else
-            sb.Append(',');
-          sb.Append('[').Append(t.ToString(full)).Append(']');
-        }
+        sb.Append('[');
+        sb.Append(String.Join(",", GenericArgs.Select(a =>
+          string.Format("[{0}]", a.ToString(full)))));
         sb.Append(']');
       }
@@ -161 +185 @@
     }
 
-    public string GetTypeNameInCode(HashSet<string> omitNamespaces) {
-      StringBuilder sb = new StringBuilder();
-      if (!string.IsNullOrEmpty(Namespace) && omitNamespaces == null || !omitNamespaces.Contains(Namespace))
-        sb.Append(Namespace).Append('.');
-      sb.Append(ClassName);
-      if (IsGeneric) {
-        sb.Append("<");
-        sb.Append(
-          string.Join(", ",
-            GenericArgs
-              .Select(a => a.GetTypeNameInCode(omitNamespaces))
-              .ToArray()));
-        sb.Append(">");
+    private IEnumerable<string> GetNestedClassesInCode(HashSet<string> omitNamespaces, bool includeAllNamespaces) {
+      var i = 0;
+      foreach (var pair in ClassName.Split('+').Zip(GenericArgCounts, (n, c) => new {n, c})) {
+        if (pair.c == 0) {
+          yield return pair.n;
+        }
+        else {
+          yield return string.Format("{0}<{1}>",
+            pair.n,
+            string.Join(",",
+              GenericArgs
+                .GetRange(i, pair.c)
+                .Select(a => a.GetTypeNameInCode(omitNamespaces, includeAllNamespaces))));
+          i += pair.c;
+        }
+      }
+    }
+
+    private string GetTypeNameInCode(HashSet<string> omitNamespaces, bool includeNamespaces) {
+      var sb = new StringBuilder();
+      if (!string.IsNullOrEmpty(Namespace) &&
+            (omitNamespaces == null && includeNamespaces) ||
+             omitNamespaces != null && !omitNamespaces.Contains(Namespace))
+          sb.Append(Namespace).Append('.');
+      if (GenericArgCounts != null) {
+        sb.Append(string.Join(".", GetNestedClassesInCode(omitNamespaces, includeNamespaces)));
+      } else {
+        sb.Append(ClassName);
+        if (IsGeneric) {
+          sb.Append("<");
+          sb.Append(
+            string.Join(", ",
+                        GenericArgs
+                          .Select(a => a.GetTypeNameInCode(omitNamespaces, includeNamespaces))
+                          .ToArray()));
+          sb.Append(">");
+        }
       }
       sb.Append(MemoryMagic);
@@ -179 +227 @@
     }
 
-    public string GetTypeNameInCode(bool includeAllNamespaces) {
-      StringBuilder sb = new StringBuilder();
-      if (includeAllNamespaces)
-        sb.Append(Namespace).Append('.');
-      sb.Append(ClassName);
-      if (IsGeneric) {
-        sb.Append("<");
-        sb.Append(
-          string.Join(", ",
-            GenericArgs
-              .Select(a => a.GetTypeNameInCode(includeAllNamespaces))
-              .ToArray()));
-        sb.Append(">");
-      }
-      sb.Append(MemoryMagic);
-      return sb.ToString();
+    public string GetTypeNameInCode(HashSet<string> omitNamespaces) {
+      return GetTypeNameInCode(omitNamespaces, false);
+    }
+
+    public string GetTypeNameInCode(bool includeNamespaces) {
+      return GetTypeNameInCode(null, includeNamespaces);
     }
 
@@ -235 +273 @@
         }
         return false;
-      } catch (KeyNotFoundException) {
+      }
+      catch (KeyNotFoundException) {
         throw new Exception("Could not extract version information from type string");
       }
@@ -272 +311 @@
         }
         return true;
-      } catch (KeyNotFoundException) {
+      }
+      catch (KeyNotFoundException) {
         throw new Exception("Could not extract version infomration from type string");
       }

branches/OaaS/HeuristicLab.Persistence/3.3/Auxiliary/TypeNameParser.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -46 +47 @@
   /// 
   /// SimpleTypeSpec := (IDENTIFIER '.')*
-  ///                   (IDENTIFIER '+')*
+  ///                   (IDENTIFIER '`\d+'? '+')*
   ///                    IDENTIFIER
   ///                   ( '`\d+[' Generics ']' )?
@@ -69 +70 @@
 
       SimpleTypeSpec := (IDENTIFIER '.')*
-                        (IDENTIFIER '+')*
-                         IDENTIFIER
-                        ( '`\d+[' Generics ']' )?
+                        (IDENTIFIER '`\d+'?
+                        ( '+' IDENTIFIER '`\d+'? )*
+                        ( '[' Generics ']' )?
                         (\*|\[(\d+\.\.\d+|\d+\.\.\.|(|\*)(,(|\*))*)\])* 
                         (',\s*' IDENTIFIER (',\s*' AssemblyProperty)* )?
 
-      Generics := '[' SimpleTypeSpec ']' (',[' SimpleTypeSpec ']')
+      Generics := '[' SimpleTypeSpec ']' (',[' SimpleTypeSpec ']')*
 
       AssemblyProperty := 'Version=' Version
@@ -88 +89 @@
 
     private class Token {
-      private static Dictionary<string, string> tokens =
-        new Dictionary<string, string> {
-          {"-", "DASH"},
-          {"&", "AMPERSAND"},
-          {".", "DOT"},
-          {"+", "PLUS"},
-          {",", "COMMA"},
-          {"[", "OPEN_BRACKET"},
-          {"]", "CLOSE_BRACKET"},
-          {"*", "ASTERISK"},
-          {" ", "SPACE"},
-          {"=", "EQUALS"},
-          {"`", "BACKTICK"} };
-      private static Regex NumberRegex = new Regex("^\\d+$");
-      private static Regex IdentifierRegex = new Regex("^[_a-zA-Z][_a-zA-Z0-9]*$");
-      private static Regex TokenRegex = new Regex("[-&.+,\\[\\]* =`]|[a-f0-9]+|\\d+|[_a-zA-Z][_a-zA-Z0-9]*");
-      public string Name { get; private set; }
+      public enum Symbol { None, Dash, Ampersand, Dot, Plus, Comma, OpenBracket, CloseBracket, Asterisk, Space, Equals, Backtick }
+      private static readonly Dictionary<string, Symbol> TOKENS =
+        new Dictionary<string, Symbol> {
+          {"-", Symbol.Dash},
+          {"&", Symbol.Ampersand},
+          {".", Symbol.Dot},
+          {"+", Symbol.Plus},
+          {",", Symbol.Comma},
+          {"[", Symbol.OpenBracket},
+          {"]", Symbol.CloseBracket},
+          {"*", Symbol.Asterisk},
+          {" ", Symbol.Space},
+          {"=", Symbol.Equals},
+          {"`", Symbol.Backtick}};
+      private static readonly Regex NumberRegex = new Regex("^\\d+$");
+      private static readonly Regex IdentifierRegex = new Regex("^[_a-zA-Z][_a-zA-Z0-9]*$");
+      private static readonly Regex TokenRegex = new Regex("[-&.+,\\[\\]* =`]|[a-f0-9]+|\\d+|[_a-zA-Z][_a-zA-Z0-9]*");
+      public Symbol Name { get; private set; }
       public string Value { get; private set; }
       public bool IsIdentifier { get; private set; }
@@ -111 +113 @@
       private Token(string value, int pos) {
         Position = pos;
-        if (tokens.ContainsKey(value)) {
-          Name = tokens[value];
+        Name = Symbol.None;
+        if (TOKENS.ContainsKey(value)) {
+          Name = TOKENS[value];
         } else if (NumberRegex.IsMatch(value)) {
           Number = int.Parse(value);
@@ -128 +131 @@
       }
       public override string ToString() {
-        if (Name != null)
+        if (Name != Symbol.None)
           return "Token(" + Name + ")";
         if (Value != null)
@@ -154 +157 @@
     /// <summary>
     /// Parses the specified typename string as obtained by
-    /// <c>System.Object.GetType().FullName"</c>.
+    /// <c>System.Object.GetType().FullName</c> or 
+    /// <c>System.Object.GetType().AssemblyQualifiedName</c>.
     /// </summary>
     /// <param name="s">The typename string.</param>
@@ -181 +185 @@
     private TypeName TransformTypeSpec() {
       TypeName t = TransformSimpleTypeSpec();
-      t.IsReference = ConsumeToken("AMPERSAND");
+      t.IsReference = ConsumeToken(Token.Symbol.Ampersand);
       return t;
     }
 
     private TypeName TransformSimpleTypeSpec() {
-      List<string> nameSpace = new List<string>();
-      nameSpace.Add(ConsumeIdentifier());
-      while (ConsumeToken("DOT"))
+      var nameSpace = new List<string> { ConsumeIdentifier() };
+      while (ConsumeToken(Token.Symbol.Dot))
         nameSpace.Add(ConsumeIdentifier());
-      List<string> className = new List<string>();
+      var className = new List<string>();
       if (nameSpace.Count > 0) {
         className.Add(nameSpace[nameSpace.Count - 1]);
         nameSpace.RemoveAt(nameSpace.Count - 1);
       }
-      while (ConsumeToken("PLUS"))
+      var genericArgCounts = new List<int> {
+        ConsumeToken(Token.Symbol.Backtick) ? ConsumeNumber() : 0
+      };
+      while (ConsumeToken(Token.Symbol.Plus)) {
         className.Add(ConsumeIdentifier());
-      TypeName typeName = new TypeName(
+        genericArgCounts.Add(ConsumeToken(Token.Symbol.Backtick) ? ConsumeNumber() : 0);
+      }
+      var nGenericArgs = genericArgCounts.Sum();
+      var typeName = new TypeName(
         string.Join(".", nameSpace.ToArray()),
-        string.Join("+", className.ToArray()));
-      if (ConsumeToken("BACKTICK")) {
-        int nGenericArgs = ConsumeNumber();
-        if (ConsumeToken("OPEN_BRACKET") &&
-          CanConsumeToken("OPEN_BRACKET")) {
-          typeName.GenericArgs.AddRange(TransformGenerics());
-          ConsumeToken("CLOSE_BRACKET", true);
-        }
-      }
-      StringBuilder pointerOrArray = new StringBuilder();
+        string.Join("+", className.ToArray()),
+        nGenericArgs > genericArgCounts.Last() ? genericArgCounts : null);
+      if (nGenericArgs > 0 && ConsumeToken(Token.Symbol.OpenBracket, true)) {
+        typeName.GenericArgs.AddRange(TransformGenerics());
+        ConsumeToken(Token.Symbol.CloseBracket, true);
+      }
+      var pointerOrArray = new StringBuilder();
       while (true) {
-        if (ConsumeToken("ASTERSIK")) {
+        if (ConsumeToken(Token.Symbol.Asterisk)) {
           pointerOrArray.Append("*");
-        } else if (ConsumeToken("OPEN_BRACKET")) {
+        } else if (ConsumeToken(Token.Symbol.OpenBracket)) {
           pointerOrArray.Append('[');
           ParseDimension(pointerOrArray);
-          while (ConsumeToken("COMMA")) {
+          while (ConsumeToken(Token.Symbol.Comma)) {
             pointerOrArray.Append(",");
             ParseDimension(pointerOrArray);
           }
-          ConsumeToken("CLOSE_BRACKET", true);
+          ConsumeToken(Token.Symbol.CloseBracket, true);
           pointerOrArray.Append(']');
         } else {
@@ -227 +233 @@
       typeName.MemoryMagic = pointerOrArray.ToString();
       if (ConsumeComma()) {
-        StringBuilder sb = new StringBuilder();
+        var sb = new StringBuilder();
         sb.Append(ConsumeIdentifier());
-        while (CanConsumeToken("DOT") ||
-          CanConsumeToken("DASH") ||
+        while (CanConsumeToken(Token.Symbol.Dot) ||
+          CanConsumeToken(Token.Symbol.Dash) ||
           CanConsumeNumber() ||
           CanConsumeIdentifier()) {
-          if (ConsumeToken("DOT"))
+          if (ConsumeToken(Token.Symbol.Dot))
             sb.Append('.');
-          else if (ConsumeToken("DASH"))
+          else if (ConsumeToken(Token.Symbol.Dash))
             sb.Append('-');
           else if (CanConsumeNumber())
@@ -253 +259 @@
 
     private void ParseDimension(StringBuilder sb) {
-      if (ConsumeToken("ASTERSIK")) {
+      if (ConsumeToken(Token.Symbol.Asterisk)) {
         sb.Append("*");
       } else if (CanConsumeNumber()) {
         sb.Append(ConsumeNumber());
-        ConsumeToken("DOT", true);
-        ConsumeToken("DOT", true);
-        if (ConsumeToken("DOT")) {
+        ConsumeToken(Token.Symbol.Dot, true);
+        ConsumeToken(Token.Symbol.Dot, true);
+        if (ConsumeToken(Token.Symbol.Dot)) {
           sb.Append("...");
         } else {
@@ -268 +274 @@
 
     private IEnumerable<TypeName> TransformGenerics() {
-      ConsumeToken("OPEN_BRACKET", true);
+      ConsumeToken(Token.Symbol.OpenBracket, true);
       yield return TransformSimpleTypeSpec();
-      ConsumeToken("CLOSE_BRACKET", true);
-      while (ConsumeToken("COMMA")) {
-        ConsumeToken("OPEN_BRACKET", true);
+      ConsumeToken(Token.Symbol.CloseBracket, true);
+      while (ConsumeToken(Token.Symbol.Comma)) {
+        ConsumeToken(Token.Symbol.OpenBracket, true);
         yield return TransformSimpleTypeSpec();
-        ConsumeToken("CLOSE_BRACKET", true);
+        ConsumeToken(Token.Symbol.CloseBracket, true);
       }
     }
@@ -280 +286 @@
     private KeyValuePair<string, string> TransformAssemblyProperty() {
       if (ConsumeIdentifier("Version")) {
-        ConsumeToken("EQUALS", true);
+        ConsumeToken(Token.Symbol.Equals, true);
         return new KeyValuePair<string, string>(
           "Version",
@@ -300 +306 @@
 
     private KeyValuePair<string, string> ConsumeAssignment(string name) {
-      ConsumeToken("EQUALS", true);
+      ConsumeToken(Token.Symbol.Equals, true);
       return new KeyValuePair<string, string>(name, ConsumeToken());
     }
@@ -307 +313 @@
       StringBuilder version = new StringBuilder();
       version.Append(ConsumeNumber());
-      ConsumeToken("DOT");
+      ConsumeToken(Token.Symbol.Dot);
       version.Append('.').Append(ConsumeNumber());
-      ConsumeToken("DOT");
+      ConsumeToken(Token.Symbol.Dot);
       version.Append('.').Append(ConsumeNumber());
-      ConsumeToken("DOT");
+      ConsumeToken(Token.Symbol.Dot);
       version.Append('.').Append(ConsumeNumber());
       return version.ToString();
@@ -368 +374 @@
 
     private bool ConsumeComma() {
-      if (ConsumeToken("COMMA")) {
-        while (ConsumeToken("SPACE")) ;
+      if (ConsumeToken(Token.Symbol.Comma)) {
+        while (ConsumeToken(Token.Symbol.Space)) ;
         return true;
       } else {
@@ -376 +382 @@
     }
 
-    private bool ConsumeToken(string name) {
-      return ConsumeToken(name, false);
-    }
-
-    private bool CanConsumeToken(string name) {
-      if (tokens.Count == 0)
-        return false;
-      if (tokens.Peek().Name == name)
+    private bool ConsumeToken(Token.Symbol symbol) {
+      return ConsumeToken(symbol, false);
+    }
+
+    private bool CanConsumeToken(Token.Symbol symbol) {
+      if (tokens.Count == 0)
+        return false;
+      if (tokens.Peek().Name == symbol)
         return true;
       return false;
     }
 
-    private bool ConsumeToken(string name, bool force) {
+    private bool ConsumeToken(Token.Symbol symbol, bool force) {
       if (tokens.Count == 0)
         if (force)
           throw new ParseError(String.Format(
             "end of input while expecting token \"{0}\"",
-            name));
+            symbol));
         else
           return false;
-      if (tokens.Peek().Name == name) {
+      if (tokens.Peek().Name == symbol) {
         tokens.Dequeue();
         return true;
@@ -402 +408 @@
         throw new ParseError(String.Format(
           "expected \"{0}\" found \"{1}\"",
-          name,
+          symbol,
           tokens.Peek().ToString()));
       } else {

branches/OaaS/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/TypeSerializer.cs

@@ -41 +41 @@
 
     public bool CanSerialize(Type type) {
+      #region Mono Compatibility
       return type == typeof(Type) ||
-             type.VersionInvariantName() == "System.RuntimeType, mscorlib";
+        type.VersionInvariantName() == "System.RuntimeType, mscorlib" ||
+        type.VersionInvariantName() == "System.MonoType, mscorlib";
+      #endregion
     }
 
     public string JustifyRejection(Type type) {
-      return "not System.Type nor System.RuntimeType";
+      #region Mono Compatibility
+      return "not System.Type, System.RuntimeType, System.MonoType";
+      #endregion
     }
 

branches/OaaS/HeuristicLab.Persistence/3.3/HeuristicLab.Persistence-3.3.csproj

@@ -125 +125 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Auxiliary\ObjectEqualityComparer.cs" />
     <Compile Include="Auxiliary\StringExtensions.cs" />
     <Compile Include="Auxiliary\TypeLoader.cs" />
@@ -246 +247 @@
   </ItemGroup>
   <PropertyGroup>
-    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
 set ProjectDir=$(ProjectDir)
 set SolutionDir=$(SolutionDir)
@@ -252 +253 @@
 
 call PreBuildEvent.cmd
+</PreBuildEvent>
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+export ProjectDir=$(ProjectDir)
+export SolutionDir=$(SolutionDir)
+
+$SolutionDir/PreBuildEvent.sh
 </PreBuildEvent>
     <PostBuildEvent>

branches/OaaS/HeuristicLab.Persistence/3.3/Plugin.cs.frame

@@ -27 +27 @@
   /// The plugin for HeuriticLab.Persistence
   /// </summary>
-  [Plugin("HeuristicLab.Persistence", "3.3.6.$WCREV$")]
+  [Plugin("HeuristicLab.Persistence", "3.3.7.$WCREV$")]
   [PluginFile("HeuristicLab.Persistence-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Tracing", "3.3")]

branches/OaaS/HeuristicLab.Persistence/3.3/Properties/AssemblyInfo.cs.frame

@@ -52 +52 @@
 //
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.6.$WCREV$")]
+[assembly: AssemblyFileVersion("3.3.7.$WCREV$")]

@@ -21 +21 @@
 protoc.exe
 _ReSharper.HeuristicLab 3.3 Tests
+Google.ProtocolBuffers-2.4.1.473.dll
 packages