source: branches/PersistenceReintegration/HeuristicLab.Persistence/4.0/Core/TypeInfo.cs @ 16210

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2015 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.Reflection.Emit;

namespace HeuristicLab.Persistence {
  public sealed class TypeInfo {
    private Func<object> constructor;

    public Type Type { get; private set; }
    public ITransformer Transformer { get; private set; }
    public StorableTypeAttribute StorableTypeAttribute { get; private set; }
    public IEnumerable<ComponentInfo> Fields { get; private set; }
    public IEnumerable<ComponentInfo> Properties { get; private set; }
    public IEnumerable<MethodInfo> BeforeSerializationHooks { get; private set; }
    public IEnumerable<MethodInfo> AfterDeserializationHooks { get; private set; }
    public long Used { get; set; }

    public TypeInfo(Type type) {
      constructor = null;
      Type = type;
      StorableTypeAttribute = StorableTypeAttribute.GetStorableTypeAttribute(type);
      Fields = Enumerable.Empty<ComponentInfo>();
      Properties = Enumerable.Empty<ComponentInfo>();
      BeforeSerializationHooks = Enumerable.Empty<MethodInfo>();
      AfterDeserializationHooks = Enumerable.Empty<MethodInfo>();
      Used = 0;
      Reflect();
    }
    public TypeInfo(Type type, ITransformer transformer)
      : this(type) {
      Transformer = transformer;
    }

    private void Reflect() {
      var type = Type;

      if (StorableTypeAttribute != null) {
        string guidPrefix = StorableTypeAttribute.Guid.ToString().ToUpper();
        // check constructors
        if (!type.IsValueType && !type.IsEnum && !type.IsInterface &&
          GetStorableConstructor() == null && GetDefaultConstructor() == null)
          throw new PersistenceException("No storable constructor or parameterless constructor found.");

        var fields = new List<ComponentInfo>();
        var properties = new List<ComponentInfo>();
        var beforeSerializationHooks = new List<MethodInfo>();
        var afterDeserializationHooks = new List<MethodInfo>();

        if (StorableTypeAttribute.MemberSelection != StorableMemberSelection.AllProperties) {
          // TODO: improved performance for static fields
          var fieldInfos = type.GetFields(BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic)
                               .Where(x => !x.Name.StartsWith("<") && !x.Name.EndsWith("k__BackingField")); // exclude backing fields

          if (StorableTypeAttribute.MemberSelection == StorableMemberSelection.MarkedOnly)
            fieldInfos = fieldInfos.Where(StorableAttribute.IsStorable).ToArray();

          foreach (var field in fieldInfos) {
            var name = field.Name;
            var attrib = StorableAttribute.GetStorableAttribute(field);

            if (attrib != null) {
              if (!string.IsNullOrEmpty(attrib.Name) && !string.IsNullOrEmpty(attrib.OldName))
                throw new PersistenceException("Cannot use Name and OldName at the same time.");

              if (!string.IsNullOrEmpty(attrib.Name)) name = attrib.Name;
              else if (!string.IsNullOrEmpty(attrib.OldName)) name = attrib.OldName;
            }

            var nameParts = name.Split('.').ToArray();
            var sourceType = type;
            var tmpGuid = Guid.Empty;

            for (int i = 0; i < nameParts.Length; i++) {
              var part = nameParts[i];
              if (part == "base") sourceType = sourceType.BaseType;
              else if (Guid.TryParse(part, out tmpGuid)) {
                if (i != 0 || nameParts.Length != 2) throw new PersistenceException("Invalid field path specified.");
                guidPrefix = tmpGuid.ToString().ToUpper();
                break;
              } else if (i != nameParts.Length - 1)
                throw new PersistenceException("Invalid field path specified.");
              else break;
            }

            if (sourceType != type) {
              name = nameParts[nameParts.Length - 1];
              guidPrefix = StorableTypeAttribute.GetStorableTypeAttribute(sourceType).Guid.ToString().ToUpper();
            } else if (tmpGuid != Guid.Empty) {
              name = nameParts[nameParts.Length - 1];
            }

            fields.Add(new ComponentInfo(name, guidPrefix + "." + name, field, attrib, true, true));
          }
        }

        if (StorableTypeAttribute.MemberSelection != StorableMemberSelection.AllFields) {
          // TODO: improved performance for static properties
          var propertyInfos = type.GetProperties(BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic)
                                  .Where(x => !x.GetIndexParameters().Any());  // exclude indexed properties

          if (StorableTypeAttribute.MemberSelection == StorableMemberSelection.MarkedOnly)
            propertyInfos = propertyInfos.Where(StorableAttribute.IsStorable).ToArray();

          foreach (var property in propertyInfos) {
            var name = property.Name;
            var attrib = StorableAttribute.GetStorableAttribute(property);

            if (attrib != null) {
              if (!string.IsNullOrEmpty(attrib.Name) && !string.IsNullOrEmpty(attrib.OldName))
                throw new PersistenceException("Cannot use Name and OldName at the same time.");

              if (attrib.AllowOneWay && !string.IsNullOrEmpty(attrib.OldName))
                throw new PersistenceException("Cannot use AllowOneWay and OldName at the same time.");

              if (!string.IsNullOrEmpty(attrib.Name)) name = attrib.Name;
              else if (!string.IsNullOrEmpty(attrib.OldName)) name = attrib.OldName;
            }

            if ((!property.CanRead || !property.CanWrite) && (attrib == null || !attrib.AllowOneWay && string.IsNullOrEmpty(attrib.OldName)))
              throw new PersistenceException("Properties must be readable and writable or have one way serialization explicitly enabled or use OldName.");

            var nameParts = name.Split('.').ToArray();
            var sourceType = type;
            var tmpGuid = Guid.Empty;

            for (int i = 0; i < nameParts.Length; i++) {
              var part = nameParts[i];
              if (part == "base") sourceType = sourceType.BaseType;
              else if (Guid.TryParse(part, out tmpGuid)) {
                if (i != 0 || nameParts.Length != 2) throw new PersistenceException("Invalid field path specified.");
                guidPrefix = tmpGuid.ToString().ToUpper();
                break;
              } else if (i != nameParts.Length - 1)
                throw new PersistenceException("Invalid field path specified.");
              else break;
            }

            if (sourceType != type) {
              name = nameParts[nameParts.Length - 1];
              guidPrefix = StorableTypeAttribute.GetStorableTypeAttribute(sourceType).Guid.ToString().ToUpper();
            } else if (tmpGuid != Guid.Empty) {
              name = nameParts[nameParts.Length - 1];
            }

            properties.Add(new ComponentInfo(name, guidPrefix + "." + name, property, attrib, property.CanRead, property.CanWrite));
          }
        }

        var methodInfos = type.GetMethods(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic)
                              .Where(StorableHookAttribute.IsStorableHook)
                              .Where(x => x.ReturnType == typeof(void) && !x.GetParameters().Any());

        foreach (var method in methodInfos) {
          foreach (var attrib in StorableHookAttribute.GetStorableHookAttributes(method)) {
            if (attrib.HookType == HookType.BeforeSerialization)
              beforeSerializationHooks.Add(method);
            if (attrib.HookType == HookType.AfterDeserialization)
              afterDeserializationHooks.Add(method);
          }
        }

        Fields = fields;
        Properties = properties;
        BeforeSerializationHooks = beforeSerializationHooks;
        AfterDeserializationHooks = afterDeserializationHooks;
      }
    }

    public Func<object> GetConstructor() {
      if (constructor != null) return constructor;

      // get storable constructor
      var ctor = GetStorableConstructor();
      if (ctor != null) {
        DynamicMethod dm = new DynamicMethod("", typeof(object), null, Type, true);
        ILGenerator ilgen = dm.GetILGenerator();
        var local = ilgen.DeclareLocal(typeof(StorableConstructorFlag));
        ilgen.Emit(OpCodes.Ldloca_S, local);
        ilgen.Emit(OpCodes.Initobj, typeof(StorableConstructorFlag)); // load default value for StorableConstructorFlag
        ilgen.Emit(OpCodes.Ldloc_0);
        ilgen.Emit(OpCodes.Newobj, ctor);
        ilgen.Emit(OpCodes.Ret);
        constructor = (Func<object>)dm.CreateDelegate(typeof(Func<object>));
        return constructor;
      }

      // get default constructor
      ctor = GetDefaultConstructor();
      if (ctor != null) {
        DynamicMethod dm = new DynamicMethod("", typeof(object), null, Type, true);
        ILGenerator ilgen = dm.GetILGenerator();
        ilgen.Emit(OpCodes.Newobj, ctor);
        ilgen.Emit(OpCodes.Ret);
        constructor = (Func<object>)dm.CreateDelegate(typeof(Func<object>));
        return constructor;
      }

      throw new PersistenceException("No storable constructor or parameterless constructor found.");
    }

    private ConstructorInfo GetStorableConstructor() {
      return (from ctor in Type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
              let parameters = ctor.GetParameters()
              where StorableConstructorAttribute.IsStorableConstructor(ctor)
                 && parameters.Length == 1
                 && parameters[0].ParameterType == typeof(StorableConstructorFlag)
              select ctor).FirstOrDefault();
    }

    private ConstructorInfo GetDefaultConstructor() {
      return Type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
    }
  }
}