@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);
}
