protected void BuildFunctionArguments(CompileResult compileResult, DataType dataType, List <FunctionArgument> args) { if (compileResult.Result is IEnumerable <object> && !(compileResult.Result is ExcelDataProvider.IRangeInfo)) { var compileResultFactory = new CompileResultFactory(); var argList = new List <FunctionArgument>(); var objects = compileResult.Result as IEnumerable <object>; foreach (var arg in objects) { var cr = compileResultFactory.Create(arg); BuildFunctionArguments(cr, dataType, argList); } args.Add(new FunctionArgument(argList)); } else { var funcArg = new FunctionArgument(compileResult.Result, dataType); funcArg.ExcelAddressReferenceId = compileResult.ExcelAddressReferenceId; if (compileResult.IsHiddenCell) { funcArg.SetExcelStateFlag(Excel.ExcelCellState.HiddenCell); } args.Add(funcArg); } }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 2); var items = new List <object>(); for (int x = 0; x < arguments.Count(); x++) { items.Add(arguments.ElementAt(x).ValueFirst); } var chooseIndices = arguments.ElementAt(0).ValueFirst as IEnumerable <FunctionArgument>; if (chooseIndices != null && chooseIndices.Count() > 1) { IntArgumentParser intParser = new IntArgumentParser(); object[] values = chooseIndices.Select(chosenIndex => items[(int)intParser.Parse(chosenIndex.ValueFirst)]).ToArray(); return(CreateResult(values, DataType.Enumerable)); } else { var index = ArgToInt(arguments, 0); var choosedValue = arguments.ElementAt(index).Value; if (choosedValue is IRangeInfo) { return(CreateResult(choosedValue, DataType.Enumerable)); } var factory = new CompileResultFactory(); return(factory.Create(choosedValue)); } }
public void CreateIntResult() { int value = 1437; CompileResult compileResult = new CompileResultFactory().Create(value); Assert.AreEqual(value, compileResult.Result); Assert.AreEqual(DataType.Integer, compileResult.DataType); }
public void CreateDecimalResult() { decimal value = 1437.756m; CompileResult compileResult = new CompileResultFactory().Create(value); Assert.AreEqual(value, compileResult.Result); Assert.AreEqual(DataType.Decimal, compileResult.DataType); }
public void CreateResultByteConvertsToInt() { byte value = 7; CompileResult compileResult = new CompileResultFactory().Create(value); Assert.AreEqual(value, compileResult.Result); Assert.AreEqual(DataType.Integer, compileResult.DataType); }
public void CreateStringResult() { string value = "SomeStringTextHere"; CompileResult compileResult = new CompileResultFactory().Create(value); Assert.AreEqual(value, compileResult.Result); Assert.AreEqual(DataType.String, compileResult.DataType); }
public void CreateNameErrorStringResult() { string value = "#NAME?"; CompileResult compileResult = new CompileResultFactory().Create(value); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Name), compileResult.Result); Assert.AreEqual(DataType.ExcelError, compileResult.DataType); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 3); var condition = ArgToBool(arguments, 0); var firstStatement = arguments.ElementAt(1).Value; var secondStatement = arguments.ElementAt(2).Value; var factory = new CompileResultFactory(); return(condition ? factory.Create(firstStatement) : factory.Create(secondStatement)); }
public void CreateListEnumerableResult() { List <string> listEnumerableObj = new List <string> { "asasd", "wrtdgff", "sdfsfds" }; CompileResult compileResult = new CompileResultFactory().Create(listEnumerableObj); Assert.AreEqual(listEnumerableObj, compileResult.Result); Assert.AreEqual(DataType.Enumerable, compileResult.DataType); }
/// <summary> /// Compiles the expression. /// </summary> /// <returns>A <see cref="CompileResult"/> result of the expression compilation.</returns> public override CompileResult Compile() { var c = this._parsingContext.Scopes.Current; var name = _parsingContext.ExcelDataProvider.GetName(c.Address.Worksheet, ExpressionString); if (name == null) { return(new CompileResult(eErrorType.Name)); } if (name.Value == null) { return(null); } if (name.Value is ExcelDataProvider.IRangeInfo range) { if (range.IsMulti) { return(new CompileResult(range, DataType.Enumerable)); } else { if (range.IsEmpty && range.Address._fromRowFixed == true && range.Address._fromColFixed == true) { return(null); } var address = range.Address; var column = address.Start.Column; var row = address.Start.Row; if (address._fromColFixed == false) { column = (column - 1 + c.Address.FromCol) % ExcelPackage.MaxColumns; if (column == 0) { column = ExcelPackage.MaxColumns; } } if (address._fromRowFixed == false) { row = (row - 1 + c.Address.FromRow) % ExcelPackage.MaxRows; if (row == 0) { row = ExcelPackage.MaxRows; } } var factory = new CompileResultFactory(); return(factory.Create(range.Worksheet.Cells[row, column].Value)); } } else { var factory = new CompileResultFactory(); return(factory.Create(name.Value)); } }
public void CreateErrorType() { var factory = new CompileResultFactory(); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Value), factory.Create("#VALUE!").Result); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Name), factory.Create("#NAME?").Result); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Div0), factory.Create("#DIV/0!").Result); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.NA), factory.Create("#N/A").Result); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Null), factory.Create("#NULL!").Result); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Num), factory.Create("#NUM!").Result); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Ref), factory.Create("#REF!").Result); }
private bool EvaluateOperator(object left, object right, IOperator op) { var compileResultFactory = new CompileResultFactory(); var leftResult = compileResultFactory.Create(left); var rightResult = compileResultFactory.Create(right); var result = op.Apply(leftResult, rightResult); if (result.DataType != DataType.Boolean) { throw new ArgumentException("Illegal operator in expression"); } return((bool)result.Result); }
/// <summary> /// Evaluates the specifed <paramref name="arguments"/> as follows: /// - [0]: the condition to evaluate; /// - [1]: the value to evaluate if true; /// - [2]: the value to evaluate if false. /// </summary> /// <param name="arguments">The arguments to evaluate.</param> /// <param name="context">The context within which to evaluate the function.</param> /// <returns>The result of either the second or third argument if the condition evaluates to true or false, respectively.</returns> public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { if (this.ArgumentsAreValid(arguments, 3, out eErrorType argumentError) == false) { return(new CompileResult(argumentError)); } var condition = ArgToBool(arguments.ElementAt(0)); var firstStatement = arguments.ElementAt(1).Value; var secondStatement = arguments.ElementAt(2).Value; var factory = new CompileResultFactory(); return(condition ? factory.Create(firstStatement) : factory.Create(secondStatement)); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 2); var crf = new CompileResultFactory(); var maxArgs = arguments.Count() < (127 * 2) ? arguments.Count() : 127 * 2; for (var x = 0; x < maxArgs; x += 2) { if (System.Math.Round(ArgToDecimal(arguments, x), 15) != 0d) { return(crf.Create(arguments.ElementAt(x + 1).Value)); } } return(CreateResult(ExcelErrorValue.Create(eErrorType.NA), DataType.ExcelError)); }
public void CalculateUsingEuropeanDates() { var us = new CultureInfo("en-US"); Thread.CurrentThread.CurrentCulture = us; var crf = new CompileResultFactory(); var result = crf.Create("1/15/2014"); var numeric = result.ResultNumeric; Assert.AreEqual(41654, numeric); var gb = new CultureInfo("en-GB"); Thread.CurrentThread.CurrentCulture = gb; var euroResult = crf.Create("15/1/2014"); var eNumeric = euroResult.ResultNumeric; Assert.AreEqual(41654, eNumeric); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 2); var arg1 = arguments.ElementAt(0); var args = arg1.Value as IEnumerable <FunctionArgument>; var crf = new CompileResultFactory(); if (args != null) { var index = ArgToInt(arguments, 1); if (index > args.Count()) { throw new ExcelErrorValueException(eErrorType.Ref); } var candidate = args.ElementAt(index - 1); //Commented JK-Can be any data type //if (!IsNumber(candidate.Value)) //{ // throw new ExcelErrorValueException(eErrorType.Value); //} //return CreateResult(ConvertUtil.GetValueDouble(candidate.Value), DataType.Decimal); return(crf.Create(candidate.Value)); } if (arg1.IsExcelRange) { var row = ArgToInt(arguments, 1); var col = arguments.Count() > 2 ? ArgToInt(arguments, 2) : 1; var ri = arg1.ValueAsRangeInfo; if (row > ri.Address._toRow - ri.Address._fromRow + 1 || col > ri.Address._toCol - ri.Address._fromCol + 1) { ThrowExcelErrorValueException(eErrorType.Ref); } var candidate = ri.GetOffset(row - 1, col - 1); //Commented JK-Can be any data type //if (!IsNumber(candidate.Value)) //{ // throw new ExcelErrorValueException(eErrorType.Value); //} return(crf.Create(candidate)); } throw new NotImplementedException(); }
public ExpressionEvaluator(WildCardValueMatcher wildCardValueMatcher, CompileResultFactory compileResultFactory) { _wildCardValueMatcher = wildCardValueMatcher; _compileResultFactory = compileResultFactory; }
public Switch(CompileResultFactory compileResultFactory) { _compileResultFactory = compileResultFactory; }
public Choose() { _compileResultFactory = new CompileResultFactory(); }
public NumericExpressionEvaluator(ValueMatcher valueMatcher, CompileResultFactory compileResultFactory) { _valueMatcher = valueMatcher; _compileResultFactory = compileResultFactory; }
public LookupFunction(ValueMatcher valueMatcher, CompileResultFactory compileResultFactory) { _valueMatcher = valueMatcher; _compileResultFactory = compileResultFactory; }
/// <summary> /// Takes the data and the associated row/column value and returns the value from the cell range /// at the given row or column value. /// </summary> /// <param name="arguments">The cell range, the row value, and the column value.</param> /// <param name="context">The context in which the function is called.</param> /// <returns>A <see cref="CompileResult"/> result.</returns> public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { if (this.ArgumentsAreValid(arguments, 2, out eErrorType argumentError) == false) { return(new CompileResult(argumentError)); } var cellRange = arguments.ElementAt(0); var rowDataCandidate = arguments.ElementAt(1); var result = new CompileResultFactory(); if (cellRange.Value is IEnumerable <FunctionArgument> args) { var index = this.ArgToInt(arguments, 1); if (index > args.Count()) { throw new ExcelErrorValueException(eErrorType.Ref); } var candidate = args.ElementAt(index - 1); return(base.CreateResult(candidate.Value, DataType.Integer)); } if (rowDataCandidate != null && rowDataCandidate.Value is ExcelErrorValue && rowDataCandidate.Value.ToString() == ExcelErrorValue.Values.NA) { return(base.CreateResult(rowDataCandidate.Value, DataType.Integer)); } // A single cell array ignores the row number and column number arguments, returning the single value in the array. if (!cellRange.IsExcelRange) { return(new CompileResult(cellRange.Value, cellRange.DataType)); } else { var rowCandidate = arguments.ElementAt(1).DataType; if (rowCandidate == DataType.Date) { return(new CompileResult(eErrorType.Ref)); } else if (rowCandidate == DataType.Decimal) { return(new CompileResult(eErrorType.Ref)); } var row = this.ArgToInt(arguments, 1); if (row == 0) { return(new CompileResult(eErrorType.Value)); } if (row < 0) { return(new CompileResult(eErrorType.Value)); } var column = 1; if (arguments.Count() > 2) { var colCandidate = arguments.ElementAt(2).DataType; if (colCandidate == DataType.Date) { return(new CompileResult(eErrorType.Ref)); } else if (colCandidate == DataType.Decimal) { return(new CompileResult(eErrorType.Ref)); } else { column = this.ArgToInt(arguments, 2); } } else if ((arguments.ElementAt(0).ValueAsRangeInfo.Address.Columns > 1) && arguments.ElementAt(0).ValueAsRangeInfo.Address.Rows > 1) { return(new CompileResult(eErrorType.Ref)); } if ((column == 0 && row == 0) || column < 0) { return(new CompileResult(eErrorType.Value)); } var rangeInfo = cellRange.ValueAsRangeInfo; if (rangeInfo.Address.Rows == 1 && arguments.Count() < 3) { column = row; row = 1; } var numColumns = arguments.ElementAt(0).ValueAsRangeInfo.Address.Columns; if ((numColumns > 1 && column == 0)) { return(new CompileResult(eErrorType.Value)); } if (row > rangeInfo.Address.Rows || column > rangeInfo.Address.Columns) { return(new CompileResult(eErrorType.Ref)); } if (row > rangeInfo.Address._toRow - rangeInfo.Address._fromRow + 1 || column > rangeInfo.Address._toCol - rangeInfo.Address._fromCol + 1) { return(new CompileResult(eErrorType.Value)); } var candidate = rangeInfo.GetOffset(row - 1, column - 1); if (column == 0) { candidate = rangeInfo.GetOffset(row - 1, column); } return(base.CreateResult(candidate, DataType.Integer)); } }