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 + ")");
        }
Esempio n. 2
0
 /**
  * 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);
 }
Esempio n. 3
0
        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;
        }
Esempio n. 4
0
        /**
         * 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 + ")");
 }
Esempio n. 6
0
 public StringLookupComparer(StringEval se)
     : base(se)
 {
     _value = se.StringValue;
 }
Esempio n. 7
0
        /**
         * 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;
 }