/** * 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); }
private Class getReturnType(final NakedObjectField field, final NakedObjectSpecification spec) { final Method getMethod = extractPublicGetMethod(spec, field.getId()); if (getMethod == null) { throw new NakedObjectRuntimeException("Cannot find get method for collection " + field.getId() + " in spec " + spec); } return getMethod.getReturnType(); }
/** * Log a warning if we map to a Hibernate Any association, but don't log Objects field in Perspective * objects as these are known to be Any associations (it is a collection of any object within the system * after all). */ private void warnAnyAssociation(final PersistentNakedClass persistentNakedClass, final NakedObjectField field) { LOG.info("Binding persistent association as an ANY association! [class=" + persistentNakedClass.getName() + ", field=" + field.getId() + "]"); }
private NakedObjectField fieldFromActualSpec(NakedObjectSpecification spec, NakedObjectField field) { String fieldName = field.getId(); return spec.getField(fieldName); }
public Naked getField(final NakedObjectField field) { return (Naked) fieldContents.get(field.getId()); }
public Naked getField(final NakedObjectField field) { return (Naked) fieldContents.get(field.getId()); }
private void ensureUniqueFieldsResolved() { if (uniqueFields != null) { return; } if (parent.isRoot()) { uniqueFields = spec.getFields(); return; } final NakedObjectField[] parentFields = parent.getSpecification().getFields(); final HashMap<String, String> parentIds = new HashMap<String, String>(); for (int i = 0; i < parentFields.length; i++) { if (parentFields[i].isPersisted()) { parentIds.put(parentFields[i].getId(), ""); } } final List<NakedObjectField> uniqueList = new ArrayList<NakedObjectField>(); final NakedObjectField[] fields = spec.getFields(); for (int i = 0; i < fields.length; i++) { if (!parentIds.containsKey(fields[i].getId())) { uniqueList.add(fields[i]); } } uniqueFields = uniqueList.toArray(new NakedObjectField[0]); }
public NakedObjectField getField(final String name) { for (int i = 0; i < fields.length; i++) { if (fields[i].getId().equals(name)) { return fields[i]; } } throw new NakedObjectRuntimeException("Field not found: " + name); }
public NakedObjectField getField(final String name) { for (int i = 0; i < fields.length; i++) { if (fields[i].getId().equals(name)) { return fields[i]; } } throw new NakedObjectRuntimeException("Field not found: " + name); }
private void dumpObjectData(final StringBuffer str, final Data data, final int indent, final Vector complete) { ObjectData objectData = ((ObjectData) data); str.append("ObjectData@" + Integer.toHexString(objectData.hashCode()) + " " + objectData.getType() + ":" + objectData.getOid() + ":" + (objectData.hasCompleteData() ? "C" : "-") + ":" + objectData.getVersion()); if (complete.contains(objectData)) { str.append(" (already detailed)"); return; } complete.addElement(objectData); NakedObjectSpecification spec = NakedObjectsContext.getReflector().loadSpecification(data.getType()); NakedObjectField[] fs = encoder.getFieldOrder(spec); Object[] fields = objectData.getFieldContent(); for (int i = 0; fields != null && i < fields.length; i++) { str.append("\n"); str.append(padding(indent)); str.append(i + 1); str.append(") "); str.append(fs[i].getId()); str.append(": "); dump(str, (Data) fields[i], indent + 1, complete); } }
/** * Create an assocation using an any mapping. */ private void bindAnyAssociation(final Element anyElement, final NakedObjectField field) { addIdType(field.getSpecification(), anyElement, "id-type", false, false); anyElement.addElement("column").addAttribute("name", deconflictColumnName(field.getId() + "type")); anyElement.addElement("column").addAttribute("name", deconflictColumnName(field.getId() + PRIMARY_KEY_SUFFIX)); return; }
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 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); } } } }
private void bindProperty(final NakedObjectField field, final Element classElement, final boolean valueFieldAccess) { LOG.debug("Binding persistent property [" + field.getId() + "]"); final Element property = classElement.addElement("property"); setType(field, property, "type", true, valueFieldAccess); final Attribute access = property.attribute("access"); final boolean fieldAccess = access != null && access.getStringValue().equals("field"); property.addAttribute("name", getPropertyName(field, fieldAccess)); final org.hibernate.type.Type type = TypeFactory.heuristicType(property.attribute("type").getValue(), null); if (type instanceof CompositeCustomType) { final String[] names = ((CompositeCustomType) type).getPropertyNames(); for (int i = 0; i < names.length; i++) { final String compositeColumnName = deconflictColumnName(columnName(field.getId()) + "_" + names[i]); property.addElement("column").addAttribute("name", compositeColumnName); } } else { addColumnAttribute(property, columnName(field.getId())); } }
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); } }
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); }
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); } } }
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); }
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); } }