public void Remove(Loc key)
{
_plainValueEntriesByLoc.Remove(key);
}
public PlainValueCellCacheEntry Get(Loc key)
{
return (PlainValueCellCacheEntry)_plainValueEntriesByLoc[key];
}
public void Put(Loc key, PlainValueCellCacheEntry cce)
{
_plainValueEntriesByLoc[key] = cce;
}
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 == LF.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);
}
}
}
public void NotifyDeleteCell(int bookIndex, int sheetIndex, IEvaluationCell cell)
{
if (cell.CellType == LF.Utils.NPOI.SS.UserModel.CellType.FORMULA)
{
FormulaCellCacheEntry fcce = _formulaCellCache.Remove(cell);
if (fcce == null)
{
// formula cell Has not been evaluated yet
}
else
{
fcce.SetSensitiveInputCells(null);
fcce.RecurseClearCachedFormulaResults(_evaluationListener);
}
}
else
{
Loc loc = new Loc(bookIndex, sheetIndex, cell.RowIndex, cell.ColumnIndex);
PlainValueCellCacheEntry pcce = _plainCellCache.Get(loc);
if (pcce == null)
{
// cache entry doesn't exist. nothing To do
}
else
{
pcce.RecurseClearCachedFormulaResults(_evaluationListener);
}
}
}
public PlainValueCellCacheEntry GetPlainValueEntry(int bookIndex, int sheetIndex,
int rowIndex, int columnIndex, ValueEval value)
{
Loc loc = new Loc(bookIndex, sheetIndex, rowIndex, columnIndex);
PlainValueCellCacheEntry result = _plainCellCache.Get(loc);
if (result == null)
{
result = new PlainValueCellCacheEntry(value);
_plainCellCache.Put(loc, result);
if (_evaluationListener != null)
{
_evaluationListener.OnReadPlainValue(sheetIndex, rowIndex, columnIndex, result);
}
}
else
{
// TODO - if we are confident that this sanity check is not required, we can Remove 'value' from plain value cache entry
if (!AreValuesEqual(result.GetValue(), value))
{
throw new InvalidOperationException("value changed");
}
if (_evaluationListener != null)
{
_evaluationListener.OnCacheHit(sheetIndex, rowIndex, columnIndex, value);
}
}
return result;
}
