private CollaboratingWorkbooksEnvironment(String[] workbookNames, WorkbookEvaluator[] evaluators, int nItems) { Hashtable m = new Hashtable(nItems * 3 / 2); Hashtable uniqueEvals = new Hashtable(nItems * 3 / 2); for (int i = 0; i < nItems; i++) { String wbName = workbookNames[i]; WorkbookEvaluator wbEval = evaluators[i]; if (m.ContainsKey(wbName)) { throw new ArgumentException("Duplicate workbook name '" + wbName + "'"); } if (uniqueEvals.ContainsKey(wbEval)) { String msg = "Attempted To register same workbook under names '" + uniqueEvals[(wbEval) + "' and '" + wbName + "'"]; throw new ArgumentException(msg); } uniqueEvals[wbEval]=wbName; m[wbName] = wbEval; } UnhookOldEnvironments(evaluators); //HookNewEnvironment(evaluators, this); - moved to Setup method above _unhooked = false; _evaluators = evaluators; _evaluatorsByName = m; }
public OperationEvaluationContext(WorkbookEvaluator bookEvaluator, IEvaluationWorkbook workbook, int sheetIndex, int srcRowNum, int srcColNum, EvaluationTracker tracker) { _bookEvaluator = bookEvaluator; _workbook = workbook; _sheetIndex = sheetIndex; _rowIndex = srcRowNum; _columnIndex = srcColNum; _tracker = tracker; }
public SheetRefEvaluator(WorkbookEvaluator bookEvaluator, EvaluationTracker tracker, int sheetIndex) { if (sheetIndex < 0) { throw new ArgumentException("Invalid sheetIndex: " + sheetIndex + "."); } _bookEvaluator = bookEvaluator; _tracker = tracker; _sheetIndex = sheetIndex; }
public static void Setup(String[] workbookNames, WorkbookEvaluator[] evaluators) { int nItems = workbookNames.Length; if (evaluators.Length != nItems) { throw new ArgumentException("Number of workbook names is " + nItems + " but number of evaluators is " + evaluators.Length); } if (nItems < 1) { throw new ArgumentException("Must provide at least one collaborating worbook"); } CollaboratingWorkbooksEnvironment env = new CollaboratingWorkbooksEnvironment(workbookNames, evaluators, nItems); HookNewEnvironment(evaluators, env); }
private static ValueEval EvaluateInternal(ValueEval arg, ValueEval iferror, int srcCellRow, int srcCellCol) { arg = WorkbookEvaluator.DereferenceResult(arg, srcCellRow, srcCellCol); if (arg is ErrorEval) { //if the 2nd argument is missing, use an empty string as default if (iferror is MissingArgEval) { return(new StringEval(string.Empty)); } else { return(iferror); } } else { return(arg); } }
private OperationEvaluationContext CreateContext() { HSSFWorkbook wb = new HSSFWorkbook(); ISheet sheet = wb.CreateSheet(); IRow row = sheet.CreateRow(0); ICell cell = row.CreateCell(0); cell.SetCellValue("123.43"); cell = row.CreateCell(1); cell.SetCellValue("8"); cell = row.CreateCell(2); cell.SetCellValue("-8"); HSSFEvaluationWorkbook workbook = HSSFEvaluationWorkbook.Create(wb); WorkbookEvaluator workbookEvaluator = new WorkbookEvaluator(workbook, new IStabilityClassifier1(), null); OperationEvaluationContext ctx = new OperationEvaluationContext(workbookEvaluator, workbook, 0, 0, 0, null); return(ctx); }
private void UnhookOldEnvironments(WorkbookEvaluator[] evaluators) { ArrayList oldEnvs = new ArrayList(); for (int i = 0; i < evaluators.Length; i++) { oldEnvs.Add(evaluators[i].GetEnvironment()); } CollaboratingWorkbooksEnvironment[] oldCWEs = new CollaboratingWorkbooksEnvironment[oldEnvs.Count]; oldCWEs = (CollaboratingWorkbooksEnvironment[])oldEnvs.ToArray(typeof(CollaboratingWorkbooksEnvironment)); for (int i = 0; i < oldCWEs.Length; i++) { oldCWEs[i].Unhook(); } }
public void NotifyUpdateCell(int bookIndex, int sheetIndex, IEvaluationCell cell) { FormulaCellCacheEntry fcce = _formulaCellCache.Get(cell); int rowIndex = cell.RowIndex; int columnIndex = cell.ColumnIndex; Loc loc = new Loc(bookIndex, sheetIndex, cell.RowIndex, cell.ColumnIndex); PlainValueCellCacheEntry pcce = _plainCellCache.Get(loc); if (cell.CellType == Frame.Utils.NPOI.SS.UserModel.CellType.FORMULA) { if (fcce == null) { fcce = new FormulaCellCacheEntry(); if (pcce == null) { if (_evaluationListener != null) { _evaluationListener.OnChangeFromBlankValue(sheetIndex, rowIndex, columnIndex, cell, fcce); } UpdateAnyBlankReferencingFormulas(bookIndex, sheetIndex, rowIndex, columnIndex); } _formulaCellCache.Put(cell, fcce); } else { fcce.RecurseClearCachedFormulaResults(_evaluationListener); fcce.ClearFormulaEntry(); } if (pcce == null) { // was formula cell before - no Change of type } else { // changing from plain cell To formula cell pcce.RecurseClearCachedFormulaResults(_evaluationListener); _plainCellCache.Remove(loc); } } else { ValueEval value = WorkbookEvaluator.GetValueFromNonFormulaCell(cell); if (pcce == null) { if (value != BlankEval.instance) { pcce = new PlainValueCellCacheEntry(value); if (fcce == null) { if (_evaluationListener != null) { _evaluationListener.OnChangeFromBlankValue(sheetIndex, rowIndex, columnIndex, cell, pcce); } UpdateAnyBlankReferencingFormulas(bookIndex, sheetIndex, rowIndex, columnIndex); } _plainCellCache.Put(loc, pcce); } } else { if (pcce.UpdateValue(value)) { pcce.RecurseClearCachedFormulaResults(_evaluationListener); } if (value == BlankEval.instance) { _plainCellCache.Remove(loc); } } if (fcce == null) { // was plain cell before - no Change of type } else { // was formula cell before - now a plain value _formulaCellCache.Remove(cell); fcce.SetSensitiveInputCells(null); fcce.RecurseClearCachedFormulaResults(_evaluationListener); } } }
private ForkedEvaluator(IEvaluationWorkbook masterWorkbook, IStabilityClassifier stabilityClassifier, UDFFinder udfFinder) { _sewb = new ForkedEvaluationWorkbook(masterWorkbook); _evaluator = new WorkbookEvaluator(_sewb, stabilityClassifier, udfFinder); }
private XSSFFormulaEvaluator(XSSFWorkbook workbook, IStabilityClassifier stabilityClassifier, UDFFinder udfFinder) { _bookEvaluator = new WorkbookEvaluator(XSSFEvaluationWorkbook.Create(workbook), stabilityClassifier, udfFinder); _book = workbook; }
/** * @param stabilityClassifier used to optimise caching performance. Pass <code>null</code> * for the (conservative) assumption that any cell may have its defInition Changed After * Evaluation begins. * @deprecated (Sep 2009) (reduce overloading) use {@link #Create(XSSFWorkbook, NPOI.ss.formula.IStabilityClassifier, NPOI.ss.formula.udf.UDFFinder)} */ public XSSFFormulaEvaluator(XSSFWorkbook workbook, IStabilityClassifier stabilityClassifier) { _bookEvaluator = new WorkbookEvaluator(XSSFEvaluationWorkbook.Create(workbook), stabilityClassifier, null); _book = workbook; }
private static void HookNewEnvironment(WorkbookEvaluator[] evaluators, CollaboratingWorkbooksEnvironment env) { // All evaluators will need To share the same cache. // but the cache takes an optional evaluation listener. int nItems = evaluators.Length; IEvaluationListener evalListener = evaluators[0].GetEvaluationListener(); // make sure that all evaluators have the same listener for (int i = 0; i < nItems; i++) { if (evalListener != evaluators[i].GetEvaluationListener()) { // This would be very complex To support throw new Exception("Workbook evaluators must all have the same evaluation listener"); } } EvaluationCache cache = new EvaluationCache(evalListener); for (int i = 0; i < nItems; i++) { evaluators[i].AttachToEnvironment(env, cache, i); } }
/** * @param udfFinder pass <code>null</code> for default (AnalysisToolPak only) */ public HSSFFormulaEvaluator(IWorkbook workbook, IStabilityClassifier stabilityClassifier, UDFFinder udfFinder) { _bookEvaluator = new WorkbookEvaluator(HSSFEvaluationWorkbook.Create(workbook), stabilityClassifier, udfFinder); }
private SXSSFFormulaEvaluator(SXSSFWorkbook workbook, WorkbookEvaluator bookEvaluator) : base(bookEvaluator) { this.wb = workbook; }
/** * @param udfFinder pass <code>null</code> for default (AnalysisToolPak only) */ private HSSFFormulaEvaluator(NPOI.SS.UserModel.Workbook workbook, IStabilityClassifier stabilityClassifier, UDFFinder udfFinder) { _bookEvaluator = new WorkbookEvaluator(HSSFEvaluationWorkbook.Create(workbook), stabilityClassifier, udfFinder); }
/** * Coordinates several formula evaluators together so that formulas that involve external * references can be evaluated. * @param workbookNames the simple file names used to identify the workbooks in formulas * with external links (for example "MyData.xls" as used in a formula "[MyData.xls]Sheet1!A1") * @param evaluators all evaluators for the full set of workbooks required by the formulas. */ public static void SetupEnvironment(String[] workbookNames, HSSFFormulaEvaluator[] evaluators) { WorkbookEvaluator[] wbEvals = new WorkbookEvaluator[evaluators.Length]; for (int i = 0; i < wbEvals.Length; i++) { wbEvals[i] = evaluators[i]._bookEvaluator; } CollaboratingWorkbooksEnvironment.Setup(workbookNames, wbEvals); }
protected BaseXSSFFormulaEvaluator(WorkbookEvaluator bookEvaluator) : base(bookEvaluator) { }
//TODO; will need testing added for streaming public XSSFFormulaEvaluator(WorkbookEvaluator bookEvaluator) { _bookEvaluator = bookEvaluator; }
public XSSFFormulaEvaluator(XSSFWorkbook workbook, IStabilityClassifier stabilityClassifier) { this._bookEvaluator = new WorkbookEvaluator((IEvaluationWorkbook)XSSFEvaluationWorkbook.Create((IWorkbook)workbook), stabilityClassifier, (UDFFinder)null); this._book = workbook; }
protected XSSFFormulaEvaluator(XSSFWorkbook workbook, WorkbookEvaluator bookEvaluator) : base(bookEvaluator) { _book = workbook; }