@Override public double doubleValue() { if (comp == ValueComparator.EQUAL_TO) { return val.doubleValue(); } else if (comp == ValueComparator.LESS_THAN) { return val.doubleValue() - Double.MIN_VALUE; } else { return val.doubleValue() + Double.MIN_VALUE; } }
private void init(ValueComparator comparator, BigDecimal val) { if (val != null) { this.val = NumberValue.getInstance(val); } else { this.val = NumberValue.getInstance(0); } if (comparator == null) { comp = ValueComparator.EQUAL_TO; } else { comp = comparator; } }
@Override public int hashCode() { if (hashCode == 0) { int result = 17; result = 37 * result + val.hashCode(); result = 37 * result + comp.hashCode(); hashCode = result; } return hashCode; }
/** * Compares this value and another numerically, or checks this value for membership in a value * list. * * @param o a {@link Value}. * @return If the provided value is a {@link NumericalValue}, returns {@link * ValueComparator#GREATER_THAN}, {@link ValueComparator#LESS_THAN} or {@link * ValueComparator#EQUAL_TO} depending on whether this value is numerically greater than, less * than or equal to the value provided as argument. IF the provided value is a {@link * ValueList}, returns {@link ValueComparator#IN} if this object is a member of the value * list, or {@link ValueComparator#NOT_IN} if this object is not a member. Otherwise, returns * {@link ValueComparator#UNKNOWN}. */ @Override public ValueComparator compare(Value d2) { if (d2 == null) { return ValueComparator.NOT_EQUAL_TO; } switch (d2.getType()) { case NUMBERVALUE: NumberValue otherVal = (NumberValue) d2; int valComp = val.compareTo(otherVal); switch (this.comp) { case EQUAL_TO: return valComp > 0 ? ValueComparator.GREATER_THAN : (valComp < 0 ? ValueComparator.LESS_THAN : ValueComparator.EQUAL_TO); case LESS_THAN: return valComp <= 0 ? ValueComparator.LESS_THAN : ValueComparator.UNKNOWN; default: return valComp >= 0 ? ValueComparator.GREATER_THAN : ValueComparator.UNKNOWN; } case INEQUALITYNUMBERVALUE: InequalityNumberValue other = (InequalityNumberValue) d2; ValueComparator d2Comp = other.comp; int valComp2 = this.val.compareTo(other.val); if (this.comp == d2Comp) { if (this.comp == ValueComparator.EQUAL_TO) { return valComp2 > 0 ? ValueComparator.GREATER_THAN : (valComp2 < 0 ? ValueComparator.LESS_THAN : ValueComparator.EQUAL_TO); } else { return ValueComparator.UNKNOWN; } } else if (this.comp == ValueComparator.GREATER_THAN && d2Comp == ValueComparator.LESS_THAN) { if (valComp2 >= 0) { return ValueComparator.GREATER_THAN; } else { return ValueComparator.UNKNOWN; } } else { if (valComp2 <= 0) { return ValueComparator.LESS_THAN; } else { return ValueComparator.UNKNOWN; } } case VALUELIST: ValueList<?> vl = (ValueList<?>) d2; return vl.contains(this) ? ValueComparator.IN : ValueComparator.NOT_IN; default: return ValueComparator.NOT_EQUAL_TO; } }
@Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } InequalityNumberValue i = (InequalityNumberValue) obj; return (val == i.val || val.equals(i.val)) && comp == i.comp; }
public void testEquals() { BooleanValue t2 = BooleanValue.TRUE; BooleanValue f2 = BooleanValue.FALSE; BooleanValue null1 = BooleanValue.getNullValue(); BooleanValue null2 = BooleanValue.getNullValue(); assertTrue(t.equals(t)); assertTrue(t.equals(t2)); assertTrue(f.equals(f)); assertTrue(f.equals(f2)); assertTrue(null1.equals(null1)); assertTrue(null1.equals(null2)); assertFalse(t.equals(f)); assertFalse(f.equals(t)); assertFalse(t.equals(null1)); assertFalse(f.equals(null1)); assertFalse(null1.equals(t)); assertFalse(null2.equals(t2)); // Check interaction with other classes: assertFalse(t.equals(Integer.valueOf(7))); assertFalse(null1.equals(NumberValue.getNullValue())); }
@Override public BigDecimal getBigDecimal() { return val.getBigDecimal(); }
@Override public Number getNumber() { return val.getNumber(); }
@Override public String getFormatted() { return comp.getComparatorString() + " " + val.getFormatted(); }
public boolean matches(Object value1, Object value2) { if (value1 == value2) return true; if (NumberValue.isNaN(value1) && NumberValue.isNaN(value2)) return true; return Compare.apply(Compare.LENIENT_EQ, value1, value2, collator); }