public boolean accept(NakedObjectField f) { return f.isValue(); } };
public Content createFieldContent(final NakedObjectField field, final NakedObject object, final Naked value) { Content content1; if (field instanceof OneToManyAssociation) { content1 = new OneToManyFieldImpl(object, (NakedCollection) value, (OneToManyAssociation) field); } else if (field.isValue()) { content1 = new ValueFieldImpl(object, (NakedValue) value, (ValueAssociation) field); } else if (field instanceof OneToOneAssociation) { content1 = new OneToOneFieldImpl(object, (NakedObject) value, (OneToOneAssociation) field); } else { throw new NakedObjectRuntimeException(); } return content1; }
public boolean canDisplay(final Content content) { if (content.isCollection()) { NakedCollection coll = (NakedCollection) ((CollectionContent) content).getCollection(); NakedObjectSpecification elementSpecification = coll.getElementSpecification(); NakedObjectField[] fields = elementSpecification.getStaticallyVisibleFields(); for (int i = 0; i < fields.length; i++) { if (fields[i].isObject() || fields[i].isValue()) { return true; } } return false; } else { return false; } }
/** * Check which classes/interfaces are used in associations, and mark them */ private void checkAssociations() { // make an array as we may modify the classes map, which would cause an exception in an iterator final PersistentNakedClass[] persistentClasses = classes.values().toArray(new PersistentNakedClass[0]); for (int i = 0; i < persistentClasses.length; i++) { final NakedObjectField[] fields = persistentClasses[i].getSpecification().getFields(); for (int j = 0; j < fields.length; j++) { final NakedObjectField field = fields[j]; if (field.isValue() || !field.isPersisted() || Features.isService(field.getSpecification()) || field.getSpecification().getFullName().startsWith("java.")) { continue; } // object or collection - for both getSpecification returns the spec of the associated object final String associatedClassName = field.getSpecification().getFullName(); if (!classes.containsKey(associatedClassName) && !interfaces.containsKey(associatedClassName)) { // enforce class must be in classes or interface maps throw new NakedObjectRuntimeException("Missing class/interface: " + field.getSpecification().getFullName()); } // if it's a class add a reference PersistentNakedClass associatedClass = classes.get(associatedClassName); if (associatedClass != null) { associatedClass.addReference(); } } } }
private void checkInverseAssociations() { for (Iterator<PersistentNakedClass> iter = classes.values().iterator(); iter.hasNext();) { PersistentNakedClass persistentClass = iter.next(); NakedObjectField[] fields = persistentClass.getUniqueFields(); for (int i = 0; i < fields.length; i++) { if (fields[i].isValue() || !fields[i].isPersisted()) { continue; } PersistentNakedClass associatedClass = getPersistentClass(fields[i].getSpecification().getFullName()); if (associatedClass == null) { continue; } String inverse = getInverse(persistentClass, fields[i].getId()); if (inverse != null) { NakedObjectField associatedField = associatedClass.getSpecification().getField(inverse); Association association = new Association(associatedClass, associatedField, false); persistentClass.addAssociation(fields[i].getId(), association); Association reverseAssociation = new Association(persistentClass, fields[i], true); associatedClass.addAssociation(inverse, reverseAssociation); } } } }
public void resolveField(final NakedObject object, final NakedObjectField field) { if (field.isValue()) { return; } NakedReference reference = (NakedReference) field.get(object); if (reference != null && reference.getResolveState().isResolved()) { return; } if (reference == null || !reference.getResolveState().isPersistent()) { return; } LOG.info("resolve-eagerly on server " + object + "/" + field.getId()); Data data = connection.resolveField(NakedObjectsContext.getSession(), encoder.createIdentityData(object), field.getId()); encoder.restore(data); }
public void resolveField(final NakedObject object, final NakedObjectField field) { if (field.isValue()) { return; } NakedReference reference = (NakedReference) field.get(object); if (reference == null || reference.getResolveState().isResolved()) { return; } if (!reference.getResolveState().isPersistent()) { return; } if (LOG.isInfoEnabled()) { // don't log object - it's toString() may use the unresolved field or unresolved collection LOG.info("resolve field " + object.getSpecification().getShortName() + "." + field.getId() + ": " + reference.getSpecification().getShortName() + " " + reference.getResolveState().code() + " " + reference.getOid()); } objectStore.resolveField(object, field); }
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); } }
final NakedObjectField field = uniqueFields[i]; if (field.isValue() || !field.isPersisted() || thisPersistentClass.hasAssociation(field.getId())) { continue;
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; }
private void createFieldData(final NakedObject object, ObjectData data, NakedObjectField field) { Object fieldData; if (field.isCollection()) { NakedCollection coll = (NakedCollection) field.get(object); fieldData = createCollectionData(coll); } else if (field.isObject()) { NakedObject ref = (NakedObject) ((OneToOneAssociation) field).get(object); fieldData = createReferenceData(ref); } else if (field.isValue()) { NakedValue value = (NakedValue) field.get(object); fieldData = value.asEncodedString(); } else { throw new UnknownTypeException(field); } data.addField(field.getId(), fieldData); }
} else if (field.isValue()) { final String fieldId = field.getId(); if ((fieldId.equals("id") && field.getId().equals("id")) || fieldId.equals(versionId)
if (!field.isPersisted()) { continue; } else if (field.isValue()) { continue; } else if (field instanceof OneToManyAssociation) {
View subview = subviews[i]; Naked value = field.get(object); if (field.isValue()) { boolean visiblityChange = !field.isVisible(object) ^ (subview instanceof BlankView); Naked naked = subview.getContent().getNaked();
if (field instanceof OneToManyAssociation) { throw new UnexpectedCallException("no collections allowed"); } else if (field.isValue()) { content = new ValueFieldImpl(object, (NakedValue) value, (ValueAssociation) field); if (content.getNaked() instanceof ImageValue) {
if (!field.isPersisted()) { continue; } else if (field.isValue()) { continue; } else if (field instanceof OneToManyAssociation) {
public void execute(final Workspace workspace, final View view, final Location at) { NakedObject original = (NakedObject) view.getContent().getNaked(); // NakedObject original = getObject(); NakedObjectSpecification spec = original.getSpecification(); NakedObject clone = NakedObjectsContext.getObjectLoader().createTransientInstance(spec); NakedObjectField[] fields = spec.getFields(); for (int i = 0; i < fields.length; i++) { Naked fld = fields[i].get(original); if (fields[i].isObject()) { ((OneToOneAssociation) fields[i]).setAssociation(clone, (NakedObject) fld); } else if (fields[i].isValue()) { ((ValueAssociation) fields[i]).setValue(clone, (NakedValue) fld); } else if (fields[i].isCollection()) { // clone.setValue((OneToOneAssociation) fields[i], fld.getObject()); } } // AbstractNakedObject clone = (AbstractNakedObject) createInstance(getClass()); // clone.copyObject(this); // clone.objectChanged(); Content content = Toolkit.getContentFactory().createRootContent(clone); View cloneView = Toolkit.getViewFactory().createWindow(content); cloneView.setLocation(at); workspace.addView(cloneView); // newWorkspace.markDamaged(); } }
private void initObject(final NakedObject object, final ObjectData data) { if (object.getResolveState().isResolvable(ResolveState.RESOLVING)) { objectLoader().start(object, ResolveState.RESOLVING); NakedObjectField[] fields = object.getSpecification().getFields(); for (int i = 0; i < fields.length; i++) { NakedObjectField field = fields[i]; if (!field.isPersisted()) { continue; } if (field.isValue()) { NakedValue value = (NakedValue) ((ValueAssociation) field).get(object); String valueData = data.value(field.getId()); value.restoreFromEncodedString(valueData == null ? "NULL" : valueData); ((ValueAssociation) field).initValue(object, value); } else if (field.isCollection()) { initObjectSetupCollection(object, data, field); } else if (field.isObject()) { initObjectSetupReference(object, data, field); } } object.setOptimisticLock(data.getVersion()); objectLoader().end(object); } }