source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs @ 14834

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Expressions {
  using System;
  using System.Collections.Generic;
  using System.Linq;

  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;

  public static class ExpressionTable {
    public static readonly IDictionary<string, Expression> StatelessExpressionTable;
    public static readonly IDictionary<string, Func<Expression>> StatefulExpressionFactory;
    public static readonly IDictionary<StackTypes, IList<string>> StackTypeToNamesTable = new Dictionary<StackTypes, IList<string>>();
    public static readonly IDictionary<int, string> IndexToNameTable = new Dictionary<int, string>();
    public static readonly IDictionary<Type, string> TypeToNameTable = new Dictionary<Type, string>();
    public static readonly IDictionary<Type, PushExpressionAttribute> TypeToAttributeTable = new Dictionary<Type, PushExpressionAttribute>();
    public static readonly IDictionary<StackTypes, IList<string>> StackDependencyToNamesTable = new Dictionary<StackTypes, IList<string>>();
    public static readonly string[] ExpressionNames;

    public static readonly Type[] StatelessExpressionTypes;
    public static readonly Type[] StatefulExpressionTypes;

    public static readonly int Count;

    static ExpressionTable() {
      StatelessExpressionTypes = GetExpressionTypes(typeof(StatelessExpression)).ToArray();
      StatefulExpressionTypes = GetExpressionTypes(typeof(StatefulExpression<>)).ToArray();

      StatelessExpressionTable = GetStatelessExpressionTable();
      StatefulExpressionFactory = GetStatefulExpressionFactory();
      ExpressionNames = StatelessExpressionTable.Keys.Concat(StatefulExpressionFactory.Keys).ToArray();

      Count = StatelessExpressionTable.Count + StatefulExpressionFactory.Count;
    }

    public static int StatelessCount
    {
      get
      {
        return StatelessExpressionTable.Count;
      }
    }

    public static int StatefullCount
    {
      get
      {
        return StatefulExpressionFactory.Count;
      }
    }

    private static Dictionary<string, Expression> GetStatelessExpressionTable() {
      var dictionary = new Dictionary<string, Expression>();

      foreach (var type in StatelessExpressionTypes) {
        var expression = Activator.CreateInstance(type) as Expression;
        var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(type, typeof(PushExpressionAttribute));

        TypeToAttributeTable.Add(type, attribute);
        dictionary.Add(attribute.ExpressionName, expression);
        IndexToNameTable.Add(IndexToNameTable.Keys.Count, attribute.ExpressionName);
        TypeToNameTable.Add(type, attribute.ExpressionName);

        if (!StackTypeToNamesTable.ContainsKey(attribute.StackType)) {
          StackTypeToNamesTable.Add(attribute.StackType, new List<string>());
        }

        StackTypeToNamesTable[attribute.StackType].Add(attribute.ExpressionName);

        var dependencies = attribute.StackType | attribute.AdditionalStackDependencies;
        if (!StackDependencyToNamesTable.ContainsKey(dependencies)) {
          StackDependencyToNamesTable.Add(dependencies, new List<string>());
        }

        StackDependencyToNamesTable[dependencies].Add(attribute.ExpressionName);
      }

      return dictionary;
    }

    private static Dictionary<string, Func<Expression>> GetStatefulExpressionFactory() {
      var dictionary = new Dictionary<string, Func<Expression>>();

      foreach (var type in StatefulExpressionTypes) {
        // Make a NewExpression that calls the ctor
        var newExp = System.Linq.Expressions.Expression.New(type);

        // Create a lambda with the New expression as body
        var creator = System.Linq.Expressions.Expression.Lambda<Func<Expression>>(newExp).Compile();
        var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(type, typeof(PushExpressionAttribute));

        TypeToAttributeTable.Add(type, attribute);
        dictionary.Add(attribute.ExpressionName, creator);
        IndexToNameTable.Add(IndexToNameTable.Keys.Count, attribute.ExpressionName);
        TypeToNameTable.Add(type, attribute.ExpressionName);

        if (!StackTypeToNamesTable.ContainsKey(attribute.StackType)) {
          StackTypeToNamesTable.Add(attribute.StackType, new List<string>());
        }

        StackTypeToNamesTable[attribute.StackType].Add(attribute.ExpressionName);

        var dependencies = attribute.StackType | attribute.AdditionalStackDependencies;
        if (!StackDependencyToNamesTable.ContainsKey(dependencies)) {
          StackDependencyToNamesTable.Add(dependencies, new List<string>());
        }

        StackDependencyToNamesTable[dependencies].Add(attribute.ExpressionName);
      }

      return dictionary;
    }

    private static bool IsSubclassOf(Type type, Type baseType) {
      if (type == null || baseType == null || type == baseType)
        return false;

      if (baseType.IsGenericType == false) {
        if (type.IsGenericType == false)
          return type.IsSubclassOf(baseType);
      } else {
        baseType = baseType.GetGenericTypeDefinition();
      }

      type = type.BaseType;
      var objectType = typeof(object);
      while (type != objectType && type != null) {
        var curentType = type.IsGenericType ? type.GetGenericTypeDefinition() : type;
        if (curentType == baseType)
          return true;

        type = type.BaseType;
      }

      return false;
    }

    private static IEnumerable<Type> GetExpressionTypes(Type baseType) {
      return from domainAssembly in AppDomain.CurrentDomain.GetAssemblies()
             from assemblyType in domainAssembly.GetTypes()
             where !assemblyType.IsAbstract &&
                   IsSubclassOf(assemblyType, baseType) &&
                   assemblyType.GetConstructor(Type.EmptyTypes) != null
             select assemblyType;
    }

    public static IReadOnlyList<string> GetExpressionsByStackTypes(StackTypes allowedTypes) {
      return StackDependencyToNamesTable
          .Where(entry => (entry.Key & ~allowedTypes) == StackTypes.None)
          .SelectMany(entry => entry.Value)
          .ToArray();
    }

    public static PushProgram GetProgram(IManagedPool<PushProgram> pool, int[] index) {
      var expressions = new Expression[index.Length];

      for (var i = 0; i < index.Length; i++) {
        expressions[i] = GetExpression(index[i]);
      }

      return PushProgram.Create(pool, expressions);
    }

    public static Expression GetExpression(int index) {
      return GetExpression(IndexToNameTable[index]);
    }

    public static Expression GetExpression(string name) {
      Expression expression;

      if (!TryGetStatelessExpression(name, out expression) &&
          !TryGetStatefulExpression(name, out expression))
        throw new InvalidOperationException(string.Format("Expression with name {0} not found", name));

      return expression;
    }

    public static Expression GetStatelessExpression<T>() where T : StatelessExpression {
      return GetStatelessExpression(TypeToNameTable[typeof(T)]);
    }

    public static Expression GetStatelessExpression(string name) {
      if (StatelessExpressionTable.ContainsKey(name))
        return StatelessExpressionTable[name];
      throw new NotSupportedException("Expression not supported: " + name);
    }

    public static bool TryGetStatelessExpression(string name, out Expression expression) {
      if (!StatelessExpressionTable.ContainsKey(name)) {
        expression = null;
        return false;
      }

      expression = StatelessExpressionTable[name];

      return true;
    }

    public static Expression GetStatefulExpression<T>() {
      return GetStatefulExpression(TypeToNameTable[typeof(T)]);
    }

    public static Expression GetStatefulExpression(string name) {
      Func<Expression> creator;
      if (StatefulExpressionFactory.TryGetValue(name, out creator))
        return creator();
      throw new NotSupportedException("Expression not supported: " + name);
    }

    public static bool TryGetStatefulExpression(string name, out Expression expression) {
      if (StatefulExpressionFactory.ContainsKey(name)) {
        expression = StatefulExpressionFactory[name]();
        return true;
      }

      expression = default(Expression);
      return false;
    }
  }
}