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 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); }
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 resolveField(final NakedObject object, final NakedObjectField field) { ensureMapped(object); if (field.isObject() || field.isCollection()) { ensureMapped(field.getSpecification()); } wrapped.resolveField(object, field); }
for (int i = 0; i < fields.length; i++) { NakedObjectField field = fields[i]; if (!field.isPersisted()) { continue; } else if (field.isValue()) { continue; } else if (field.isCollection()) { Naked fieldValue = field.get(object); if (fieldValue == null) { continue; if (!field.isPersisted()) { continue; } else if (field.isValue()) { continue; } else if (field.isCollection()) { NakedCollection collection = (NakedCollection) field.get(object); makePersistent(collection, persistor); Enumeration elements = collection.elements();
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); }
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(); }
/** * Get the property name for the field * * @param field * @param fieldAccess */ private String getPropertyName(final NakedObjectField field, final boolean fieldAccess) { String name = field.getId().replace(" ", ""); if (fieldAccess) { name = fieldPrefix + name; } // use same method as Hibernate return Introspector.decapitalize(name); }
/** * 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()); }
NakedObjectField field = fieldFromActualSpec(spec, viewAxis.getFieldForColumn(i)); 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(); boolean valueChange = value != null && value.getObject() != null && !value.getObject().equals(naked.getObject()); } 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()); } }
eachField: for (int i = 0; i < fields.length; i++) { NakedObjectField field = fields[i]; String fieldName = field.getId(); if (field.isValue()) { LOG.debug("objectToElement(NO): " + log("field", fieldName) + " is value"); NakedObjectSpecification fieldNos = field.getSpecification();
/** * 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(); } } } }
public int compare(final NakedObject sortedElement) { Naked refTo = field.get(sortedElement); String sortedTitle = refTo == null ? null : refTo.titleString(); sortedTitle = sortedTitle == null ? "" : sortedTitle; int compareTo = sortedTitle.compareTo(title); return compareTo; }
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; }
private void initObjectSetupReference(final NakedObject object, final ObjectData data, final NakedObjectField field) { SerialOid referenceOid = (SerialOid) data.get(field.getId()); LOG.debug("setting up field " + field + " with " + referenceOid); if (referenceOid == null) { NakedObject adapter = NakedObjectsContext.getObjectLoader().recreateAdapterForPersistent(referenceOid, field.getSpecification()); if (!adapter.getResolveState().isDestroyed()) { adapter.changeState(ResolveState.DESTROYED); LOG.warn("No data found for " + referenceOid + " so field '" + field.getName() + "' not set in object '" + object.titleString() + "'"); } else {
Vector xmlFieldElements = elementsUnder(xmlElement, field.getId()); if (xmlFieldElements.size() != 1) { LOG.info("includeField(Pl, Vec, Str): could not locate " + log("field", field.getId()) + andlog("xmlFieldElements.size", "" + xmlFieldElements.size())); return false; if (field.isValue()) { LOG.debug("includeField(Pl, Vec, Str): field is value; done"); return false;
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 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(); } }
private void initObjectSetupCollection(final NakedObject object, final ObjectData data, final NakedObjectField field) { /* * The internal collection is already a part of the object, and therefore cannot be recreated, but its * oid must be set */ ReferenceVector refs = (ReferenceVector) data.get(field.getId()); NakedCollection collection = (NakedCollection) field.get(object); NakedObjectsContext.getObjectLoader().start(collection, ResolveState.RESOLVING); int size = refs == null ? 0 : refs.size(); NakedObject[] elements = new NakedObject[size]; for (int j = 0; j < size; j++) { SerialOid elementOid = refs.elementAt(j); NakedObject adapter; if (objectLoader().isIdentityKnown(elementOid)) { adapter = objectLoader().getAdapterFor(elementOid); } else { adapter = getObject(elementOid, null); } elements[j] = adapter; } ((OneToManyAssociation) field).initCollection(object, elements); NakedObjectsContext.getObjectLoader().end(collection); }