public void parseTextEntry(final String entryText) { String existingEntry = valueAdapter.asEncodedString(); valueAdapter.parseTextEntry(entryText); Consent valid = ((ValueAssociation) getField()).isValueValid(getParent(), valueAdapter); if (valid.isVetoed()) { valueAdapter.restoreFromEncodedString(existingEntry); throw new InvalidEntryException(valid.getReason()); } if (getValueAssociation().isMandatory() && valueAdapter.isEmpty()) { valueAdapter.restoreFromEncodedString(existingEntry); throw new InvalidEntryException("Mandatory field cannot be empty"); } }
protected String asString(NakedValue arg) { return (String)arg.getObject(); }
public void testDecodeNULL() throws Exception { value.restoreFromEncodedString("NULL"); assertTrue(value.isEmpty()); }
public ObjectData[] setValue( final Session session, final String fieldIdentifier, final IdentityData target, final ValueData value) { Assert.assertNotNull(value); LOG.debug("request setValue " + fieldIdentifier + " on " + target + " with " + value + " for " + session); NakedObject inObject = getPersistentNakedObject(session, target); ValueAssociation association = (ValueAssociation) inObject.getSpecification().getField(fieldIdentifier); if (!association.isVisible() || association.isUsable(inObject).isVetoed()) { throw new IllegalRequestException("can't modify field as not visible or editable"); } NakedValue fieldValue = (NakedValue) association.get(inObject); if (fieldValue != null) { // /byte[] encodedString = // NakedObjectsContext.getObjectLoader().createAdapterForValue(value).asEncodedString(); fieldValue.restoreFromEncodedString(value.getEncodedValue()); } NakedValue valueAdapter = NakedObjectsContext.getObjectLoader().createValueInstance(association.getSpecification()); valueAdapter.restoreFromEncodedString(value.getEncodedValue()); association.setValue(inObject, valueAdapter); return getUpdates(); }
public boolean isEmpty() { return object.isEmpty(); }
public void testEncode() throws Exception { assertEquals("NULL", value.asEncodedString()); }
public void testParseEmptyString() throws Exception { value.parseTextEntry(""); assertTrue(value.isEmpty()); }
public void clear() { object.clear(); }
public String title() { return object.titleString(); }
public void parseTextEntry(final String entryText) { object.parseTextEntry(entryText); }
public Consent disabled(final View view) { NakedValue value = getValue(view); ValueContent field = (ValueContent) view.getContent(); Consent changable = view.canChangeValue(); if (changable.isVetoed()) { return changable; } else if (!field.canClear()) { return new Veto("Can't clear " + value.getSpecification().getShortName() + " values"); } else if (isEmpty(view)) { return new Veto("Field is already empty"); } else { return new Allow("Clear value " + value.titleString()); } }
private void updateField(final NakedObject object, ObjectData od, NakedObjectField field) { Object fieldData = od.getEntry(field.getId()); if (field.isCollection()) { updateOneToManyAssociation(object, (OneToManyAssociation) field, (CollectionData) fieldData); } else if (field.isObject()) { updateOneToOneAssociation(object, (OneToOneAssociation) field, (Data) fieldData); } else if (field.isValue()) { NakedValue value = NakedObjectsContext.getObjectLoader().createValueInstance(field.getSpecification()); value.restoreFromEncodedString((String) fieldData); ((ValueAssociation) field).initValue(object, value); } }
/** * Checks that the argument has been specified, or, if not then the value * is specified as optional. */ public String check( Naked[] values) { final NakedValue argument = getArgument(values); return (!argument.isEmpty() || hasAnnotation(getValueAssociationInstance(), OptionalAnnotation.class))?null:"Mandatory"; }
private ObjectData createObjectData(final NakedObject object, final boolean ensurePersistent) { LOG.debug("compiling object data for " + object); ObjectData data; data = new ObjectData(object.getSpecification(), (SerialOid) object.getOid(), (FileVersion) object.getVersion()); NakedObjectField[] fields = object.getSpecification().getFields(); for (int i = 0; i < fields.length; i++) { if (!fields[i].isPersisted()) { continue; } Naked field = fields[i].get(object); Naked fieldContent = field; String fieldId = fields[i].getId(); if (fields[i].isCollection()) { data.addInternalCollection((NakedCollection) fieldContent, fieldId, ensurePersistent); } else if (fields[i].isValue()) { boolean isEmpty = fields[i].isEmpty(object); String encodedValue = ((NakedValue) field).asEncodedString(); data.saveValue(fieldId, isEmpty, field == null || isEmpty ? null : new String(encodedValue)); } else if (fields[i].isObject()) { data.addAssociation((NakedObject) fieldContent, fieldId, ensurePersistent); } } return data; }
public void clear() { valueAdapter.clear(); }
public String toString() { return (valueAdapter == null ? "null" : valueAdapter.titleString()) + "/" + getField(); }
public void testParseEmptyString() throws Exception { try { value.parseTextEntry(""); fail(); } catch (InvalidEntryException expected) {} }
/** * Whether the provided argument (expected to be a {@link NakedValue}) * exceeds the {@link #value() maximum length}. */ public boolean violatedBy( Naked argNaked) { if (argNaked == null) { return true; } if (!(argNaked instanceof NakedValue)) { return true; } NakedValue argNakedValue = (NakedValue) argNaked; Object arg = argNakedValue.getObject(); if (!(arg instanceof String)) { return true; } String argStr = (String) arg; boolean violated = argStr != null && argStr.length() > value(); return violated; }
private Naked[] getParameters(final Session session, final Data[] parameterData, final KnownObjects knownObjects) { Naked[] parameters = new Naked[parameterData.length]; for (int i = 0; i < parameters.length; i++) { Data data = parameterData[i]; if (data instanceof NullData) { continue; } if (data instanceof IdentityData) { parameters[i] = getPersistentNakedObject(session, (IdentityData) data); } else if (data instanceof ObjectData) { parameters[i] = encoder.restore((ObjectData) data, knownObjects); } else if (data instanceof ValueData) { NakedObjectSpecification valueSpecification = NakedObjectsContext.getReflector() .loadSpecification(data.getType()); NakedValue value = NakedObjectsContext.getObjectLoader().createValueInstance(valueSpecification); String valueData = ((ValueData) data).getEncodedValue(); value.restoreFromEncodedString(valueData); parameters[i] = value; } else { throw new UnknownTypeException(data); } } return parameters; }