source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Individual/InduvidualMapper.cs @ 15334

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Individual {
  using System;
  using Configuration;
  using Core;
  using Data.Pool;
  using Encodings.IntegerVectorEncoding;
  using Expressions;
  using Extensions;
  using Generators.CodeGenerator;

  public class ListCheck {
    public PooledList<Expression> List { get; set; }
    public IManagedPool<PooledList<Expression>> Pool { get; set; }
    public IndividualMapper Mapper { get; set; }
  }

  public class IndividualMapper : IDisposable {
    private static readonly ObjectPool<IndividualMapper> MapperPool = new ObjectPool<IndividualMapper>(() => new IndividualMapper());
    private static readonly ManagedPoolProvider<PushProgram> PushProgramPoolProvider = new ManagedPoolProvider<PushProgram>(1000, () => new PushProgram());
    private static readonly ManagedPoolProvider<PooledList<Expression>> ExpressionListPoolProvider = new ManagedPoolProvider<PooledList<Expression>>(1000, () => new PooledList<Expression>());

    private readonly IManagedPool<PushProgram> pushProgramPool = PushProgramPoolProvider.CreatePool();
    private readonly IManagedPool<PooledList<Expression>> expressionListPool = ExpressionListPoolProvider.CreatePool();

    private IndividualMapper() { }

    public PushProgram FromPlush(
      IntegerVector vector,
      ref int currentIndex,
      ref int close,
      int depth,
      IReadOnlyPushConfiguration config,
      IRandom random) {

      if (currentIndex >= vector.Length)
        return PushProgram.Empty;

      var expressions = expressionListPool.Get();

      for (; currentIndex < vector.Length; currentIndex++) {
        var expression = CodeGeneratorUtils.MapToExpression(
          vector[currentIndex] % config.EnabledExpressions.Count,
          random,
          config.ErcOptions,
          config);

        var expressionType = expression.GetType();

        if (config.CloseBiasLevel > 0) {
          close += random.NextBiased(0, config.MaxClose, config.CloseBiasLevel);

          // check if expression requires additional blocks
          if (ExpressionTable.TypeToAttributeTable.ContainsKey(expressionType)) {
            var attr = ExpressionTable.TypeToAttributeTable[expressionType];

            for (var blockIdx = 0u; blockIdx < attr.RequiredBlockCount && currentIndex < vector.Length; blockIdx++) {
              if (close != 0) {
                close--;
                expressions.Add(PushProgram.Empty);
              } else {
                currentIndex++;
                var subProgram = FromPlush(vector, ref currentIndex, ref close, depth + 1, config, random);
                var subExpression = subProgram.Count == 1 ? subProgram.Expressions[0] : subProgram;

                expressions.Add(subExpression);
              }
            }
          }
        }

        expressions.Add(expression);

        if (close > 0 && depth > 0) {
          close--;
          break;
        }

        if (depth == 0) {
          close = 0;
        }
      }

      return PushProgram.Create(pushProgramPool, expressions);
    }

    public static IndividualMapper Create() {
      return MapperPool.Allocate();
    }

    public static void Reset() {
      foreach (var mapper in MapperPool.Items) {
        mapper.expressionListPool.Release();
        mapper.pushProgramPool.Release();
      }
    }

    public static void Clear() {
      Reset();

      PushProgramPoolProvider.Clear();
      ExpressionListPoolProvider.Clear();

      MapperPool.Clear();
    }

    public void Dispose() {
      MapperPool.Free(this);
    }
  }
}