public boolean accept(NakedObjectField f) { return f.isObject(); } };
/** * 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; }
private View createFieldView(final View view, final NakedObject object, final NakedObjectField field, final Naked value) { if (field == null) { throw new NullPointerException(); } if (field.isObject()) { NakedObjectsContext.getObjectPersistor().resolveField(object, field); } Content content1 = Toolkit.getContentFactory().createFieldContent(field, object, value); View fieldView = subviewDesign.createSubview(content1, view.getViewAxis()); return fieldView; } }
public void resolveField(final NakedObject object, final NakedObjectField field) { ensureMapped(object); if (field.isObject() || field.isCollection()) { ensureMapped(field.getSpecification()); } wrapped.resolveField(object, field); }
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; } }
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; }
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); }
} else if (field.isObject()) { LOG.debug("Binding persistent association [" + field.getId() + "]"); Element assnElement;
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); } } }
if (assn != null) { final NakedObjectField associatedField = assn.getField(); if (associatedField.isObject()) { associationType = "one-to-many"; collElement.addAttribute("inverse", "true");
} else if (field.isObject()) { NakedObject existing = ((ObjectContent) subviews[i].getContent()).getObject(); boolean changedValue = value != existing;
private Consent setFieldOfMatchingType(final NakedObject target, final NakedObject source) { if (target.getResolveState().isTransient() && source.getResolveState().isPersistent()) { return new Veto("Can't set field in persistent object with reference to non-persistent object"); } else { NakedObjectField[] fields = target.getSpecification().getDynamicallyVisibleFields(target); for (int i = 0; i < fields.length; i++) { NakedObjectField fld = fields[i]; if (fld.isObject() && source.getSpecification().isOfType(fld.getSpecification())) { if (fld.get(target) == null && ((OneToOneAssociation) fld).isAssociationValid(target, source).isAllowed()) { return new Allow("Set field " + fld.getName()); } } } return new Veto("No empty field accepting object of type " + source.getSpecification().getSingularName() + " in " + title()); } }
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); } }
public Naked drop(final Content sourceContent) { if (sourceContent instanceof ObjectContent) { NakedObject source = (NakedObject) sourceContent.getNaked(); Assert.assertNotNull(source); NakedObject target = (NakedObject) getObject(); Assert.assertNotNull(target); if (canDrop(sourceContent).isAllowed()) { NakedObjectAction action = dropAction(source, target); if ((action != null) && action.isParameterSetValid(target, new NakedObject[] { source }).isAllowed()) { return action.execute(target, new NakedObject[] { source }); } else { NakedObjectField[] fields = target.getSpecification().getDynamicallyVisibleFields(target); for (int i = 0; i < fields.length; i++) { NakedObjectField fld = fields[i]; if (fld.isObject() && source.getSpecification().isOfType(fld.getSpecification())) { if (fld.get(target) == null && ((OneToOneAssociation) fld).isAssociationValid(target, source).isAllowed()) { ((OneToOneAssociation) fld).setAssociation(target, source); break; } } } } } } return null; }
} else if (field.isObject()) { NakedObject existing = ((ObjectContent) subviews[i].getContent()).getObject(); boolean changedValue = value != existing;
/** * Create a simple assocation (to a class/interface) * * @param persistentNakedClass * @param associationFieldAccess */ private Element bindAssociation( final Element classElement, final PersistentNakedClass persistentNakedClass, final NakedObjectField field, final boolean associationFieldAccess) { final Association assn = persistentNakedClass.getAssociation(field.getId()); if (assn != null && assn.getField().isObject()) { if (assn.isInverse()) { final String FKColumn = deconflictColumnName(FOREIGN_KEY_PREFIX + field.getId()); return classElement.addElement("many-to-one") .addAttribute("name", getPropertyName(field, associationFieldAccess)).addAttribute("column", FKColumn) .addAttribute("class", field.getSpecification().getFullName()).addAttribute("unique", "true"); } else { return classElement.addElement("one-to-one").addAttribute("name", getPropertyName(field, associationFieldAccess)) .addAttribute("class", field.getSpecification().getFullName()).addAttribute("property-ref", getPropertyName(assn.getField(), associationFieldAccess)); } } final String FKColumn = deconflictColumnName(FOREIGN_KEY_PREFIX + field.getId()); return classElement.addElement("many-to-one").addAttribute("name", getPropertyName(field, associationFieldAccess)) .addAttribute("column", FKColumn).addAttribute("class", field.getSpecification().getFullName()); }