/// <summary>
/// Run formula and apply to passed cell.
/// </summary>
/// <param name="cell"></param>
/// <returns></returns>
public Boolean Run(SheetCell cell)
{
Boolean returnValue = default(Boolean);
FormulaExecutionContext context = default(FormulaExecutionContext);
try
{
//validate settings determined at runtime
if (!this.Complete())
{
throw new ApplicationException(String.Format("{0}", this.ErrorMessage));
}
//run operation
context = new FormulaExecutionContext(this, cell);
cell.ValueChangingProgrammatically = true;
//TODO:invoke with parameter list
cell.Value = this.Delegate.DynamicInvoke(new ParameterExpression[] { /*Expression.Parameter(typeof(float), "p")*/ }).ToString(); //AssignerOperand.Evaluate(context).ToString();
//TODO:mvoe this or something like it to wwhere formula is changed.
//cell.Value = AssignerOperand.Evaluate(context).ToString();
cell.ValueChangingProgrammatically = false;
returnValue = true;
}
catch (Exception ex)
{
Log.Write(ex, MethodBase.GetCurrentMethod(), EventLogEntryType.Error);
cell.ValueChangingProgrammatically = false;
throw;
}
return(returnValue);
}
/// <summary>
/// Evaluate the operand. Must return the literal value.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override Single Evaluate(FormulaExecutionContext context)
{
Single returnValue = default(Single);
try
{
returnValue = _Value;
}
catch (Exception ex)
{
Log.Write(ex, MethodBase.GetCurrentMethod(), EventLogEntryType.Error);
throw;
}
return(returnValue);
}
/// <summary>
/// The operation's OperandBase implementation is invoked here.
/// </summary>
/// <param name="dictionary"></param>
/// <param name="context"></param>
/// <returns></returns>
public OperandBase Run(Dictionary <String, OperandBase> dictionary, FormulaExecutionContext context)
{
OperandBase returnValue = default(OperandBase);
try
{
returnValue = functorOperandBase(dictionary, context);
}
catch (Exception ex)
{
Log.Write(ex, MethodBase.GetCurrentMethod(), EventLogEntryType.Error);
throw;
}
return(returnValue);
}
/// <summary>
/// Evaluate the operand. Must process the address reference and find a single sheet cell.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override Single Evaluate(FormulaExecutionContext context)
{
Single returnValue = default(Single);
List <CategoryItem> assignerCellCriteria = default(List <CategoryItem>);
List <SheetCell> formulaSearchResults = default(List <SheetCell>);
Sheet sheet = default(Sheet);
try
{
//locate parent sheet, containing cells
sheet = context.ExecutingFormula.Parent;
if (sheet == null)
{
throw new ApplicationException(String.Format("Unable to find parent sheet for formula: '{0}'", context.ExecutingFormula.Value));
}
//select all criteria in assignee cell EXCEPT those categories defined for assigner in the formula criteria.
assignerCellCriteria = context.AssigneeCell.CategoryItems.Except(_Value, new EqualityComparerOfT <CategoryItem>((x, y) => x.Parent == y.Parent)).ToList <CategoryItem>();
//add formula criteria to produce a complete set of criteria for an assigner cell.
assignerCellCriteria.AddRange(_Value);
//run assigner criteria
formulaSearchResults = Sheet.GetCellsWhereAllSearchCategoryItemsMatchAnyInGivenCell(sheet.Cells.ToList <SheetCell>(), assignerCellCriteria);
if ((formulaSearchResults == null) || (formulaSearchResults.Count == 0))
{
throw new ApplicationException(String.Format("Unable to find assigner cell for parent sheet for formula '{0}'", context.ExecutingFormula.Value));
}
if (formulaSearchResults.Count > 1)
{
throw new ApplicationException(String.Format("Too many results found for assigner cell for parent sheet for formula '{0}'", context.ExecutingFormula.Value));
}
//retrieve value from single cell in results
returnValue = Single.Parse(formulaSearchResults[0].Value);
}
catch (Exception ex)
{
Log.Write(ex, MethodBase.GetCurrentMethod(), EventLogEntryType.Error);
throw;
}
return(returnValue);
}
/// <summary>
/// Run operation on child operands. Must pass through sheet cell and formula to child operands that may need to do cell lookups.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override Single Run(FormulaExecutionContext context)
{
Single returnValue = default(Single);
OperandBase operationResult = default(OperandBase);
try
{
//The operand (of type OperandOperation) that contains this operation will have its Evaluate() called; Evaluate() will call this operation's Run().
operationResult = Operator.Run(this.Operands, context);
returnValue = operationResult.Evaluate(context);
}
catch (Exception ex)
{
Log.Write(ex, MethodBase.GetCurrentMethod(), EventLogEntryType.Error);
throw;
}
return(returnValue);
}
public abstract Single Evaluate(FormulaExecutionContext context);
/// <summary> /// Run operation on child operands. Must pass through sheet cell and formula to child operands that may need to do cell lookups. /// </summary> /// <param name="context"></param> /// <returns></returns> public abstract Single Run(FormulaExecutionContext context);