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;
 }
Ejemplo n.º 3
0
 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);
 }
Ejemplo n.º 5
0
 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);
     }
 }
Ejemplo n.º 6
0
        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();
     }
 }
Ejemplo n.º 8
0
        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);
                }
            }
        }
Ejemplo n.º 9
0
 private ForkedEvaluator(IEvaluationWorkbook masterWorkbook, IStabilityClassifier stabilityClassifier, UDFFinder udfFinder)
 {
     _sewb      = new ForkedEvaluationWorkbook(masterWorkbook);
     _evaluator = new WorkbookEvaluator(_sewb, stabilityClassifier, udfFinder);
 }
Ejemplo n.º 10
0
 private XSSFFormulaEvaluator(XSSFWorkbook workbook, IStabilityClassifier stabilityClassifier, UDFFinder udfFinder)
 {
     _bookEvaluator = new WorkbookEvaluator(XSSFEvaluationWorkbook.Create(workbook), stabilityClassifier, udfFinder);
     _book          = workbook;
 }
Ejemplo n.º 11
0
        /**
         * @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);
            }

        }
Ejemplo n.º 13
0
 /**
  * @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);
 }
Ejemplo n.º 14
0
 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);
 }
 /**
  * @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);
 }
 /**
  * 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);
 }
Ejemplo n.º 18
0
 protected BaseXSSFFormulaEvaluator(WorkbookEvaluator bookEvaluator)
     : base(bookEvaluator)
 {
 }
Ejemplo n.º 19
0
 //TODO; will need testing added for streaming
 public XSSFFormulaEvaluator(WorkbookEvaluator bookEvaluator)
 {
     _bookEvaluator = bookEvaluator;
 }
Ejemplo n.º 20
0
 public XSSFFormulaEvaluator(XSSFWorkbook workbook, IStabilityClassifier stabilityClassifier)
 {
     this._bookEvaluator = new WorkbookEvaluator((IEvaluationWorkbook)XSSFEvaluationWorkbook.Create((IWorkbook)workbook), stabilityClassifier, (UDFFinder)null);
     this._book          = workbook;
 }
Ejemplo n.º 21
0
 protected XSSFFormulaEvaluator(XSSFWorkbook workbook, WorkbookEvaluator bookEvaluator)
     : base(bookEvaluator)
 {
     _book = workbook;
 }
Ejemplo n.º 22
0
 private ForkedEvaluator(IEvaluationWorkbook masterWorkbook, IStabilityClassifier stabilityClassifier, UDFFinder udfFinder)
 {
     _sewb = new ForkedEvaluationWorkbook(masterWorkbook);
     _evaluator = new WorkbookEvaluator(_sewb, stabilityClassifier, udfFinder);
 }