/**
* @return possibly <c>ErrorEval</c>, and <c>null</c>
*/
private static ValueEval ChooseSingleElementFromAreaInternal(AreaEval ae,
int srcCellRow, int srcCellCol)
{
//if (false)
//{
// // this is too simplistic
// if (ae.ContainsRow(srcCellRow) && ae.ContainsColumn(srcCellCol))
// {
// throw new EvaluationException(ErrorEval.CIRCULAR_REF_ERROR);
// }
// /*
// Circular references are not dealt with directly here, but it is worth noting some Issues.
// ANY one of the return statements in this method could return a cell that is identical
// to the one immediately being Evaluated. The evaluating cell is identified by srcCellRow,
// srcCellRow AND sheet. The sheet is not available in any nearby calling method, so that's
// one reason why circular references are not easy to detect here. (The sheet of the returned
// cell can be obtained from ae if it is an Area3DEval.)
// Another reason there's little value in attempting to detect circular references here Is
// that only direct circular references could be detected. If the cycle involved two or more
// cells this method could not detect it.
// Logic to detect evaluation cycles of all kinds has been coded in EvaluationCycleDetector
// (and HSSFFormulaEvaluator).
// */
//}
if (ae.IsColumn)
{
if (ae.IsRow)
{
return(ae.GetRelativeValue(0, 0));
}
if (!ae.ContainsRow(srcCellRow))
{
throw EvaluationException.InvalidValue();
}
return(ae.GetAbsoluteValue(srcCellRow, ae.FirstColumn));
}
if (!ae.IsRow)
{
// multi-column, multi-row area
if (ae.ContainsRow(srcCellRow) && ae.ContainsColumn(srcCellCol))
{
return(ae.GetAbsoluteValue(ae.FirstRow, ae.FirstColumn));
}
throw EvaluationException.InvalidValue();
}
if (!ae.ContainsColumn(srcCellCol))
{
throw EvaluationException.InvalidValue();
}
return(ae.GetAbsoluteValue(ae.FirstRow, srcCellCol));
}
/**
* Applies some conversion rules if the supplied value is not already a number.
* Note - <c>BlankEval</c> is not supported and must be handled by the caller.
* @param ev must be a <c>NumberEval</c>, <c>StringEval</c> or <c>BoolEval</c>
* @return actual, Parsed or interpreted double value (respectively).
* @throws EvaluationException(#VALUE!) only if a StringEval is supplied and cannot be Parsed
* as a double (See <c>Parsedouble()</c> for allowable formats).
* @throws Exception if the supplied parameter is not <c>NumberEval</c>,
* <c>StringEval</c> or <c>BoolEval</c>
*/
public static double CoerceValueToDouble(ValueEval ev)
{
if (ev == BlankEval.instance)
{
return(0.0);
}
if (ev is NumericValueEval)
{
// this also handles bools
return(((NumericValueEval)ev).NumberValue);
}
if (ev is StringEval)
{
double dd = ParseDouble(((StringEval)ev).StringValue);
if (double.IsNaN(dd))
{
throw EvaluationException.InvalidValue();
}
return(dd);
}
throw new Exception("Unexpected arg eval type (" + ev.GetType().Name + ")");
}