source: branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableClassAnalyzer.cs @ 6224

#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 HeuristicLab.Persistence.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable.Descriptors;

namespace HeuristicLab.Persistence.Default.CompositeSerializers.Storable {

  /// <summary>
  /// Analyzes storables classes and creates a datastructure containing all required
  /// reflection information to serialize and deserialized these types.
  /// </summary>  
  public static class StorableClassAnalyzer {

    private static Dictionary<Type, TypeDescriptor> typeDescriptors = new Dictionary<Type, TypeDescriptor>();
    private static object typeDescriptorLock = new object();

    /// <summary>
    /// A list of all types that have been analyzed by this instance.
    /// </summary>
    public static IEnumerable<Type> KnownTypes { get { lock (typeDescriptorLock) { return typeDescriptors.Keys; } } }

    /// <summary>
    /// Retrieve analyzis results for a certain type. This either returns
    /// already cached results or analyzes the given type and caches the
    /// results.
    /// </summary>
    /// <param name="type">The type to be analyzed.</param>
    /// <returns>A TypeDescriptor object that encapsulates all necessary reflection information.</returns>
    public static TypeDescriptor GetDescriptor(Type type) {
      TypeDescriptor typeDescriptor = null;
      lock (typeDescriptorLock) {
        typeDescriptors.TryGetValue(type, out typeDescriptor);
      }
      if (typeDescriptor != null)
        return typeDescriptor;
      typeDescriptor = new TypeDescriptor(type);
      AddMembers(type, typeDescriptor);
      if (!typeDescriptor.IsInvalid) {
        typeDescriptor.Disentangle();
        lock (typeDescriptorLock) {
          typeDescriptors[type] = typeDescriptor;
        }
      }
      return typeDescriptor;
    }

    private static void AddMembers(Type type, TypeDescriptor typeDescriptor) {
      if (type.BaseType != null) {
        typeDescriptor.BaseTypeDescriptor = StorableClassAnalyzer.GetDescriptor(type.BaseType);
        if (typeDescriptor.BaseTypeDescriptor.IsInvalid) {
          typeDescriptor.IsInvalid = true;
          return;
        }
      }
      var attribute = (StorableClassAttribute)type.GetCustomAttributes(typeof(StorableClassAttribute), false).SingleOrDefault();
      typeDescriptor.IsStorableClass = attribute != null;
      foreach (MemberInfo member in type.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)) {
        switch (member.MemberType) {
          case MemberTypes.Constructor: MaybeAddConstructor((ConstructorInfo)member, typeDescriptor); break;
          case MemberTypes.Field: MaybeAddField((FieldInfo)member, typeDescriptor, attribute); break;
          case MemberTypes.Property: MaybeAddProperty((PropertyInfo)member, typeDescriptor, attribute); break;
          case MemberTypes.Method: MaybeAddHook((MethodInfo)member, typeDescriptor); break;
        }
        if (typeDescriptor.IsInvalid) return;
      }
    }

    private static bool IsMutableField(FieldInfo fi) {
      return !fi.IsLiteral && !fi.IsInitOnly;
    }

    private static bool IsMutableProperty(PropertyInfo pi) {
      return pi.CanWrite;
    }

    private static void MaybeAddConstructor(ConstructorInfo constructorInfo, TypeDescriptor typeDescriptor) {
      ParameterInfo[] parameters = constructorInfo.GetParameters();
      if (parameters.Length == 0) {
        typeDescriptor.HasDefaultConstructor = true;
        typeDescriptor.DefaultConstructor = constructorInfo;
      }
      if (parameters.Length == 1 &&
          parameters[0].ParameterType == typeof(bool) &&
          constructorInfo.GetCustomAttributes(typeof(StorableConstructorAttribute), false).Length == 1) {
        typeDescriptor.HasStorableConstructor = true;
        typeDescriptor.StorableConstructor = constructorInfo;
      }
    }

    private static void MaybeAddField(FieldInfo fieldInfo, TypeDescriptor typeDescriptor, StorableClassAttribute classAttribute) {
      if (classAttribute == null) {
        if (IsMutableField(fieldInfo)) typeDescriptor.IsInvalid = true;
        return;
      }
      if (fieldInfo.Name.StartsWith("<") || fieldInfo.Name.EndsWith("k__BackingField"))
        return;
      var attribute = (StorableAttribute)fieldInfo.GetCustomAttributes(typeof(StorableAttribute), false).SingleOrDefault();
      if (attribute != null)
        typeDescriptor.Fields.Add(new FieldDescriptor(typeDescriptor, fieldInfo, attribute));
    }

    private static void MaybeAddProperty(PropertyInfo propertyInfo, TypeDescriptor typeDescriptor, StorableClassAttribute classAttribute) {
      if (classAttribute == null) {
        if (IsMutableProperty(propertyInfo)) typeDescriptor.IsInvalid = true;
        return;
      }
      var attribute = (StorableAttribute)propertyInfo.GetCustomAttributes(typeof(StorableAttribute), false).SingleOrDefault();
      if (attribute != null) {
        if (!(attribute.AllowOneWay || propertyInfo.CanRead && propertyInfo.CanWrite))
          throw new PersistenceException("Properties have to be read/write or marked as one way storable");
        typeDescriptor.Properties.Add(new PropertyDescriptor(typeDescriptor, propertyInfo, attribute));
      }
    }

    private static void MaybeAddHook(MethodInfo methodInfo, TypeDescriptor typeDescriptor) {
      if (methodInfo.ReturnType != typeof(void) || methodInfo.GetParameters().Length > 0)
        return;
      var attribute = (StorableHookAttribute)methodInfo.GetCustomAttributes(typeof(StorableHookAttribute), false).SingleOrDefault();
      if (attribute != null)
        typeDescriptor.Hooks.Add(new HookDescriptor(typeDescriptor, methodInfo, attribute.HookType));
    }
  }
}