public boolean isTransient() { return object != null && object.getResolveState().isTransient(); }
public boolean isTransient() { return object.getResolveState().isTransient(); }
public Consent disabled(final View view) { NakedObject object = (NakedObject) view.getContent().getNaked(); return AbstractConsent.allow(object == null || object.getResolveState() != ResolveState.TRANSIENT || object.getResolveState() == ResolveState.GHOST); }
public void objectChanged(final NakedObject object) { if (object.getResolveState().isTransient()) { NakedObjectsContext.getUpdateNotifer().addChangedObject(object); } if (object.getResolveState().respondToChangesInPersistentObjects()) { checkTransactionInProgress(); clientSideTransaction.addObjectChanged(object); } }
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); } }
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); } }
private NakedObject[] toInstancesArray(final Vector instances) { NakedObject[] ins = new NakedObject[instances.size()]; for (int i = 0; i < ins.length; i++) { NakedObject object = (NakedObject) instances.elementAt(i); setupReferencedObjects(object); if (object.getResolveState().isResolvable(ResolveState.RESOLVING)) { NakedObjectsContext.getObjectLoader().start(object, ResolveState.RESOLVING); NakedObjectsContext.getObjectLoader().end(object); } ins[i] = object; } return ins; }
public void onPostUpdate(final PostUpdateEvent event) { if (LOG.isDebugEnabled()) { LOG.debug("PostUpdateEvent "+event.getEntity().getClass()+" "+event.getId()); } NakedObjectLoader objectLoader = NakedObjectsContext.getObjectLoader(); NakedObject adapter = objectLoader.getAdapterFor(event.getEntity()); adapter.getSpecification().clearDirty(adapter); // TODO: if flush processing changes remove the if (leave the changeState) // make sure adapter not set to serializing by preflush if (adapter.getResolveState() == ResolveState.UPDATING) { // adapter.changeState(ResolveState.RESOLVED); objectLoader.end(adapter); } }
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); }
protected void resolveObject(final Content content) { NakedObject object = ((ObjectContent) content).getObject(); if (!object.getResolveState().isResolved()) { NakedObjectsContext.getObjectPersistor().resolveImmediately(object); } }
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); }
public synchronized void resolveImmediately(NakedObject object) { ResolveState resolveState = object.getResolveState(); if (resolveState.isResolvable(ResolveState.RESOLVING)) { Oid oid = object.getOid(); LOG.debug("resolve object (remotely from server)" + oid); ObjectData data = connection.resolveImmediately(NakedObjectsContext.getSession(), encoder.createIdentityData(object)); encoder.restore(data); } }
public Object getDefault() { ResolveState resolveState = getNakedObject().getResolveState(); if (resolveState.isTransient()) { return getScalarAssociation().getDefault(getNakedObject()); } return null; }
public Consent disabled(final View view) { NakedObject adapter = (NakedObject) view.getContent().getNaked(); if (adapter.getResolveState().isDestroyed()) { return new Veto("Can't do anything with a destroyed object"); } if (isObjectInRootView(view)) { return Allow.DEFAULT; } else { return new Veto("Can't dispose an object from within another view."); } }
public ObjectData resolveImmediately(final Session session, final IdentityData target) { LOG.debug("request resolveImmediately " + target + " for " + session); NakedObjectSpecification spec = getSpecification(target.getType()); NakedObject object = NakedObjectsContext.getObjectPersistor().getObject(target.getOid(), spec); if (object.getResolveState().isResolvable(ResolveState.RESOLVING)) { // this is need when the object store does not load the object fully in the getObject() above NakedObjectsContext.getObjectPersistor().resolveImmediately(object); } return encoder.createCompletePersistentGraph(object); }
private ObjectData createObjectData(final NakedObject object) { NakedObjectSpecification cls = object.getSpecification(); NakedObjectField[] fields = cls.getFields(); ObjectData data = new ObjectData(object.getOid(), object.getResolveState().name(), cls.getFullName()); for (int i = 0; i < fields.length; i++) { if (fields[i].isPersisted()) { createFieldData(object, data, fields[i]); } } return data; }
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 testSetValueCallPassedToDelegateWhenTargetIsTransient() { reset(encoder); reset(object); expect(object.getResolveState()).andReturn(ResolveState.TRANSIENT); peer.setValue(object, new TestValueAdapter("string")); // distributionControl.setDefaultMatcher(MockControl.ARRAY_MATCHER); // distributionControl.expectAndDefaultReturn(connection.setValue(NakedObjectsContext.getSession(), "field", expectedTarget, new DummyValueData("string")), null); // distributionControl.setDefaultMatcher(MockControl.ARRAY_MATCHER); replay(); proxy.setValue(object, new TestValueAdapter("string")); verify(); } /*
public void testRecreateTransientAdapter() { Oid oid = new TestProxyOid(13, false); Object object = new TestPojo(); NakedObject adapter = objectLoader.recreateAdapter(oid, object); assertEquals(oid, adapter.getOid()); assertEquals(object, adapter.getObject()); assertEquals(ResolveState.TRANSIENT, adapter.getResolveState()); assertEquals(null, adapter.getVersion()); }
public void testRecreatePersistentAdapter() { Oid oid = new TestProxyOid(15, true); Object object = new TestPojo(); NakedObject adapter = objectLoader.recreateAdapter(oid, object); assertEquals(oid, adapter.getOid()); assertEquals(object, adapter.getObject()); assertEquals(ResolveState.GHOST, adapter.getResolveState()); assertEquals(null, adapter.getVersion()); }