source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/BenchmarkSuiteDataDescriptor.cs @ 14777

namespace HeuristicLab.BenchmarkSuite {
  using System.Collections.Generic;
  using System.IO;
  using System.IO.Compression;
  using System.Linq;
  using System.Reflection;
  using System.Text.RegularExpressions;

  using HeuristicLab.BenchmarkSuite.ERC;
  using HeuristicLab.BenchmarkSuite.Problems;

  using Microsoft.VisualBasic.FileIO;


  public abstract class BenchmarkSuiteDataDescriptor : IBenchmarkSuiteDataDescriptor {
    private const string InstanceArchiveName = "HeuristicLab.BenchmarkSuite.Data.BenchmarkExamples.zip";
    private const string ResourcePath = @".*\.Data\.";
    private const string ExampleSeparator = ",";

    private Example[] examples;
    public Example[] Examples
    {
      get
      {
        return this.examples ?? (this.examples = this.ParseData().ToArray());
      }
    }

    public Data CreateProblemData() {
      return new Data {
        Name = Name,
        Description = Description,
        Examples = Examples.ToArray(),
        BestResult = BestResult,
        WorstResult = WorstResult,
        InputArgumentTypes = InputArgumentTypes,
        OutputArgumentTypes = OutputArgumentTypes,
        OriginalTestCount = OriginalTestCount,
        OriginalTrainingCount = OriginalTrainingCount,
        EnabledDataTypes = EnabledDataTypes,
        EvalLimit = EvalLimit,
        MaxGenerations = MaxGenerations,
        MaxSize = MaxSize,
        ProgEvalBudget = ProgEvalBudget,
        ProblemErcOptions = ProblemErcOptions,
      };
    }

    public abstract string Name { get; }
    public abstract string Description { get; }
    protected abstract string FileName { get; }
    public abstract int OriginalTrainingCount { get; }
    public abstract int OriginalTestCount { get; }
    public abstract int BestResult { get; }
    public abstract int WorstResult { get; }
    public abstract ExampleArgumentType[] InputArgumentTypes { get; }
    public abstract ExampleArgumentType[] OutputArgumentTypes { get; }
    public abstract ProblemErcOptions ProblemErcOptions { get; }
    public abstract DataTypes EnabledDataTypes { get; }
    public abstract int MaxSize { get; }
    public abstract int EvalLimit { get; }
    public abstract int MaxGenerations { get; }
    public abstract int ProgEvalBudget { get; }

    public abstract Example ParseExample(string[] input, string[] output);

    private IEnumerable<Example> ParseData() {
      using (var file = this.GetType().Assembly.GetManifestResourceStream(InstanceArchiveName))
      using (var archive = new ZipArchive(file, ZipArchiveMode.Read)) {
        var entry = archive.Entries.SingleOrDefault(x => x.Name == FileName);

        using (var parser = new TextFieldParser(entry.Open())) {
          parser.TextFieldType = FieldType.Delimited;
          parser.SetDelimiters(ExampleSeparator);
          parser.TrimWhiteSpace = false;

          //Processing rows
          while (!parser.EndOfData) {
            var fields = parser.ReadFields();

            if (fields.Length != InputArgumentTypes.Length + OutputArgumentTypes.Length)
              throw new InvalidDataException("Number of values do not fit");

            var input = fields.Take(InputArgumentTypes.Length).ToArray();
            var output = fields.Skip(OutputArgumentTypes.Length).ToArray();

            yield return ParseExample(input, output);
          }
        }
      }
    }

    protected static string GetResourceName(string fileName) {
      return Assembly
          .GetExecutingAssembly()
          .GetManifestResourceNames()
          .SingleOrDefault(x => Regex.Match(x, ResourcePath + fileName).Success);
    }
  }
}