private void validateCompatibleTypes(DataType d, FieldValue v) { if (!d.isValueCompatible(v)) { throw new IllegalArgumentException( "Incompatible data types. Got " + v.getDataType() + ", expected " + d); } }
public Array(DataType type, List<T> values) { this(type); for (T v : values) { if (!((ArrayDataType)type).getNestedType().isValueCompatible(v)) { throw new IllegalArgumentException("FieldValue " + v + " is not compatible with " + type + "."); } } this.values.addAll(values); }
public final boolean isAssignableFrom(DataType dataType) { // TODO: Reverse this so that isValueCompatible() uses this instead. return isValueCompatible(dataType.createFieldValue()); }
/** * Sets the value of the annotation. * * @param fieldValue the value to set * @throws UnsupportedOperationException if the annotation type does not allow this annotation to have values. */ public void setFieldValue(FieldValue fieldValue) { if (fieldValue == null) { value = null; return; } DataType type = getType().getDataType(); if (type != null && type.isValueCompatible(fieldValue)) { this.value = fieldValue; } else { String typeName = (type == null) ? "null" : type.getValueClass().getName(); throw new IllegalArgumentException("Argument is of wrong type, must be of type " + typeName + ", was " + fieldValue.getClass().getName()); } }
public void verifyElementCompatibility(T o) { if (!getDataType().getNestedType().isValueCompatible(o)) { throw new IllegalArgumentException( "Incompatible data types. Got " + o.getDataType() + ", expected " + getDataType().getNestedType()); } }
} else if (!nextKeyType.isValueCompatible(nextKey)) { throw new IllegalArgumentException("Expected " + nextKeyType.getName() + ", got " + nextKey.getDataType().getName() + "."); } else if (!nextValType.isValueCompatible(nextVal)) { throw new IllegalArgumentException("Expected " + nextValType.getName() + ", got " + nextVal.getDataType().getName() + ".");
@SuppressWarnings({ "unchecked", "rawtypes" }) private FieldValue convertArray(Array val) { List<FieldValue> next = new LinkedList<FieldValue>(); DataType nextType = null; for (Iterator<FieldValue> it = val.fieldValueIterator(); it.hasNext();) { FieldValue prevVal = it.next(); FieldValue nextVal = convert(prevVal); if (nextVal == null) { continue; } if (nextType == null) { nextType = nextVal.getDataType(); } else if (!nextType.isValueCompatible(nextVal)) { throw new IllegalArgumentException("Expected " + nextType.getName() + ", got " + nextVal.getDataType().getName() + "."); } next.add(nextVal); } if (nextType == null) { return null; } Array ret = DataType.getArray(nextType).createFieldValue(); for (FieldValue nextVal : next) { ret.add(nextVal); } return ret; }
@SuppressWarnings({ "unchecked", "rawtypes" }) private FieldValue convertWset(WeightedSet val) { Map<FieldValue, Integer> next = new LinkedHashMap<FieldValue, Integer>(); DataType nextType = null; for (Iterator<FieldValue> it = val.fieldValueIterator(); it.hasNext();) { FieldValue prevKey = it.next(); Integer prevVal = val.get(prevKey); FieldValue nextKey = convert(prevKey); if (nextKey == null) { continue; } if (nextType == null) { nextType = nextKey.getDataType(); } else if (!nextType.isValueCompatible(nextKey)) { throw new IllegalArgumentException("Expected " + nextType.getName() + ", got " + nextKey.getDataType().getName() + "."); } next.put(nextKey, prevVal); } if (nextType == null) { return null; } WeightedSet ret = DataType.getWeightedSet(nextType, val.getDataType().createIfNonExistent(), val.getDataType().removeIfZero()).createFieldValue(); for (Map.Entry<FieldValue, Integer> entry : next.entrySet()) { ret.put(entry.getKey(), entry.getValue()); } return ret; }
public final FieldValue execute(ExecutionContext context) { DataType inputType = requiredInputType(); if (inputType != null) { FieldValue input = context.getValue(); if (input == null) { return null; } if (!inputType.isValueCompatible(input)) { throw new IllegalArgumentException("Expression '" + this + "' expected " + inputType.getName() + " input, got " + input.getDataType().getName() + "."); } } doExecute(context); DataType outputType = createdOutputType(); if (outputType != null) { FieldValue output = context.getValue(); if (output != null && !outputType.isValueCompatible(output)) { throw new IllegalStateException("Expression '" + this + "' expected " + outputType.getName() + " output, got " + output.getDataType().getName() + "."); } } return context.getValue(); }
/** * Utility function to wrap primitives. * * @see Array.ListWrapper */ protected FieldValue createFieldValue(Object o) { if (o instanceof FieldValue) { if (!getDataType().getNestedType().isValueCompatible((FieldValue) o)) { throw new IllegalArgumentException( "Incompatible data types. Got " + ((FieldValue)o).getDataType() + ", expected " + getDataType().getNestedType()); } return (FieldValue) o; } else { FieldValue fval = getDataType().getNestedType().createFieldValue(); fval.assign(o); return fval; } }
@Override protected void doSetFieldValue(Field field, FieldValue value) { if (field == null) { throw new IllegalArgumentException("Invalid null field pointer"); } Field myField = getDataType().getField(field.getId()); if (myField==null) { throw new IllegalArgumentException("No such field in "+getDataType()+" : "+field.getName()); } if (!myField .getDataType().isValueCompatible(value)) { throw new IllegalArgumentException( "Incompatible data types. Got " + value.getDataType() + ", expected " + myField.getDataType()); } if (myField.getId() != field.getId()) { throw new IllegalArgumentException( "Inconsistent field: " + field); } int index = values.getIndexOfKey(field.getId()); if (index == -1) { values.put(field.getId(), value); invalidateOrder(); } else { values.setValue(index, value); } }