/**
* uses the relevant flags to decode the StringEval
* @param eval
*/
private ValueEval XlateRefStringEval(StringEval sve)
{
if ((flags & REF_STRING_IS_PARSED) > 0)
{
String s = sve.StringValue;
double d = OperandResolver.ParseDouble(s);
if (double.IsNaN(d))
{
return(ErrorEval.VALUE_INVALID);
}
return(new NumberEval(d));
}
// strings are blanks
return(BlankEval.instance);
}
/**
* uses the relevant flags to decode the StringEval
* @param eval
*/
private ValueEval XlateStringEval(StringEval eval)
{
if ((flags & STRING_IS_PARSED) > 0)
{
String s = eval.StringValue;
double d = OperandResolver.ParseDouble(s);
if (double.IsNaN(d))
{
return(ErrorEval.VALUE_INVALID);
}
return(new NumberEval(d));
}
// strings are errors?
if ((flags & STRING_IS_INVALID_VALUE) > 0)
{
return(ErrorEval.VALUE_INVALID);
}
// ignore strings
return(XlateBlankEval(BLANK_IS_PARSED));
}
private static int CompareBlank(ValueEval v)
{
if (v == BlankEval.instance)
{
return(0);
}
if (v is BoolEval)
{
BoolEval boolEval = (BoolEval)v;
return(boolEval.BooleanValue ? -1 : 0);
}
if (v is NumberEval)
{
NumberEval ne = (NumberEval)v;
//return ne.NumberValue.CompareTo(0.0);
return(NumberComparer.Compare(0.0, ne.NumberValue));
}
if (v is StringEval)
{
StringEval se = (StringEval)v;
return(se.StringValue.Length < 1 ? 0 : -1);
}
throw new ArgumentException("bad value class (" + v.GetType().Name + ")");
}
/**
* When the second argument is a string, many things are possible
*/
private static I_MatchPredicate CreateGeneralMatchPredicate(StringEval stringEval)
{
String value = stringEval.StringValue;
CmpOp operator1 = CmpOp.GetOperator(value);
value = value.Substring(operator1.Length);
bool? booleanVal = ParseBoolean(value);
if (booleanVal != null)
{
return new BooleanMatcher(booleanVal.Value, operator1);
}
Double doubleVal = OperandResolver.ParseDouble(value);
if (!double.IsNaN(doubleVal))
{
return new NumberMatcher(doubleVal, operator1);
}
ErrorEval ee = ParseError(value);
if (ee != null)
{
return new ErrorMatcher(ee.ErrorCode, operator1);
}
//else - just a plain string with no interpretation.
return new StringMatcher(value, operator1);
}
/**
* uses the relevant flags to decode the StringEval
* @param eval
*/
private ValueEval XlateRefStringEval(StringEval sve)
{
if ((flags & REF_STRING_IS_PARSED) > 0)
{
String s = sve.StringValue;
double d = OperandResolver.ParseDouble(s);
if (double.IsNaN(d))
{
return ErrorEval.VALUE_INVALID;
}
return new NumberEval(d);
}
// strings are blanks
return BlankEval.instance;
}
/**
* uses the relevant flags to decode the StringEval
* @param eval
*/
private ValueEval XlateStringEval(StringEval eval)
{
if ((flags & STRING_IS_PARSED) > 0)
{
String s = eval.StringValue;
double d = OperandResolver.ParseDouble(s);
if (double.IsNaN(d))
{
return ErrorEval.VALUE_INVALID;
}
return new NumberEval(d);
}
// strings are errors?
if ((flags & STRING_IS_INVALID_VALUE) > 0)
{
return ErrorEval.VALUE_INVALID;
}
// ignore strings
return XlateBlankEval(BLANK_IS_PARSED);
}
private static int DoCompare(ValueEval va, ValueEval vb)
{
// special cases when one operand is blank
if (va == BlankEval.instance)
{
return(CompareBlank(vb));
}
if (vb == BlankEval.instance)
{
return(-CompareBlank(va));
}
if (va is BoolEval)
{
if (vb is BoolEval)
{
BoolEval bA = (BoolEval)va;
BoolEval bB = (BoolEval)vb;
if (bA.BooleanValue == bB.BooleanValue)
{
return(0);
}
return(bA.BooleanValue ? 1 : -1);
}
return(1);
}
if (vb is BoolEval)
{
return(-1);
}
if (va is StringEval)
{
if (vb is StringEval)
{
StringEval sA = (StringEval)va;
StringEval sB = (StringEval)vb;
return(string.Compare(sA.StringValue, sB.StringValue, StringComparison.OrdinalIgnoreCase));
}
return(1);
}
if (vb is StringEval)
{
return(-1);
}
if (va is NumberEval)
{
if (vb is NumberEval)
{
NumberEval nA = (NumberEval)va;
NumberEval nB = (NumberEval)vb;
if (nA.NumberValue == nB.NumberValue)
{
// Excel considers -0.0 == 0.0 which is different to Double.compare()
return(0);
}
return(NumberComparer.Compare(nA.NumberValue, nB.NumberValue));
}
}
throw new ArgumentException("Bad operand types (" + va.GetType().Name + "), ("
+ vb.GetType().Name + ")");
}
public StringLookupComparer(StringEval se)
: base(se)
{
_value = se.StringValue;
}
