source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problem.ProgramSynthesis.BenchmarkSuite/Example.cs @ 15428

namespace HeuristicLab.BenchmarkSuite {
  using System;

  using HeuristicLab.Common;
  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

  [StorableClass]
  public class Example : DeepCloneable {
    private static readonly long[] emptyIntegers = new long[0];
    private static readonly double[] emptyFloats = new double[0];
    private static readonly bool[] emptyBooleans = new bool[0];
    private static readonly char[] emptyChars = new char[0];
    private static readonly string[] emptyStrings = new string[0];
    private static readonly long[][] emptyIntegerVectors = new long[0][];
    private static readonly double[][] emptyFloatVectors = new double[0][];
    private static readonly bool[][] emptyBooleanVectors = new bool[0][];
    private static readonly string[][] emptyStringVectors = new string[0][];

    public Example() {
      InputArgs = emptyStrings;
      OutputArgs = emptyStrings;

      InputInteger = emptyIntegers;
      InputFloat = emptyFloats;
      InputBoolean = emptyBooleans;
      InputChar = emptyChars;
      InputString = emptyStrings;
      InputIntegerVector = emptyIntegerVectors;
      InputFloatVector = emptyFloatVectors;
      InputBooleanVector = emptyBooleanVectors;
      InputStringVector = emptyStringVectors;

      OutputInteger = emptyIntegers;
      OutputFloat = emptyFloats;
      OutputBoolean = emptyBooleans;
      OutputChar = emptyChars;
      OutputString = emptyStrings;
      OutputIntegerVector = emptyIntegerVectors;
      OutputFloatVector = emptyFloatVectors;
      OutputBooleanVector = emptyBooleanVectors;
      OutputStringVector = emptyStringVectors;
      OutputPrint = string.Empty;
      OutputFloatPrecision = 15;
      OutputFloatVectorPrecision = 15;
    }

    public Example(Example origin, Cloner cloner) : base(origin, cloner) {
      InputArgs = (string[])origin.InputArgs.Clone();
      OutputArgs = (string[])origin.OutputArgs.Clone();

      InputBoolean = (bool[])origin.InputBoolean.Clone();
      InputInteger = (long[])origin.InputInteger.Clone();
      InputFloat = (double[])origin.InputFloat.Clone();
      InputChar = (char[])origin.InputChar.Clone();
      InputString = (string[])origin.InputString.Clone();
      InputIntegerVector = (long[][])origin.InputIntegerVector.Clone();
      InputFloatVector = (double[][])origin.InputFloatVector.Clone();
      InputBooleanVector = (bool[][])origin.InputBooleanVector.Clone();
      InputStringVector = (string[][])origin.InputStringVector.Clone();

      OutputBoolean = (bool[])origin.OutputBoolean.Clone();
      OutputInteger = (long[])origin.OutputInteger.Clone();
      OutputFloat = (double[])origin.OutputFloat.Clone();
      OutputChar = (char[])origin.OutputChar.Clone();
      OutputString = (string[])origin.OutputString.Clone();
      OutputIntegerVector = (long[][])origin.OutputIntegerVector.Clone();
      OutputFloatVector = (double[][])origin.OutputFloatVector.Clone();
      OutputBooleanVector = (bool[][])origin.OutputBooleanVector.Clone();
      OutputStringVector = (string[][])origin.OutputStringVector.Clone();
      OutputPrint = origin.OutputPrint;
      OutputPrintLineCount = origin.OutputPrintLineCount;
      OutputFloatPrecision = origin.OutputFloatPrecision;
      OutputFloatVectorPrecision = origin.OutputFloatVectorPrecision;
    }

    [StorableConstructor]
    public Example(bool deserializing) { }

    [Storable]
    public string[] InputArgs { get; set; }
    [Storable]
    public string[] OutputArgs { get; set; }

    [Storable]
    public long[] InputInteger { get; set; }
    [Storable]
    public double[] InputFloat { get; set; }
    [Storable]
    public bool[] InputBoolean { get; set; }
    [Storable]
    public char[] InputChar { get; set; }
    [Storable]
    public string[] InputString { get; set; }
    [Storable]
    public long[][] InputIntegerVector { get; set; }
    [Storable]
    public double[][] InputFloatVector { get; set; }
    [Storable]
    public bool[][] InputBooleanVector { get; set; }
    [Storable]
    public string[][] InputStringVector { get; set; }

    [Storable]
    public long[] OutputInteger { get; set; }
    [Storable]
    public double[] OutputFloat { get; set; }
    [Storable]
    public bool[] OutputBoolean { get; set; }
    [Storable]
    public char[] OutputChar { get; set; }
    [Storable]
    public string[] OutputString { get; set; }
    [Storable]
    public long[][] OutputIntegerVector { get; set; }
    [Storable]
    public double[][] OutputFloatVector { get; set; }
    [Storable]
    public bool[][] OutputBooleanVector { get; set; }
    [Storable]
    public string[][] OutputStringVector { get; set; }
    [Storable]
    private string outputPrint;
    private static readonly string[] NewLineSeparator = { "\r\n", "\n" };
    public string OutputPrint
    {
      get { return outputPrint; }
      set
      {
        outputPrint = value;
        OutputPrintLineCount = value != null ? value.Split(NewLineSeparator, StringSplitOptions.None).Length : 0;
      }
    }

    [Storable]
    public int OutputPrintLineCount { get; private set; }

    [Storable]
    public int OutputFloatPrecision { get; set; }
    [Storable]
    public int OutputFloatVectorPrecision { get; set; }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new Example(this, cloner);
    }
  }
}