source: branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/Descriptors/TypeDescriptor.cs

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2011 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;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;

namespace HeuristicLab.Persistence.Default.CompositeSerializers.Storable.Descriptors {

  /// <summary>
  /// Type descriptor containing all relevant reflection information for serialization and
  /// deserialization of storable types.
  /// </summary>
  [StorableClass]
  public sealed class TypeDescriptor {

    #region Properties
    /// <summary>
    /// Type descriptor of the base class
    /// </summary>
    [Storable]
    public TypeDescriptor BaseTypeDescriptor { get; set; }

    /// <summary>
    /// Whether the type is marked as storable class or not.
    /// </summary>
    [Storable]
    public bool IsStorableClass { get; set; }

    /// <summary>
    /// The assembly qualified name of the type.
    /// </summary>
    [Storable]
    public string AssemblyQualifiedName { get; set; }

    /// <summary>
    /// Whether the type has a default contructor.
    /// </summary>
    [Storable]
    public bool HasDefaultConstructor { get; set; }

    /// <summary>
    /// Whether the type has a storable constructor. (One bool argument
    /// and marked with the [StorableConstructor] attribute.
    /// </summary>
    [Storable]
    public bool HasStorableConstructor { get; set; }

    /// <summary>
    /// A list of field descriptors describing all storable fields.
    /// </summary>
    [Storable]
    public List<FieldDescriptor> Fields { get; set; }

    /// <summary>
    /// A list of property descriptors describing all storable properties.
    /// </summary>
    [Storable]
    public List<PropertyDescriptor> Properties { get; set; }

    /// <summary>
    /// A list of hook descriptors describing all storable hooks.
    /// </summary>
    [Storable]
    public List<HookDescriptor> Hooks { get; set; }

    /// <summary>
    /// Indicates that the given type is incompatible with the storable serializer.
    /// </summary>
    [Storable]
    public bool IsInvalid { get; set; }

    internal Type handle;
    /// <summary>
    /// Get the System.Type handle representing this type.
    /// </summary>
    public Type Handle {
      get {
        if (handle == null)
          handle = Type.GetType(AssemblyQualifiedName);
        return handle;
      }
    }
    #endregion

    #region Constants
    private static BindingFlags ALL_INSTANCE = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
    private static Type[] ONE_ARG_BOOL = new[] { typeof(bool) };
    #endregion

    #region Cache
    private ConstructorInfo storableConstructor;
    /// <summary>
    /// Get the constructor info of the storable constructor (if any).
    /// </summary>
    public ConstructorInfo StorableConstructor {
      get {
        if (storableConstructor == null && HasStorableConstructor)
          storableConstructor = Handle.GetConstructor(ALL_INSTANCE, null, Type.EmptyTypes, null);
        return storableConstructor;
      }
      internal set {
        storableConstructor = value;
      }
    }

    private ConstructorInfo defaultConstructor;
    /// <summary>
    /// Get the constructor info of the default constructor (if any).
    /// </summary>
    public ConstructorInfo DefaultConstructor {
      get {
        if (defaultConstructor == null && HasDefaultConstructor)
          defaultConstructor = Handle.GetConstructor(ALL_INSTANCE, null, ONE_ARG_BOOL, null);
        return defaultConstructor;
      }
      internal set {
        defaultConstructor = value;
      }
    }
    #endregion

    /// <summary>
    /// Empty storable constructor.
    /// </summary>
    [StorableConstructor]
    private TypeDescriptor(bool deserializing) { }

    /// <summary>
    /// Instantiate a new type descriptor for the given type. This does not add any
    /// methods, fields or properties and should only by called within a
    /// discovery service such as the <code>StorableClassAnalyzer</code>.
    /// </summary>
    /// <param name="handle"></param>
    public TypeDescriptor(Type handle) {
      if (handle.ContainsGenericParameters)
        throw new ArgumentException("Can only create type descriptor for types without generic type parameters (closed)");
      this.handle = handle;
      AssemblyQualifiedName = handle.AssemblyQualifiedName;
      Fields = new List<FieldDescriptor>();
      Properties = new List<PropertyDescriptor>();
      Hooks = new List<HookDescriptor>();
    }

    /// <summary>
    /// Ensures that field and property names of this class and its base classes
    /// do not collide by prefixing them if necessary.
    /// </summary>
    public void Disentangle() {
      if (BaseTypeDescriptor != null)
        AnalyzeBaseClass();
      DisentangleFields();
      DisentangleProperties();
    }

    private void AnalyzeBaseClass() {
      Fields = BaseTypeDescriptor.Fields.Select(f => (FieldDescriptor)f.Clone()).Concat(Fields).ToList();
      Properties = BaseTypeDescriptor.Properties.Select(p => (PropertyDescriptor)p.Clone()).Concat(Properties).ToList();
      Hooks = BaseTypeDescriptor.Hooks.Concat(Hooks).ToList();
    }

    private void DisentangleFields() {
      var nameGroups = GroupByName(Fields);
      foreach (var group in nameGroups.Values) {
        if (group.Count > 1) {
          foreach (var f in group) {
            if (f.StoredName != null) {
              f.StoredName = string.Format("{0}.{1}", f.DeclaringType.AssemblyQualifiedName, f.StoredName);
            }
          }
        }
      }
    }

    private void DisentangleProperties() {
      if (Handle == null)
        throw new InvalidOperationException(string.Format(
          "Cannot disentangle properties. Type {0} cannot be activated and is either not loaded or outdated", AssemblyQualifiedName));

      var nameGroups = GroupByName(Properties);
      Properties.Clear();
      foreach (var group in nameGroups.Values) {
        if (group.Count == 1) {
          Properties.Add(group[0]);
        } else {
          var uniqueAccessors = new Dictionary<Type, PropertyDescriptor>();
          foreach (var pi in group)
            uniqueAccessors[pi.DeclaringBaseType] = pi;
          foreach (var pi in uniqueAccessors.Values) {
            pi.StoredName = pi.DeclaringBaseType.FullName + pi.RealName;
          }
          Properties.AddRange(uniqueAccessors.Select(kvp => kvp.Value));
        }
      }
    }

    private static Dictionary<string, List<T>> GroupByName<T>(IEnumerable<T> fields) where T : ITypeComponent {
      var nameGroups = new Dictionary<string, List<T>>();
      foreach (var field in fields) {
        if (!nameGroups.ContainsKey(field.Name))
          nameGroups[field.Name] = new List<T>() { field };
        else
          nameGroups[field.Name].Add(field);
      }
      return nameGroups;
    }

    /// <summary>
    /// Creates a string representation of this type descriptor.
    /// </summary>
    public override string ToString() {
      StringBuilder sb = new StringBuilder();
      if (IsStorableClass)
        sb.Append("[StorableClass] ");
      sb.Append(AssemblyQualifiedName);
      if (handle != null)
        sb.Append("*");
      if (HasDefaultConstructor)
        sb.Append(" ()");
      if (HasStorableConstructor)
        sb.Append(" (bool)");
      sb.AppendLine();
      foreach (var field in Fields)
        sb.Append("  F ").AppendLine(field.ToString());
      foreach (var property in Properties)
        sb.Append("  P ").AppendLine(property.ToString());
      foreach (var hook in Hooks)
        sb.Append("  H ").AppendLine(hook.ToString());
      return sb.ToString();
    }

    private Func<object, Dictionary<string, object>> decomposeMethod;
    private Action<object, Dictionary<string, object>> populateMathod;
    private Func<object> createInstanceMethod;

    /// <summary>
    /// Decomposes objects as described by this type descriptor.
    /// </summary>
    /// <param name="o">The object to decompose.</param>
    /// <returns>A dictionary of component names (fields &amp; properites) and its values.</returns>
    public Dictionary<string, object> Decompose(object o) {
      if (decomposeMethod == null)
        decomposeMethod = TypeSerializationCompiler.GenerateDecomposeMethod(this);
      return decomposeMethod(o);
    }

    /// <summary>
    /// Populates objects as described by this type descriptor.
    /// </summary>
    /// <param name="instance">The instance whose fields a properties should be set.</param>
    /// <param name="values">A dictionary of names (fields &amp; properties) and their new values.</param>
    public void Populate(object instance, Dictionary<string, object> values) {
      if (populateMathod == null)
        populateMathod = TypeSerializationCompiler.GeneratePopulateMethod(this);
      populateMathod(instance, values);
    }

    /// <summary>
    /// Creates an instance of the described type using either the storable
    /// constructor if availble or the default constructor otherwise.
    /// </summary>
    /// <returns>A fresh instance of the described type.</returns>
    public object CreateInstance() {
      if (createInstanceMethod == null)
        createInstanceMethod = TypeSerializationCompiler.GenerateCreateInstanceMethod(this);
      return createInstanceMethod();
    }

  }
}