source: addons/HeuristicLab.DataImporter/HeuristicLab.DataImporter.Data/Model/DynamicValueList.cs @ 16994

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections;
using System.Linq;
using System.Linq.Expressions;

namespace HeuristicLab.DataImporter.Data.Model {
  internal class DynamicValueList : IList {

    private Func<int, int, double?> expression;
    private ColumnGroup columnGroup;
    private int count;
    private int recursiveIndex;

    public int RecursiveIndex {
      get { return recursiveIndex; }
      set { recursiveIndex = value; }
    }
    private object syncRoot = new object();

    public DynamicValueList(string expression, ColumnGroup columnGroup) {
      this.columnGroup = columnGroup;
      recursiveIndex = -1;
      this.expression = Parse(expression);
      count = columnGroup.RowCount;
    }

    public void IncreaseLength() {
      count++;
    }

    public void DecreaseLength() {
      count--;
    }

    #region IList Members

    public int IndexOf(object item) {
      if (!(item is double?)) return -1;
      double? d = (double?)item;
      for (int i = 0; i < Count; i++) {
        if (d == (double?)this[i]) return i;
      }
      // not found
      return -1;
    }

    public void Insert(int index, object item) {
      throw new NotSupportedException();
    }

    public void RemoveAt(int index) {
      throw new NotSupportedException();
    }

    public object this[int index] {
      get {
        return EvaluateExpression(index);
      }
      set {
        throw new NotSupportedException();
      }
    }

    int IList.Add(object value) {
      throw new NotSupportedException();
    }

    public bool IsFixedSize {
      get { return false; }
    }

    void IList.Remove(object value) {
      throw new NotSupportedException();
    }



    private Func<int, int, double?> Parse(string expression) {
      // make sure that every operator is separated from other tokens with a whitespace
      // to allow splitting into tokens by whitespace
      expression = expression.Replace("+", " + ");
      expression = expression.Replace("-", " - ");
      expression = expression.Replace("*", " * ");
      expression = expression.Replace("/", " / ");
      expression = expression.Replace("(", " ( ");
      expression = expression.Replace(")", " ) ");

      var tokens = expression.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
      LookAheadOneEnumerator enumerator = new LookAheadOneEnumerator(tokens);
      ParameterExpression parameter = Expression.Parameter(typeof(int), "index");
      ParameterExpression forbiddenColumnIndexParameter = Expression.Parameter(typeof(int), "forbiddenIndex");
      // move to first token
      if (tokens.Length == 0) {
        // empty expression => evaluate to missing value
        return Expression.Lambda<Func<int, int, double?>>(Expression.Constant(null, typeof(double?)), parameter, forbiddenColumnIndexParameter).Compile();
      } else {
        // "index" is a free parameter to access rows of columns by index
        // all Invoke expressions for column symbols must use the same index parameter (referentially equal)
        // so we have to create it at root level and push it down to the terminals
        return Expression.Lambda<Func<int, int, double?>>(ParseSimpleExpression(enumerator, parameter, forbiddenColumnIndexParameter), parameter, forbiddenColumnIndexParameter).Compile();
      }
    }

    private Expression ParseSimpleExpression(LookAheadOneEnumerator tokens, ParameterExpression indexParameter, ParameterExpression forbiddenColumnIndexParameter) {
      Expression term;
      string peek = tokens.Peek;
      if (peek == "-") {
        tokens.MoveNext(); // move to "-"  
        term = Expression.Negate(ParseTerm(tokens, indexParameter, forbiddenColumnIndexParameter));
      } else if (peek == "+") {
        tokens.MoveNext(); // move to "+" 
        term = ParseTerm(tokens, indexParameter, forbiddenColumnIndexParameter);
      } else {
        term = ParseTerm(tokens, indexParameter, forbiddenColumnIndexParameter);
      }
      while (tokens.HasNext &&
        (tokens.Peek == "+" || tokens.Peek == "-")) {
        tokens.MoveNext(); // move to operator
        if (tokens.Current == "+") {
          term = Expression.Add(term, ParseTerm(tokens, indexParameter, forbiddenColumnIndexParameter));
        } else if (tokens.Current == "-") {
          term = Expression.Subtract(term, ParseTerm(tokens, indexParameter, forbiddenColumnIndexParameter));
        }
      }
      if (tokens.HasNext && tokens.Peek != ")") throw new ParseException("Couldn't parse the full exception.");
      return term;
    }

    private Expression ParseTerm(LookAheadOneEnumerator tokens, ParameterExpression indexParameter, ParameterExpression forbiddenColumnIndexParameter) {
      Expression fact = ParseFact(tokens, indexParameter, forbiddenColumnIndexParameter);
      while (tokens.HasNext &&
        (tokens.Peek == "*" || tokens.Peek == "/")) {
        tokens.MoveNext(); // set to operator
        if (tokens.Current == "*") {
          fact = Expression.Multiply(fact, ParseFact(tokens, indexParameter, forbiddenColumnIndexParameter));
        } else if (tokens.Current == "/") {
          fact = Expression.Divide(fact, ParseFact(tokens, indexParameter, forbiddenColumnIndexParameter));
        }
      }
      return fact;
    }

    private Expression ParseFact(LookAheadOneEnumerator tokens, ParameterExpression indexParameter, ParameterExpression forbiddenColumnIndexParameter) {
      Expression fact;
      if (tokens.Peek == "(") {
        tokens.MoveNext(); // set to "("
        fact = ParseSimpleExpression(tokens, indexParameter, forbiddenColumnIndexParameter);
        // expect ")"
        if (!(tokens.HasNext && tokens.Peek == ")")) throw new ParseException(@""")"" expected instead of """ + tokens + @""".");
        tokens.MoveNext(); // set to ")"
        return fact;
      } else {
        double c;
        int columnIndex;
        tokens.MoveNext(); // set to terminal
        if (double.TryParse(tokens.Current, out c)) {
          return Expression.Constant(c, typeof(double?));
        } else if (TryTranslateColumnIndex(tokens.Current.ToUpper(), out columnIndex)) {
          Expression<Func<int, int, double?>> readValueExp =
            (index, forbiddenIndex) =>
              (columnIndex < columnGroup.Columns.Count() &&
               columnIndex != forbiddenIndex &&
               columnGroup.GetColumn(columnIndex).DataType == typeof(double?) &&
               index < columnGroup.GetColumn(columnIndex).TotalValuesCount) ?
              (double?)columnGroup.GetColumn(columnIndex).GetValue(index) : null;
          return Expression.Invoke(readValueExp, indexParameter, forbiddenColumnIndexParameter);
        } else {
          throw new ParseException("Unknown terminal: " + tokens.Current);
        }
      }
    }

    private bool TryTranslateColumnIndex(string symb, out int columnIndex) {
      if (symb.Length == 1) {       // 'A' .. 'Z'
        return TryTranslateColumnIndexDigit(symb[0], out columnIndex);
      } else if (symb.Length == 2) { // 'AA' ... 'ZZ'
        bool ok;
        int d0, d1;
        ok = TryTranslateColumnIndexDigit(symb[0], out d1) & TryTranslateColumnIndexDigit(symb[1], out d0);
        columnIndex = (d1 + 1) * 26 + d0;
        return ok;
      } else {
        columnIndex = 0;
        return false;
      }
    }

    private bool TryTranslateColumnIndexDigit(char d, out int columnIndex) {
      if (d < 'A' || d > 'Z') {
        columnIndex = 0;
        return false;
      } else {
        columnIndex = d - 'A';
        return true;
      }
    }

    private double? EvaluateExpression(int index) {
      return expression(index, recursiveIndex);
    }

    #endregion

    #region ICollection Members

    public void Add(object item) {
      throw new NotSupportedException();
    }

    public void Clear() {
      throw new NotSupportedException();
    }

    public bool Contains(object item) {
      return IndexOf(item) != -1;
    }

    public int Count {
      get { return count; }
    }

    public bool IsReadOnly {
      get { return true; }
    }

    public bool Remove(object item) {
      throw new NotSupportedException();
    }

    public void CopyTo(Array array, int index) {
      for (int i = index; i < array.Length && i < Count; i++) {
        array.SetValue(this[i], i);
      }
    }

    public bool IsSynchronized {
      get { return false; }
    }

    public object SyncRoot {
      get { return syncRoot; }
    }

    #endregion

    #region IEnumerable Members

    IEnumerator IEnumerable.GetEnumerator() {
      for (int i = 0; i < Count; i++)
        yield return this[i];
    }

    #endregion

    // private enumerator class with one lookahead symbol (Peek) needed to parse expressions
    private class LookAheadOneEnumerator {
      private string[] tokens;
      private int index;

      public LookAheadOneEnumerator(string[] tokens) {
        this.tokens = tokens;
        index = -1;
      }

      public void MoveNext() {
        if (HasNext) index++;
        else throw new InvalidOperationException("End of the token stream");
      }

      public bool HasNext {
        get { return index < tokens.Length - 1; }
      }
      public string Current {
        get {
          if (index < 0) throw new InvalidOperationException("Not initialized. Call MoveNext() first");
          else return tokens[index];
        }
      }
      public string Peek {
        get {
          if (HasNext) {
            return tokens[index + 1];
          } else
            return "";
        }
      }
    }
  }

  public class ParseException : Exception {
    public ParseException(string message) : base(message) { }
  }
}