source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs @ 15287

using System.Collections.Generic;
using System.Linq;

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter {
  using System;
  using System.Collections;
  using System.Reflection;

  using Attributes;

  using HeuristicLab.BenchmarkSuite;

  using Stack;

  public static class Extensions {
    private static readonly IDictionary<StackTypes, PropertyInfo> StackProperties = typeof(PushInterpreter)
        .GetProperties()
        .Select(p => new { Property = p, Attribute = p.GetCustomAttribute<PushStackAttribute>() })
        .Where(x => x.Attribute != null)
        .ToDictionary(x => x.Attribute.StackType, x => x.Property);

    public static IEnumerable<T> GetStackEntriesByType<T>(this IPushInterpreter interpreter, StackTypes stackType) {
      return StackProperties.ContainsKey(stackType)
        ? ((IEnumerable)StackProperties[stackType].GetValue(interpreter)).OfType<T>()
        : null;
    }

    public static Type GetStackEntryType(this StackTypes stackType) {
      if (StackProperties.ContainsKey(stackType) &&
          StackProperties[stackType].PropertyType.IsGenericType) {
        var genericTypeDef = StackProperties[stackType].PropertyType.GetGenericTypeDefinition();
        if (genericTypeDef == typeof(IPushStack<>))
          return genericTypeDef.GetGenericArguments()[0];
      }

      return StackProperties.ContainsKey(stackType)
        ? StackProperties[stackType]
            .PropertyType
            .GetInterfaces()
            .First(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPushStack<>))
            .GetGenericArguments()
            .First()
        : null;
    }

    public static void PrintStacks(this IPushInterpreter interpreter) {
      foreach (var pair in interpreter.Stacks) {
        var stackName = pair.Key.ToString();
        var stack = interpreter.Stacks[pair.Key];

        if (stack.IsEmpty || !stack.IsEnabled) continue;

        var stackString = string.Join(" ", interpreter.StringifyStack(pair.Key).Reverse());
        Console.WriteLine("--------- {0} ---------\n{1}\n", stackName, stackString);
      }

      if (interpreter.CustomExpressions.Count > 0) {
        Console.WriteLine("--------- Custom Expressions ---------");
        foreach (var ce in interpreter.CustomExpressions) {
          Console.WriteLine("{0}: {1}", ce.Key, ce.Value);
        }
      }
    }

    public static void InitExample(this IPushInterpreter interpreter, Example example) {
      interpreter.BooleanStack.Push(example.InputBoolean);
      interpreter.IntegerStack.Push(example.InputInteger);
      interpreter.FloatStack.Push(example.InputFloat);
      interpreter.CharStack.Push(example.InputChar);
      interpreter.StringStack.Push(example.InputString);
      interpreter.StringVectorStack.Push(example.InputStringVector);
      interpreter.IntegerVectorStack.Push(example.InputIntegerVector);
      interpreter.FloatVectorStack.Push(example.InputFloatVector);

      interpreter.SetInput(
        integers: example.InputInteger,
        floats: example.InputFloat,
        booleans: example.InputBoolean,
        chars: example.InputChar,
        strings: example.InputString,
        integerVectors: example.InputIntegerVector,
        floatVectors: example.InputFloatVector,
        stringVectors: example.InputStringVector);
    }
  }
}