private boolean executeRemotely(final NakedObject target) { return target.getResolveState().isPersistent(); }
private boolean executeRemotely(final NakedObject target) { return target.getResolveState().isPersistent(); }
private boolean executeRemotely(final NakedObject target) { return target.getResolveState().isPersistent(); }
private boolean isPersistent(final NakedReference object) { return object.getResolveState().isPersistent(); }
public void makePersistent(final NakedObject object, final PersistedObjectAdder adders) { if (object.getResolveState().isPersistent() || object.persistable() == Persistable.TRANSIENT) { return; } if (LOG.isInfoEnabled()) { LOG.info("persist " + object); } // NakedObjects.getObjectLoader().madePersistent(object); // Don't do here - allow EventListener to propogate persistent state object.getSpecification().lifecycleEvent(object, NakedObjectSpecification.SAVING); adders.addPersistedObject(object); object.getSpecification().lifecycleEvent(object, NakedObjectSpecification.SAVED); }
public void makePersistent(final NakedObject object, final PersistedObjectAdder persistor) { if (object.getResolveState().isPersistent() || object.persistable() == Persistable.TRANSIENT) { throw new NotPersistableException("can't make object persistent - either already persistent, or transient only: " + object); } persist(object, persistor); }
private void makePersistent(final NakedCollection collection, final PersistedObjectAdder persistor) { if (collection.getResolveState().isPersistent() || collection.persistable() == Persistable.TRANSIENT) { return; } LOG.info("persist " + collection); if (collection.getResolveState() == ResolveState.TRANSIENT) { collection.changeState(ResolveState.RESOLVED); } NakedObjectsContext.getObjectLoader().madePersistent(collection); Enumeration elements = collection.elements(); while (elements.hasMoreElements()) { makePersistent((NakedObject) elements.nextElement(), persistor); } }
private void makePersistent(final NakedCollection collection, final PersistedObjectAdder persistor) { if (collection.getResolveState().isPersistent() || collection.persistable() == Persistable.TRANSIENT) { return; } LOG.info("persist " + collection); if (collection.getResolveState() == ResolveState.TRANSIENT) { collection.changeState(ResolveState.RESOLVED); } NakedObjectsContext.getObjectLoader().madePersistent(collection); Enumeration elements = collection.elements(); while (elements.hasMoreElements()) { makePersistent((NakedObject) elements.nextElement(), persistor); } }
public void addElement(final NakedObject inObject, final NakedObject associate) { if (associate == null) { throw new IllegalArgumentException("Can't use null to add an item to a collection"); } if (readWrite()) { if (inObject.getResolveState().isPersistent() && associate.getResolveState().isTransient()) { throw new NakedObjectRuntimeException("can't set a reference to a transient object from a persistent one: " + inObject.titleString() + " (persistent) -> " + associate.titleString() + " (transient)"); } reflectiveAdapter.addAssociation(inObject, associate); } }
private boolean isToBeExecutedRemotely(final NakedReference target) { boolean remoteOverride = getTarget() == NakedObjectAction.REMOTE; boolean localOverride = getTarget() == NakedObjectAction.LOCAL; if (localOverride) { return false; } if (remoteOverride) { return true; } if (Features.isService(target.getSpecification())) { return true; } if (target == null) { // for static methods there is no target return false; } boolean remoteAsPersistent = target.getResolveState().isPersistent(); return remoteAsPersistent; }
public void setAssociation(final NakedObject inObject, final NakedObject associate) { if (isReadWrite()) { if (inObject.getResolveState().isPersistent() && associate != null && associate.getResolveState().isTransient()) { throw new NakedObjectRuntimeException("can't set a reference to a transient object from a persistent one: " + inObject.titleString() + " (persistent) -> " + associate.titleString() + " (transient)"); } reflectiveAdapter.setAssociation(inObject, associate); } }
public void setValue(final NakedObject inObject, final NakedValue value) { NakedObjectPersistor objectManager = NakedObjectsContext.getObjectPersistor(); if (inObject.getResolveState().isPersistent()) { try { objectManager.startTransaction(); super.setValue(inObject, value); objectManager.saveChanges(); objectManager.endTransaction(); } catch (RuntimeException e) { abort(objectManager); throw e; } } else { super.setValue(inObject, value); } }
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 removeAllAssociations(final NakedObject inObject) { NakedObjectPersistor objectManager = NakedObjectsContext.getObjectPersistor(); if (inObject.getResolveState().isPersistent()) { try { objectManager.startTransaction(); super.removeAllAssociations(inObject); objectManager.saveChanges(); objectManager.endTransaction(); } catch (RuntimeException e) { abort(objectManager); throw e; } } else { super.removeAllAssociations(inObject); } }
public void clearValue(final NakedObject inObject) { NakedObjectPersistor objectManager = NakedObjectsContext.getObjectPersistor(); if (inObject.getResolveState().isPersistent()) { try { objectManager.startTransaction(); super.clearValue(inObject); objectManager.saveChanges(); objectManager.endTransaction(); } catch (RuntimeException e) { abort(objectManager); throw e; } } else { super.clearValue(inObject); } }
public void addAssociation(final NakedObject inObject, final NakedObject associate) { NakedObjectPersistor objectManager = NakedObjectsContext.getObjectPersistor(); if (inObject.getResolveState().isPersistent()) { try { objectManager.startTransaction(); super.addAssociation(inObject, associate); objectManager.saveChanges(); objectManager.endTransaction(); } catch (RuntimeException e) { abort(objectManager); throw e; } } else { super.addAssociation(inObject, associate); } }
public void clearAssociation(final NakedObject inObject, final NakedObject associate) { NakedObjectPersistor objectManager = NakedObjectsContext.getObjectPersistor(); if (inObject.getResolveState().isPersistent()) { try { objectManager.startTransaction(); super.clearAssociation(inObject, associate); objectManager.saveChanges(); objectManager.endTransaction(); } catch (RuntimeException e) { abort(objectManager); throw e; } } else { super.clearAssociation(inObject, associate); } }
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 resolveImmediately(final NakedObject object) { ResolveState resolveState = object.getResolveState(); if (resolveState.isResolvable(ResolveState.RESOLVING)) { Assert.assertFalse("only resolve object that is not yet resolved", object, object.getResolveState().isResolved()); Assert.assertTrue("only resolve object that is persistent", object, object.getResolveState().isPersistent()); if (LOG.isInfoEnabled()) { // don't log object - it's toString() may use the unresolved field, or unresolved collection LOG.info("resolve immediately: " + object.getSpecification().getShortName() + " "+ object.getResolveState().code() + " " + object.getOid()); } object.getSpecification().lifecycleEvent(object, NakedObjectSpecification.LOADING); objectStore.resolveImmediately(object); object.getSpecification().lifecycleEvent(object, NakedObjectSpecification.LOADED); } }
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()); } }