public boolean matches(ValueEval valueEval) { // Note - only BlankEval counts return valueEval == BlankEval.instance || // see https://support.office.com/en-us/article/COUNTBLANK-function-6a92d772-675c-4bee-b346-24af6bd3ac22 // "Cells with formulas that return "" (empty text) are also counted." (valueEval instanceof StringEval && ((StringEval)valueEval).getStringValue().isEmpty()); } };
protected StringLookupComparer(StringEval se, boolean matchExact, boolean isMatchFunction) { super(se); _value = se.getStringValue(); _wildCardPattern = Countif.StringMatcher.getWildCardPattern(_value); _matchExact = matchExact; _isMatchFunction = isMatchFunction; }
protected CompareResult compareSameType(ValueEval other) { StringEval se = (StringEval) other; String stringValue = se.getStringValue(); if (_wildCardPattern != null) { Matcher matcher = _wildCardPattern.matcher(stringValue); boolean matches = matcher.matches(); if (_isMatchFunction || !_matchExact) { return CompareResult.valueOf(matches); } } return CompareResult.valueOf(_value.compareToIgnoreCase(stringValue)); } protected String getValueAsString() {
private static int compareBlank(ValueEval v) { if (v == BlankEval.instance) { return 0; } if (v instanceof BoolEval) { BoolEval boolEval = (BoolEval) v; return boolEval.getBooleanValue() ? -1 : 0; } if (v instanceof NumberEval) { NumberEval ne = (NumberEval) v; return NumberComparer.compare(0.0, ne.getNumberValue()); } if (v instanceof StringEval) { StringEval se = (StringEval) v; return se.getStringValue().length() < 1 ? 0 : -1; } throw new IllegalArgumentException("bad value class (" + v.getClass().getName() + ")"); }
/** * Applies some conversion rules if the supplied value is not already a number. * Note - <tt>BlankEval</tt> is converted to {@link NumberEval#ZERO}. * @param ev must be a {@link NumberEval}, {@link StringEval}, {@link BoolEval} or * {@link BlankEval} * @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 <tt>parseDouble()</tt> for allowable formats). * @throws RuntimeException if the supplied parameter is not {@link NumberEval}, * {@link StringEval}, {@link BoolEval} or {@link BlankEval} */ public static double coerceValueToDouble(ValueEval ev) throws EvaluationException { if (ev == BlankEval.instance) { return 0.0; } if (ev instanceof NumericValueEval) { // this also handles booleans return ((NumericValueEval)ev).getNumberValue(); } if (ev instanceof StringEval) { Double dd = parseDouble(((StringEval) ev).getStringValue()); if (dd == null) { throw EvaluationException.invalidValue(); } return dd.doubleValue(); } throw new RuntimeException("Unexpected arg eval type (" + ev.getClass().getName() + ")"); }
private static boolean areValuesEqual(ValueEval a, ValueEval b) { if (a == null) { return false; } Class<? extends ValueEval> cls = a.getClass(); if (cls != b.getClass()) { // value type is changing return false; } if (a == BlankEval.instance) { return b == a; } if (cls == NumberEval.class) { return ((NumberEval)a).getNumberValue() == ((NumberEval)b).getNumberValue(); } if (cls == StringEval.class) { return ((StringEval)a).getStringValue().equals(((StringEval)b).getStringValue()); } if (cls == BoolEval.class) { return ((BoolEval)a).getBooleanValue() == ((BoolEval)b).getBooleanValue(); } if (cls == ErrorEval.class) { return ((ErrorEval)a).getErrorCode() == ((ErrorEval)b).getErrorCode(); } throw new IllegalStateException("Unexpected value class (" + cls.getName() + ")"); }
private boolean areValuesEqual(ValueEval a, ValueEval b) { if (a == null) { return false; } Class<?> cls = a.getClass(); if (cls != b.getClass()) { // value type is changing return false; } if (a == BlankEval.instance) { return b == a; } if (cls == NumberEval.class) { return ((NumberEval)a).getNumberValue() == ((NumberEval)b).getNumberValue(); } if (cls == StringEval.class) { return ((StringEval)a).getStringValue().equals(((StringEval)b).getStringValue()); } if (cls == BoolEval.class) { return ((BoolEval)a).getBooleanValue() == ((BoolEval)b).getBooleanValue(); } if (cls == ErrorEval.class) { return ((ErrorEval)a).getErrorCode() == ((ErrorEval)b).getErrorCode(); } throw new IllegalStateException("Unexpected value class (" + cls.getName() + ")"); }
public void setValue(ValueEval value) { Class<? extends ValueEval> cls = value.getClass(); if (cls == NumberEval.class) { _cellType = CellType.NUMERIC; _numberValue = ((NumberEval)value).getNumberValue(); return; } if (cls == StringEval.class) { _cellType = CellType.STRING; _stringValue = ((StringEval)value).getStringValue(); return; } if (cls == BoolEval.class) { _cellType = CellType.BOOLEAN; _booleanValue = ((BoolEval)value).getBooleanValue(); return; } if (cls == ErrorEval.class) { _cellType = CellType.ERROR; _errorValue = ((ErrorEval)value).getErrorCode(); return; } if (cls == BlankEval.class) { _cellType = CellType.BLANK; return; } throw new IllegalArgumentException("Unexpected value class (" + cls.getName() + ")"); } public void copyValue(Cell destCell) {
private static double evaluateMatchTypeArg(ValueEval arg, int srcCellRow, int srcCellCol) throws EvaluationException { ValueEval match_type = OperandResolver.getSingleValue(arg, srcCellRow, srcCellCol); if(match_type instanceof ErrorEval) { throw new EvaluationException((ErrorEval)match_type); } if(match_type instanceof NumericValueEval) { NumericValueEval ne = (NumericValueEval) match_type; return ne.getNumberValue(); } if (match_type instanceof StringEval) { StringEval se = (StringEval) match_type; Double d = OperandResolver.parseDouble(se.getStringValue()); if(d == null) { // plain string throw new EvaluationException(ErrorEval.VALUE_INVALID); } // if the string parses as a number, it is OK return d.doubleValue(); } throw new RuntimeException("Unexpected match_type type (" + match_type.getClass().getName() + ")"); }
String testedValue = ((StringEval) x).getStringValue(); if (testedValue.length() < 1 && _value.length() < 1) {
private static double evaluateDateArg(ValueEval arg, int srcCellRow, int srcCellCol) throws EvaluationException { ValueEval ve = OperandResolver.getSingleValue(arg, srcCellRow, (short) srcCellCol); if (ve instanceof StringEval) { String strVal = ((StringEval) ve).getStringValue(); Double dVal = OperandResolver.parseDouble(strVal); if (dVal != null) { return dVal.doubleValue(); } Calendar date = DateParser.parseDate(strVal); return DateUtil.getExcelDate(date, false); } return OperandResolver.coerceValueToDouble(ve); }
if (eval instanceof NumberEval) return Double.valueOf(((NumberEval) eval).getNumberValue()); if (eval instanceof StringEval) { final String value = ((StringEval) eval).getStringValue(); if (value == null || value.trim().isEmpty()) return null;
StringEval sA = (StringEval) va; StringEval sB = (StringEval) vb; return sA.getStringValue().compareToIgnoreCase(sB.getStringValue());
/** * Evaluate a generic {@link ValueEval} argument to a double value that represents a date in POI. * * @param arg {@link ValueEval} an argument. * @param srcCellRow number cell row. * @param srcCellCol number cell column. * @return a double representing a date in POI. * @throws EvaluationException exception upon argument evaluation. */ public double evaluateDateArg(ValueEval arg, int srcCellRow, int srcCellCol) throws EvaluationException { ValueEval ve = OperandResolver.getSingleValue(arg, srcCellRow, (short) srcCellCol); if (ve instanceof StringEval) { String strVal = ((StringEval) ve).getStringValue(); Double dVal = OperandResolver.parseDouble(strVal); if (dVal != null) { return dVal.doubleValue(); } Calendar date = DateParser.parseDate(strVal); return DateUtil.getExcelDate(date, false); } return OperandResolver.coerceValueToDouble(ve); }
String stringValue = ((StringEval) valEval).getStringValue(); if(stringValue.length() < 1) {
/** * Returns a CellValue wrapper around the supplied ValueEval instance. */ protected CellValue evaluateFormulaCellValue(Cell cell) { EvaluationCell evalCell = toEvaluationCell(cell); ValueEval eval = _bookEvaluator.evaluate(evalCell); if (eval instanceof NumberEval) { NumberEval ne = (NumberEval) eval; return new CellValue(ne.getNumberValue()); } if (eval instanceof BoolEval) { BoolEval be = (BoolEval) eval; return CellValue.valueOf(be.getBooleanValue()); } if (eval instanceof StringEval) { StringEval ne = (StringEval) eval; return new CellValue(ne.getStringValue()); } if (eval instanceof ErrorEval) { return CellValue.getError(((ErrorEval)eval).getErrorCode()); } throw new RuntimeException("Unexpected eval class (" + eval.getClass().getName() + ")"); }
/** * When the second argument is a string, many things are possible */ private static I_MatchPredicate createGeneralMatchPredicate(StringEval stringEval) { String value = stringEval.getStringValue(); CmpOp operator = CmpOp.getOperator(value); value = value.substring(operator.getLength()); Boolean booleanVal = parseBoolean(value); if(booleanVal != null) { return new BooleanMatcher(booleanVal.booleanValue(), operator); } Double doubleVal = OperandResolver.parseDouble(value); if(doubleVal != null) { return new NumberMatcher(doubleVal.doubleValue(), operator); } ErrorEval ee = parseError(value); if (ee != null) { return new ErrorMatcher(ee.getErrorCode(), operator); } //else - just a plain string with no interpretation. return new StringMatcher(value, operator); } private static ErrorEval parseError(String value) {
Double d = OperandResolver.parseDouble(se.getStringValue()); if(d == null) {
if (isType(cell, CellType.STRING) && ((StringEval) comp).getStringValue().equalsIgnoreCase(cell.getStringCellValue())) { return true; } else {
&& (eval2 == BlankEval.instance || eval2 instanceof StringEval) ) { return operator.isValid(cell.getStringCellValue(), eval == BlankEval.instance ? null : ((StringEval) eval).getStringValue(), eval2 == BlankEval.instance ? null : ((StringEval) eval2).getStringValue());