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, true));
}
return(1);
}
if (vb is StringEval)
{
return(-1);
}
if (va is NumberEval)
{
if (vb is NumberEval)
{
NumberEval nA = (NumberEval)va;
NumberEval nB = (NumberEval)vb;
return(nA.NumberValue.CompareTo(nB.NumberValue));
}
}
throw new ArgumentException("Bad operand types (" + va.GetType().Name + "), ("
+ vb.GetType().Name + ")");
}
/**
* 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);
}
public override Eval Evaluate(Eval[] operands, int srcCellRow, short srcCellCol)
{
Eval retval = ErrorEval.VALUE_INVALID;
int index = 1;
switch (operands.Length)
{
case 2:
Eval indexEval = operands[1];
index = EvaluateAsInteger(indexEval);
break;
case 1:
ValueEval veval = SingleOperandEvaluate(operands[0], srcCellRow, srcCellCol);
String str = null;
if (veval is StringEval)
{
StringEval stringEval = (StringEval)veval;
str = stringEval.StringValue;
}
else if (veval is BoolEval)
{
BoolEval beval = (BoolEval)veval;
str = beval.BooleanValue ? "TRUE" : "FALSE";
}
else if (veval is NumberEval)
{
NumberEval neval = (NumberEval)veval;
str = neval.StringValue;
}
if (null != str)
{
int strlen = str.Length;
str = str.Substring(Math.Max(0, strlen - index));
retval = new StringEval(str);
}
break;
default:
break;
}
return retval;
}
/**
* 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));
}
if (v is StringEval)
{
StringEval se = (StringEval)v;
return(se.StringValue.Length < 1 ? 0 : -1);
}
throw new ArgumentException("bad value class (" + v.GetType().Name + ")");
}
public StringLookupComparer(StringEval se)
: base(se)
{
_value = se.StringValue;
}
/**
* When the second argument Is a string, many things are possible
*/
private static I_MatchPredicate CreateGeneralMatchPredicate(StringEval stringEval)
{
String value = stringEval.StringValue;
CmpOp optr = CmpOp.GetOperator(value);
value = value.Substring(optr.Length);
bool? boolVal= ParseBoolean(value);
if(boolVal!=null)
{
return new BooleanMatcher(boolVal==true?true:false, optr);
}
Double doubleVal = OperandResolver.ParseDouble(value);
if(!double.IsNaN(doubleVal)) {
return new NumberMatcher(doubleVal, optr);
}
//else - just a plain string with no interpretation.
return new StringMatcher(value, optr);
}
/**
* 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);
}
/**
* 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;
}