@Override public FieldValue applyTo(FieldValue fval) { if (value == null) return null; fval.assign(value); return fval; }
private static FieldValue wrapValue(DataType type, Object val) { if (val == null) { return null; } if (val instanceof FieldValue) { return (FieldValue)val; } FieldValue ret = type.createFieldValue(); ret.assign(val); return ret; }
@Override public ModificationStatus doModify(FieldValue fieldVal) { doModifyCalled = true; prevVal = fieldVal.clone(); fieldVal.assign(nextVal); return ModificationStatus.MODIFIED; } }
@Override public FieldValue applyTo(FieldValue oldValue) { if (oldValue instanceof NumericFieldValue) { Number number = (Number) oldValue.getWrappedValue(); oldValue.assign(calculate(number)); } else { throw new IllegalStateException("Cannot use arithmetic value update on non-numeric datatype "+oldValue.getClass().getName()); } return oldValue; }
private static FieldValue readReferenceFieldValue(final String refText, DataType expectedType) { final FieldValue value = expectedType.createFieldValue(); if (!refText.isEmpty()) { value.assign(new DocumentId(refText)); } return value; } }
@Override public ModificationStatus doModify(FieldValue fv) { if (!fv.getDataType().equals(newValue.getDataType())) { throw new IllegalArgumentException("Trying to assign " + newValue + " of type " + newValue.getDataType() + " to an instance of " + fv.getDataType()); } else { if (removeIfZero && (newValue instanceof NumericFieldValue) && ((NumericFieldValue)newValue).getNumber().longValue() == 0) { return ModificationStatus.REMOVED; } fv.assign(newValue); } return ModificationStatus.MODIFIED; }
@Override public ModificationStatus doModify(FieldValue fv) { if (fv instanceof NumericFieldValue) { Map<String, Object> vars = new HashMap<String, Object>(); for (Map.Entry<String, IndexValue> entry : getVariables().entrySet()) { if (entry.getValue().getKey() != null && entry.getValue().getKey() instanceof NumericFieldValue) { vars.put(entry.getKey(), ((NumericFieldValue)entry.getValue().getKey()).getNumber()); } else { vars.put(entry.getKey(), entry.getValue().getIndex()); } } vars.put("value", ((NumericFieldValue)fv).getNumber()); try { Number d = calc.evaluate(doc, vars); if (removeIfZero && d.longValue() == 0) { return ModificationStatus.REMOVED; } else { fv.assign(calc.evaluate(doc, vars)); } } catch (IllegalArgumentException e) { // Ignore divide by zero return ModificationStatus.NOT_MODIFIED; } } else { throw new IllegalArgumentException("Trying to perform arithmetic on " + fv + " of type " + fv.getDataType()); } return ModificationStatus.MODIFIED; }
/** * Creates a new FieldValue of this type, with the given value. * * @param arg the value of the new FieldValue * @return a new FieldValue of this type, with the given value */ public FieldValue createFieldValue(Object arg) { if (arg == null) { return createFieldValue(); } FieldValue val = createByReflection(arg); if (val == null) { val = createFieldValue(); if (val != null) { val.assign(arg); } } return val; }
@Override protected void checkCompatibility(DataType fieldType) { if (fieldType instanceof ArrayDataType) { if (!(value instanceof IntegerFieldValue)) { throw new IllegalArgumentException("Expected integer, got " + value.getClass().getName() + "."); } update.checkCompatibility(((ArrayDataType)fieldType).getNestedType()); } else if (fieldType instanceof WeightedSetDataType) { ((WeightedSetDataType)fieldType).getNestedType().createFieldValue().assign(value); update.checkCompatibility(DataType.INT); } else if (fieldType instanceof StructuredDataType) { if (!(value instanceof StringFieldValue)) { throw new IllegalArgumentException("Expected string, got " + value.getClass().getName() + "."); } Field field = ((StructuredDataType)fieldType).getField(((StringFieldValue)value).getString()); if (field == null) { throw new IllegalArgumentException("Field '" + value + "' not found."); } update.checkCompatibility(field.getDataType()); } else { throw new UnsupportedOperationException("Field type " + fieldType.getName() + " not supported."); } }
/** * Sets the value of the given field. The type of the value must match the type of this field, i.e. * <pre>field.getDataType().getValueClass().isAssignableFrom(value.getClass())</pre> must be true. * * @param field The field whose value to set. * @param value The value to set. * @return The previous value of the field, or null. * @throws IllegalArgumentException If the value is not compatible with the field. */ public FieldValue setFieldValue(Field field, FieldValue value) { if (value == null) { return removeFieldValue(field); } DataType type = field.getDataType(); if (!type.getValueClass().isAssignableFrom(value.getClass())) { FieldValue tmp = type.createFieldValue(); tmp.assign(value); value = tmp; } FieldValue ret = getFieldValue(field); doSetFieldValue(field, value); return ret; }
public static FieldPath buildFieldPath(String remainFieldName, DataType keyType, DataType valueType) { if (remainFieldName.length() > 0 && remainFieldName.charAt(0) == '{') { FieldPathEntry.KeyParseResult result = FieldPathEntry.parseKey(remainFieldName); String keyValue = result.parsed; FieldPath path = valueType.buildFieldPath(skipDotInString(remainFieldName, result.consumedChars - 1)); List<FieldPathEntry> tmpPath = new ArrayList<FieldPathEntry>(path.getList()); if (remainFieldName.charAt(1) == '$') { tmpPath.add(0, FieldPathEntry.newVariableLookupEntry(keyValue.substring(1), valueType)); } else { FieldValue fv = keyType.createFieldValue(); fv.assign(keyValue); tmpPath.add(0, FieldPathEntry.newMapLookupEntry(fv, valueType)); } return new FieldPath(tmpPath); } else if (remainFieldName.startsWith("key")) { FieldPath path = keyType.buildFieldPath(skipDotInString(remainFieldName, 2)); List<FieldPathEntry> tmpPath = new ArrayList<FieldPathEntry>(path.getList()); tmpPath.add(0, FieldPathEntry.newAllKeysLookupEntry(keyType)); return new FieldPath(tmpPath); } else if (remainFieldName.startsWith("value")) { FieldPath path = valueType.buildFieldPath(skipDotInString(remainFieldName, 4)); List<FieldPathEntry> tmpPath = new ArrayList<FieldPathEntry>(path.getList()); tmpPath.add(0, FieldPathEntry.newAllValuesLookupEntry(valueType)); return new FieldPath(tmpPath); } return keyType.buildFieldPath(remainFieldName); }
/** * 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; } }