public boolean accept(NakedObjectField f) { return f.isCollection(); } };
private void setupReferencedObjects(final NakedObject object, final Vector all) { if (true) return; if (object == null || all.contains(object)) { return; } all.addElement(object); NakedObjectsContext.getObjectLoader().start(object, ResolveState.RESOLVING); NakedObjectField[] fields = object.getSpecification().getFields(); for (int i = 0; i < fields.length; i++) { NakedObjectField field = fields[i]; if (field.isCollection()) { NakedCollection col = (NakedCollection) field.get(object); for (Enumeration e = col.elements(); e.hasMoreElements();) { NakedObject element = (NakedObject) e.nextElement(); setupReferencedObjects(element, all); } } else if (field.isObject()) { NakedObject fieldContent = (NakedObject) field.get(object); setupReferencedObjects(fieldContent, all); } } NakedObjectsContext.getObjectLoader().end(object); }
private String debugObjectGraph(final NakedObject object, final int level, final Vector recursiveElements) { StringBuffer s = new StringBuffer(); recursiveElements.addElement(object); // work through all its fields NakedObjectField[] fields; fields = object.getSpecification().getFields(); for (int i = 0; i < fields.length; i++) { NakedObjectField field = fields[i]; Object obj = field.get(object); String id = field.getId(); indent(s, level); if (field.isCollection()) { s.append(id + ": \n" + debugCollectionGraph((NakedCollection) obj, level + 1, recursiveElements)); } else { if (obj instanceof NakedObject) { if (recursiveElements.contains(obj)) { s.append(id + ": " + obj + "*\n"); } else { s.append(id + ": " + obj); s.append(debugGraph((NakedObject) obj, level + 1, recursiveElements)); } } else { s.append(id + ": " + obj); s.append("\n"); } } } return s.toString(); }
/** * Return the one, and only one association from this persistent class to the associated class. */ public NakedObjectField getUniqueAssociation(final String associatedClassName) { ensureUniqueFieldsResolved(); NakedObjectField association = null; for (int i = 0; i < uniqueFields.length; i++) { if (uniqueFields[i].isObject() || uniqueFields[i].isCollection()) { if (associatedClassName.equals(uniqueFields[i].getSpecification().getFullName())) { if (association != null) { return null; } association = uniqueFields[i]; } } } return association; }
public void resolveField(final NakedObject object, final NakedObjectField field) { ensureMapped(object); if (field.isObject() || field.isCollection()) { ensureMapped(field.getSpecification()); } wrapped.resolveField(object, field); }
public void resolveField(final NakedObject object, final NakedObjectField field) { if (field.isCollection()) { NakedCollection collection = (NakedCollection) field.get(object); NakedObjectsContext.getObjectLoader().start(collection, ResolveState.RESOLVING); NakedObjectsContext.getObjectLoader().end(collection); } else { throw new UnexpectedCallException(); } }
/** * This is only used to control root nodes. Therefore a object tree can only be displayed for an object * with fields that are collections. */ public boolean canDisplay(final Content content) { if (content.isObject() && content.getNaked() != null) { NakedObject object = (NakedObject) content.getNaked(); NakedObjectField[] fields = object.getSpecification().getDynamicallyVisibleFields(object); for (int i = 0; i < fields.length; i++) { if (fields[i].isCollection()) { return true; } } } return false; }
public int canOpen(final Content content) { NakedObject object = ((ObjectContent) content).getObject(); NakedObjectField[] fields = object.getSpecification().getDynamicallyVisibleFields(object); for (int i = 0; i < fields.length; i++) { if (fields[i].isCollection()) { return CAN_OPEN; } if (showObjectContents && fields[i].isObject() && !(Features.isBoundedSet(object.getSpecification()))) { return CAN_OPEN; } } return CANT_OPEN; }
Naked attribute = field.get(object); if (field.getId().equals("objects") && field.isCollection()) { Enumeration elements = ((NakedCollection) attribute).elements(); while (elements.hasMoreElements()) { Naked attribute = field.get(object); if (field.getId().equals("services") && field.isCollection()) { NakedObjectsContext.getObjectPersistor().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); } }
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); }
continue; if (field.isCollection()) { bindCollection(classElement, persistentNakedClass, field, associationFieldAccess); } else if (field.isObject()) {
} else if (field.isValue()) { continue; } else if (field.isCollection()) { } else if (field.isValue()) { continue; } else if (field.isCollection()) { NakedCollection collection = (NakedCollection) field.get(object); makePersistent(collection, persistor);
public void resolveField(final NakedObject object, final NakedObjectField field) { LOG.debug("resolveField id=" + object.getOid() + ", field=" + field.getId()); if (field.isObject()) { final NakedObject adapter = (NakedObject) field.get(object); initializeField(object.getObject(), adapter.getObject()); } else if (field.isCollection()) { final NakedCollection collectionAdapter = (NakedCollection) field.get(object); // can sometimes be called if collection is already resolved! e.g. // BasicPerpsective.services if (!collectionAdapter.getResolveState().isResolved()) { NakedObjectsContext.getObjectLoader().start(collectionAdapter, ResolveState.RESOLVING); final Object collection = collectionAdapter.getObject(); initializeField(object.getObject(), collection); NakedObjectsContext.getObjectLoader().end(collectionAdapter); } } }
} else if (field.isValue()) { continue; } else if (field.isCollection()) {
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); } }
subview.refresh(); } else if (field.isCollection()) { subview.update(value); } else if (field.isObject()) {