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; }
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(); }
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 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; }
continue; } else if (field instanceof OneToManyAssociation) { NakedCollection collection = (NakedCollection) field.get(object); if (collection == null) { throw new ObjectPersistenceException("Collection " + field.getName() + " does not exist in " Naked fieldValue = field.get(object); if (fieldValue == null) { continue;
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 init(final NakedObject element) { Naked refTo = field.get(element); title = refTo == null ? null : refTo.titleString(); title = title == null ? "" : title; }
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) { NakedObject reference = (NakedObject) field.get(object); resolveImmediately(reference); }
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 addField(final View view, final NakedObject object, final NakedObjectField field) { Naked value = field.get(object); View fieldView = createFieldView(view, object, field, value); if (fieldView != null) { view.addView(decorateSubview(fieldView)); } }
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); }
public void resolveField(final NakedObject object, final NakedObjectField field) throws ObjectPersistenceException { NakedReference reference = (NakedReference) field.get(object); NakedObjectsContext.getObjectLoader().start(reference, ResolveState.RESOLVING); NakedObjectsContext.getObjectLoader().end(reference); }
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 addField(final View view, final NakedObject object, final NakedObjectField field) { Naked value = field.get(object); View fieldView; fieldView = createFieldView(view, object, field, value); if (fieldView != null) { view.addView(decorateSubview(fieldView)); } else { view.addView(new FieldErrorView("No field for " + value)); } }
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 DateValue findDate(View view) { Content c = view.getContent(); Naked adapter = c.getNaked(); NakedObjectSpecification spec = adapter.getSpecification(); NakedObjectField[] fields = spec.getFields(); DateValue date = null; for (int j = 0; j < fields.length; j++) { Naked field = fields[j].get((NakedObject) adapter); if (field instanceof DateValue) { return (DateValue) field; } /* if(fields[j].getSpecification() == NakedObjectsContext.getReflector().loadSpecification(DateValue.class)) { date = (DateValue) fields[j].get((NakedObject) adapter).getObject(); break; } */ } return date; } }
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(); } }
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);
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(); } }