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 ValueEval evaluate(String arg) { return new StringEval(arg.toUpperCase(Locale.ROOT)); } };
protected StringLookupComparer(StringEval se, boolean matchExact, boolean isMatchFunction) { super(se); _value = se.getStringValue(); _wildCardPattern = Countif.StringMatcher.getWildCardPattern(_value); _matchExact = matchExact; _isMatchFunction = isMatchFunction; }
protected ValueEval evaluate(String arg) { return new StringEval(arg.toLowerCase(Locale.ROOT)); } };
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() {
protected ValueEval evaluate(String arg) { return new StringEval(arg.trim()); } };
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() + ")"); }
protected ValueEval evaluate(String arg) { StringBuilder result = new StringBuilder(); for (final char c : arg.toCharArray()) { if (isPrintable(c)) { result.append(c); } } return new StringEval(result.toString()); }
/** * 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() + ")"); }
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval real_num, ValueEval i_num) { return this.evaluate(srcRowIndex, srcColumnIndex, real_num, i_num, new StringEval(DEFAULT_SUFFIX)); }
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() + ")"); }
protected ValueEval evaluate(String text) { StringBuilder sb = new StringBuilder(); boolean shouldMakeUppercase = true; for(final char ch : text.toCharArray()) { // Note: we are using String.toUpperCase() here on purpose as it handles certain things // better than Character.toUpperCase(), e.g. German "scharfes s" is translated // to "SS" (i.e. two characters), if uppercased properly! if (shouldMakeUppercase) { sb.append(String.valueOf(ch).toUpperCase(Locale.ROOT)); } else { sb.append(String.valueOf(ch).toLowerCase(Locale.ROOT)); } shouldMakeUppercase = !Character.isLetter(ch); } return new StringEval(sb.toString()); } };
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 ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) { StringBuilder sb = new StringBuilder(); for (ValueEval arg : args) { try { sb.append(evaluateStringArg(arg, srcRowIndex, srcColumnIndex)); } catch (EvaluationException e) { return e.getErrorEval(); } } return new StringEval(sb.toString()); } };
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) {
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval textArg) { ValueEval veText1; try { veText1 = OperandResolver.getSingleValue(textArg, srcRowIndex, srcColumnIndex); } catch (EvaluationException e) { return e.getErrorEval(); } String text = OperandResolver.coerceValueToString(veText1); if (text.length() == 0) { return ErrorEval.VALUE_INVALID; } int code = text.charAt(0); return new StringEval(String.valueOf(code)); } }
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() + ")"); }
return new StringEval(String.valueOf(0)); return new StringEval(imaginary);
String testedValue = ((StringEval) x).getStringValue(); if (testedValue.length() < 1 && _value.length() < 1) {
return new StringEval(String.valueOf(0)); return new StringEval(real);