public void CompileSingleCellReferenceResolveToRangeAbsolute() { var parsingContext = ParsingContext.Create(); var file = new FileInfo("filename.xlsx"); using (var package = new ExcelPackage(file)) using (var sheet = package.Workbook.Worksheets.Add("NewSheet")) using (var excelDataProvider = new EpplusExcelDataProvider(package)) { var rangeAddressFactory = new RangeAddressFactory(excelDataProvider); using (parsingContext.Scopes.NewScope(rangeAddressFactory.Create("NewSheet", 3, 3))) { var expression = new ExcelAddressExpression("$A$1", excelDataProvider, parsingContext); expression.ResolveAsRange = true; var result = expression.Compile(); var rangeInfo = result.Result as ExcelDataProvider.IRangeInfo; Assert.IsNotNull(rangeInfo); Assert.AreEqual("$A$1", rangeInfo.Address.Address); } } }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 1); var r = arguments.ElementAt(0).ValueAsRangeInfo; if (r != null) { return(CreateResult(r.Address._toRow - r.Address._fromRow + 1, DataType.Integer)); } else { var range = ArgToAddress(arguments, 0, context); if (ExcelAddressUtil.IsValidAddress(range)) { var factory = new RangeAddressFactory(context.ExcelDataProvider); var address = factory.Create(range); return(CreateResult(address.ToRow - address.FromRow + 1, DataType.Integer)); } } throw new ArgumentException("Invalid range supplied"); }
public void CompileMultiCellReferenceAbsolute() { var parsingContext = ParsingContext.Create(); var file = new FileInfo("filename.xlsx"); using (var package = new ExcelPackage(file)) using (var sheet = package.Workbook.Worksheets.Add("NewSheet")) using (var excelDataProvider = new EpplusExcelDataProvider(package)) { var rangeAddressFactory = new RangeAddressFactory(excelDataProvider); using (parsingContext.Scopes.NewScope(rangeAddressFactory.Create("NewSheet", 3, 3))) { var expression = new ExcelAddressExpression("$A$1:$A$5", excelDataProvider, parsingContext); var result = expression.Compile(); var rangeInfo = result.Result as ExcelDataProvider.IRangeInfo; Assert.IsNotNull(rangeInfo); Assert.AreEqual("$A$1:$A$5", rangeInfo.Address.Address); // Enumerating the range still yields no results. Assert.AreEqual(0, rangeInfo.Count()); } } }
private CompileResult HandleSingleRange(IEnumerable <FunctionArgument> arguments, ParsingContext context) { var searchedValue = arguments.ElementAt(0).Value; Require.That(arguments.ElementAt(1).Value).Named("firstAddress").IsNotNull(); var firstAddress = ArgToString(arguments, 1); var rangeAddressFactory = new RangeAddressFactory(context.ExcelDataProvider); var address = rangeAddressFactory.Create(firstAddress); var nRows = address.ToRow - address.FromRow; var nCols = address.ToCol - address.FromCol; var lookupIndex = nCols + 1; var lookupDirection = LookupDirection.Vertical; if (nCols > nRows) { lookupIndex = nRows + 1; lookupDirection = LookupDirection.Horizontal; } var lookupArgs = new LookupArguments(searchedValue, firstAddress, lookupIndex, 0, true); var navigator = LookupNavigatorFactory.Create(lookupDirection, lookupArgs, context); return(Lookup(navigator, lookupArgs)); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { if (arguments == null || arguments.Count() == 0) { return(CreateResult(context.Scopes.Current.Address.FromRow, DataType.Integer)); } var r = arguments.ElementAt(0).ValueAsRangeInfo; if (r != null) { return(CreateResult(r.Address._fromRow, DataType.Integer)); } else { var rangeAddress = ArgToString(arguments, 0); if (ExcelAddressUtil.IsValidAddress(rangeAddress)) { var factory = new RangeAddressFactory(context.ExcelDataProvider); var address = factory.Create(rangeAddress); return(CreateResult(address.FromRow, DataType.Integer)); } } throw new ArgumentException("An invalid argument was supplied"); }
public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { ValidateArguments(arguments, 2); var searchedValue = arguments.ElementAt(0).Value; var address = ArgToAddress(arguments, 1, context); var rangeAddressFactory = new RangeAddressFactory(context.ExcelDataProvider); var rangeAddress = rangeAddressFactory.Create(address); var matchType = GetMatchType(arguments); var args = new LookupArguments(searchedValue, address, 0, 0, false, arguments.ElementAt(1).ValueAsRangeInfo); var lookupDirection = GetLookupDirection(rangeAddress); var navigator = LookupNavigatorFactory.Create(lookupDirection, args, context); int?lastValidIndex = null; do { var matchResult = IsMatch(searchedValue, navigator.CurrentValue); // For all match types, if the match result indicated equality, return the index (1 based) if (matchResult == 0) { return(CreateResult(navigator.Index + 1, DataType.Integer)); } if ((matchType == MatchType.ClosestBelow && matchResult < 0) || (matchType == MatchType.ClosestAbove && matchResult > 0)) { lastValidIndex = navigator.Index + 1; } // If matchType is ClosestBelow or ClosestAbove and the match result test failed, no more searching is required else if (matchType == MatchType.ClosestBelow || matchType == MatchType.ClosestAbove) { break; } }while (navigator.MoveNext()); return(CreateResult(lastValidIndex, DataType.Integer)); }
/// <summary> /// Executes the function with the specified <paramref name="arguments"/> in the specified <paramref name="context"/>. /// </summary> /// <param name="arguments">The arguments with which to evaluate the function.</param> /// <param name="context">The context in which to evaluate the function.</param> /// <returns>The <see cref="CompileResult"/>.</returns> public override CompileResult Execute(IEnumerable <FunctionArgument> arguments, ParsingContext context) { if (this.ArgumentsAreValid(arguments, 1, out eErrorType argumentError) == false) { return(new CompileResult(argumentError)); } var r = arguments.ElementAt(0).ValueAsRangeInfo; if (r != null) { return(CreateResult(r.Address._toCol - r.Address._fromCol + 1, DataType.Integer)); } else { var range = ArgToString(arguments, 0); if (ExcelAddressUtil.IsValidAddress(range)) { var factory = new RangeAddressFactory(context.ExcelDataProvider); var address = factory.Create(range); return(CreateResult(address.ToCol - address.FromCol + 1, DataType.Integer)); } } throw new ArgumentException("Invalid range supplied"); }
public void Setup() { var provider = MockRepository.GenerateStub <ExcelDataProvider>(); _factory = new RangeAddressFactory(provider); }
public ExcelAddressExpression(string expression, ExcelDataProvider excelDataProvider, ParsingContext parsingContext, RangeAddressFactory rangeAddressFactory, bool negate) : base(expression) { Require.That(excelDataProvider).Named("excelDataProvider").IsNotNull(); Require.That(parsingContext).Named("parsingContext").IsNotNull(); Require.That(rangeAddressFactory).Named("rangeAddressFactory").IsNotNull(); _excelDataProvider = excelDataProvider; _parsingContext = parsingContext; _rangeAddressFactory = rangeAddressFactory; _negate = negate; }
public EpplusExcelDataProvider(ExcelPackage package) { _package = package; _rangeAddressFactory = new RangeAddressFactory(this); }
public void Setup() { var provider = A.Fake <ExcelDataProvider>(); _factory = new RangeAddressFactory(provider); }