package jnpf.elnFormula;
|
|
import java.math.BigDecimal;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.List;
|
import java.util.Objects;
|
|
public final class FormulaValue {
|
|
private static final FormulaValue NULL = new FormulaValue(FormulaType.NULL, null, null);
|
|
private final FormulaType type;
|
private final Object value;
|
private final String missingSlotCode;
|
|
private FormulaValue(FormulaType type, Object value) {
|
this(type, value, null);
|
}
|
|
private FormulaValue(FormulaType type, Object value, String missingSlotCode) {
|
this.type = type;
|
this.value = value;
|
this.missingSlotCode = missingSlotCode;
|
}
|
|
public static FormulaValue decimal(String value) {
|
if (value == null) {
|
throw new IllegalArgumentException("decimal value must not be null");
|
}
|
return decimal(new BigDecimal(value));
|
}
|
|
public static FormulaValue decimal(BigDecimal value) {
|
if (value == null) {
|
throw new IllegalArgumentException("decimal value must not be null");
|
}
|
return new FormulaValue(FormulaType.DECIMAL, value);
|
}
|
|
public static FormulaValue decimalList(List<FormulaValue> values) {
|
if (values == null) {
|
throw new IllegalArgumentException("decimal list must not be null");
|
}
|
List<FormulaValue> copy = new ArrayList<>(values.size());
|
for (FormulaValue value : values) {
|
if (value == null || value.type != FormulaType.DECIMAL) {
|
throw new IllegalArgumentException("decimal list accepts DECIMAL values only");
|
}
|
copy.add(value);
|
}
|
return new FormulaValue(FormulaType.DECIMAL_LIST,
|
Collections.unmodifiableList(copy));
|
}
|
|
public static FormulaValue decimalList(FormulaValue... values) {
|
if (values == null) {
|
throw new IllegalArgumentException("decimal list must not be null");
|
}
|
List<FormulaValue> items = new ArrayList<>(values.length);
|
Collections.addAll(items, values);
|
return decimalList(items);
|
}
|
|
public static FormulaValue text(String value) {
|
if (value == null) {
|
throw new IllegalArgumentException("text value must not be null");
|
}
|
return new FormulaValue(FormulaType.TEXT, value);
|
}
|
|
public static FormulaValue bool(boolean value) {
|
return new FormulaValue(FormulaType.BOOLEAN, value);
|
}
|
|
public static FormulaValue nullValue() {
|
return NULL;
|
}
|
|
public static FormulaValue nullValue(String missingSlotCode) {
|
if (missingSlotCode == null || missingSlotCode.isEmpty()) {
|
throw new IllegalArgumentException("missing slot code must not be empty");
|
}
|
return new FormulaValue(FormulaType.NULL, null, missingSlotCode);
|
}
|
|
public FormulaType getType() {
|
return type;
|
}
|
|
public String getMissingSlotCode() {
|
return missingSlotCode;
|
}
|
|
public BigDecimal getDecimal() {
|
require(FormulaType.DECIMAL);
|
return (BigDecimal) value;
|
}
|
|
@SuppressWarnings("unchecked")
|
public List<FormulaValue> getDecimalList() {
|
require(FormulaType.DECIMAL_LIST);
|
return (List<FormulaValue>) value;
|
}
|
|
public String getText() {
|
require(FormulaType.TEXT);
|
return (String) value;
|
}
|
|
public boolean getBoolean() {
|
require(FormulaType.BOOLEAN);
|
return (Boolean) value;
|
}
|
|
public boolean isNull() {
|
return type == FormulaType.NULL;
|
}
|
|
public String toPlainString() {
|
if (type == FormulaType.NULL) {
|
return "null";
|
}
|
if (type == FormulaType.TEXT) {
|
return getText();
|
}
|
if (type == FormulaType.BOOLEAN) {
|
return Boolean.toString(getBoolean());
|
}
|
if (type == FormulaType.DECIMAL) {
|
BigDecimal decimal = getDecimal();
|
return decimal.signum() == 0 ? "0" : decimal.stripTrailingZeros().toPlainString();
|
}
|
StringBuilder result = new StringBuilder("[");
|
List<FormulaValue> items = getDecimalList();
|
for (int i = 0; i < items.size(); i++) {
|
if (i > 0) {
|
result.append(',');
|
}
|
result.append(items.get(i).toPlainString());
|
}
|
return result.append(']').toString();
|
}
|
|
private void require(FormulaType expected) {
|
if (type != expected) {
|
throw new IllegalStateException("expected " + expected + " but was " + type);
|
}
|
}
|
|
@Override
|
public boolean equals(Object other) {
|
if (this == other) {
|
return true;
|
}
|
if (!(other instanceof FormulaValue)) {
|
return false;
|
}
|
FormulaValue that = (FormulaValue) other;
|
if (type != that.type) {
|
return false;
|
}
|
if (type == FormulaType.DECIMAL) {
|
return getDecimal().compareTo(that.getDecimal()) == 0;
|
}
|
return Objects.equals(value, that.value);
|
}
|
|
@Override
|
public int hashCode() {
|
Object hashValue = type == FormulaType.DECIMAL
|
? getDecimal().stripTrailingZeros() : value;
|
return Objects.hash(type, hashValue);
|
}
|
|
@Override
|
public String toString() {
|
return toPlainString();
|
}
|
}
|
