@Override public boolean accept(final NakedObjectAssociation property) { return property.isOneToOneAssociation(); } };
@Override public boolean accept(final NakedObjectAssociation property) { return property.isOneToOneAssociation(); } };
public boolean accept(NakedObjectAssociation t) { return t.isOneToManyAssociation() || (t.isOneToOneAssociation() && !((OneToOneAssociation)t).getSpecification().isParseable()); } });
private View createFieldView( final View view, final NakedObject object, final int fieldNumber, final NakedObjectAssociation field) { if (field == null) { throw new NullPointerException(); } if (field.isOneToOneAssociation()) { NakedObjectsContext.getPersistenceSession().resolveField(object, field); } final Content content1 = Toolkit.getContentFactory().createFieldContent(field, object); final View fieldView = subviewDesign.createSubview(content1, view.getViewAxis(), fieldNumber); return fieldView; }
public boolean canDisplay(final Content content, ViewRequirement requirement) { if (!content.isCollection() || !requirement.is(ViewRequirement.OPEN)) { return false; } else { CollectionContent collectionContent = (CollectionContent) content; final NakedObjectSpecification elementSpecification = collectionContent.getElementSpecification(); final NakedObjectAssociation[] fields = elementSpecification .getAssociations(NakedObjectAssociationFilters.STATICALLY_VISIBLE_ASSOCIATIONS); for (int i = 0; i < fields.length; i++) { if (fields[i].isOneToOneAssociation()) { return true; } } return false; } }
private void saveState(final NakedObject targetAdapter, final NakedObject[] entryAdapters) { for (int i = 0; i < fields.length; i++) { final NakedObjectAssociation fld = fields[i]; final NakedObject entryAdapter = entryAdapters[i]; final boolean isReadOnly = readOnly[i]; if (isReadOnly) { continue; } if (fld.isOneToOneAssociation()) { final OneToOneAssociation oneToOneAssociation = ((OneToOneAssociation) fld); final Object entryPojo = NakedObjectUtils.unwrap(entryAdapter); if (entryPojo == null) { if (oneToOneAssociation.get(targetAdapter) != null) { oneToOneAssociation.clearAssociation(targetAdapter); } } else { final NakedObject currentAdapter = oneToOneAssociation.get(targetAdapter); final Object currentPojo = NakedObjectUtils.unwrap(currentAdapter); if (currentAdapter == null || currentPojo == null || !currentPojo.equals(entryPojo)) { oneToOneAssociation.setAssociation(targetAdapter, entryAdapter); } } } } }
@Override public void checkForValidity(final Context context) { final NakedObject target = getTarget(context); final NakedObject[] entries = getEntries(context); final int len = fields.length; for (int i = 0; i < len; i++) { if (readOnly[i] || errors[i] != null) { continue; } final NakedObjectAssociation fld = fields[i]; if (fld.isOneToOneAssociation()) { final OneToOneAssociation oneToOneAssociation = (OneToOneAssociation) fld; final NakedObject entryReference = entries[i]; final NakedObject currentReference = oneToOneAssociation.get(target); if (currentReference != entryReference) { final Consent valueValid = ((OneToOneAssociation) fld).isAssociationValid(target, entryReference); errors[i] = valueValid.getReason(); } } } }
@Override public int canOpen(final Content content) { final NakedObject object = ((ObjectContent) content).getObject(); final NakedObjectAssociation[] fields = object.getSpecification().getAssociations( NakedObjectAssociationFilters.dynamicallyVisible(NakedObjectsContext.getAuthenticationSession(), object)); for (int i = 0; i < fields.length; i++) { if (fields[i].isOneToManyAssociation()) { return CAN_OPEN; } if ( showObjectContents && fields[i].isOneToOneAssociation() && !(SpecificationFacets.isBoundedSet(object.getSpecification()))) { return CAN_OPEN; } } return CANT_OPEN; }
private Content fieldContent(Content content) { NakedObjectSpecification spec = content.getSpecification(); NakedObject target = content.getNaked(); AuthenticationSession session = NakedObjectsContext.getAuthenticationSession(); NakedObjectAssociation[] fields = spec.getAssociations(NakedObjectAssociationFilters.dynamicallyVisible(session, target)); for (NakedObjectAssociation field : fields) { if (field.isOneToOneAssociation() && !field.getSpecification().isParseable()) { return Toolkit.getContentFactory().createFieldContent(field, target); } } return null; }
private void updateField(final NakedObject object, final ObjectData od, final NakedObjectAssociation field) { final Object fieldData = od.getEntry(field.getId()); if (field.isOneToManyAssociation()) { updateOneToManyAssociation(object, (OneToManyAssociation) field, (CollectionData) fieldData); } else if (field.getSpecification().containsFacet(EncodableFacet.class)) { final EncodableFacet facet = field.getSpecification().getFacet(EncodableFacet.class); final NakedObject value = facet.fromEncodedString((String) fieldData); ((OneToOneAssociation) field).initAssociation(object, value); } else if (field.isOneToOneAssociation()) { updateOneToOneAssociation(object, (OneToOneAssociation) field, (Data) fieldData); } }
@Override public void checkForValidity(final Context context) { final NakedObject target = getTarget(context); final NakedObject[] entries = getEntries(context); final int len = fields.length; for (int i = 0; i < len; i++) { if (readOnly[i] || errors[i] != null) { continue; } final NakedObjectAssociation fld = fields[i]; if (fld.isOneToOneAssociation()) { final OneToOneAssociation oneToOneAssociation = (OneToOneAssociation) fld; final NakedObject entryReference = entries[i]; final NakedObject currentReference = oneToOneAssociation.get(target); if (currentReference != entryReference) { final Consent valueValid = ((OneToOneAssociation) fld).isAssociationValid(target, entryReference); errors[i] = valueValid.getReason(); } } } if (target.isTransient()) { saveState(target, entries); Consent isValid = target.getSpecification().isValid(target); error = isValid.isVetoed() ? isValid.getReason() : null; } }
private void createFieldData(final NakedObject object, final ObjectData data, final NakedObjectAssociation field) { Object fieldData; if (field.isOneToManyAssociation()) { final NakedObject coll = field.get(object); fieldData = createCollectionData(coll); } else if (field.getSpecification().isEncodeable()) { final EncodableFacet facet = field.getSpecification().getFacet(EncodableFacet.class); final NakedObject value = field.get(object); fieldData = facet.toEncodedString(value); } else if (field.isOneToOneAssociation()) { final NakedObject ref = ((OneToOneAssociation) field).get(object); fieldData = createReferenceData(ref); } else { throw new UnknownTypeException(field); } data.addField(field.getId(), fieldData); }
private Consent setFieldOfMatchingType(final NakedObject targetAdapter, final NakedObject sourceAdapter) { if (targetAdapter.isTransient() && sourceAdapter.isPersistent()) { // TODO: use Facet for this test instead. return new Veto("Can't set field in persistent object with reference to non-persistent object"); } final NakedObjectAssociation[] fields = targetAdapter.getSpecification().getAssociations( NakedObjectAssociationFilters.dynamicallyVisible(NakedObjectsContext.getAuthenticationSession(), targetAdapter)); for (final NakedObjectAssociation fld : fields) { if (!fld.isOneToOneAssociation()) { continue; } if (!sourceAdapter.getSpecification().isOfType(fld.getSpecification())) { continue; } if (fld.get(targetAdapter) != null) { continue; } final Consent associationValid = ((OneToOneAssociation) fld).isAssociationValid(targetAdapter, sourceAdapter); if (associationValid.isAllowed()) { return associationValid.setDescription("Set field " + fld.getName()); } } // TODO: use Facet for this test instead return new Veto(String.format("No empty field accepting object of type %s in %s", sourceAdapter.getSpecification() .getSingularName(), title())); }
if (fld.isOneToOneAssociation()) { final OneToOneAssociation oneToOneAssociation = ((OneToOneAssociation) fld); final NakedObject entryNO = entries[i];
private void initObject(final NakedObject object, final ObjectData data) { if (object.getResolveState().canChangeTo(ResolveState.RESOLVING)) { PersistorUtil.start(object, ResolveState.RESOLVING); final NakedObjectAssociation[] fields = object.getSpecification().getAssociations(); for (int i = 0; i < fields.length; i++) { final NakedObjectAssociation field = fields[i]; if (!field.isPersisted()) { continue; } final NakedObjectSpecification fieldSpecification = field.getSpecification(); if (fieldSpecification.isEncodeable()) { final EncodeableFacet encoder = fieldSpecification.getFacet(EncodeableFacet.class); NakedObject value; final String valueData = data.value(field.getId()); if (valueData == null || valueData.equals("NULL")) { value = null; } else { value = encoder.fromEncodedString(valueData); } ((OneToOneAssociation) field).initAssociation(object, value); } else if (field.isOneToManyAssociation()) { initObjectSetupCollection(object, data, field); } else if (field.isOneToOneAssociation()) { initObjectSetupReference(object, data, field); } } object.setOptimisticLock(data.getVersion()); PersistorUtil.end(object); } }
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()); final NakedObjectAssociation[] fields = object.getSpecification().getAssociations(); for (int i = 0; i < fields.length; i++) { if (!fields[i].isPersisted()) { continue; } final NakedObject field = fields[i].get(object); final NakedObject fieldContent = field; final String fieldId = fields[i].getId(); if (fields[i].isOneToManyAssociation()) { data.addInternalCollection(fieldContent, fieldId, ensurePersistent); } else if (fields[i].getSpecification().isEncodeable()) { final boolean isEmpty = fields[i].isEmpty(object); if (field == null || isEmpty) { data.saveValue(fieldId, isEmpty, null); } else { final EncodeableFacet facet = fieldContent.getSpecification().getFacet(EncodeableFacet.class); final String encodedValue = facet.toEncodedString(fieldContent); data.saveValue(fieldId, isEmpty, encodedValue); } } else if (fields[i].isOneToOneAssociation()) { data.addAssociation(fieldContent, fieldId, ensurePersistent); } } return data; }
@Override public void execute(final Workspace workspace, final View view, final Location at) { final NakedObject original = view.getContent().getNaked(); // NakedObject original = getObject(); final NakedObjectSpecification spec = original.getSpecification(); final NakedObject clone = getPersistenceSession().createInstance(spec); final NakedObjectAssociation[] fields = spec.getAssociations(); for (int i = 0; i < fields.length; i++) { final NakedObject fld = fields[i].get(original); if (fields[i].isOneToOneAssociation()) { ((OneToOneAssociation) fields[i]).setAssociation(clone, fld); } else if (fields[i].isOneToManyAssociation()) { // clone.setValue((OneToOneAssociation) fields[i], fld.getObject()); } } // AbstractNakedObject clone = (AbstractNakedObject) createInstance(getClass()); // clone.copyObject(this); // clone.objectChanged(); final Content content = Toolkit.getContentFactory().createRootContent(clone); final View cloneView = Toolkit.getViewFactory().createWindow(content); cloneView.setLocation(at); workspace.addView(cloneView); // newWorkspace.markDamaged(); }
if (fieldData instanceof NullData) { persistentContents[i] = null; } else if (fields[i].isOneToOneAssociation()) { if (fieldData instanceof ObjectData) { final NakedObject fieldReference = fields[i].get(object);
if (association.isOneToOneAssociation() && source.getSpecification().isOfType(association.getSpecification())) { OneToOneAssociation otoa = (OneToOneAssociation) association; if (association.get(target) == null &&
if (field.getSpecification().isParseable()) { component = factory.createParseableField(field, associatedObject, false); } else if (field.isOneToOneAssociation()) { if (associatedObject == null) { component = factory.createInlineBlock("value", "", null);