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 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); } }
public void changeState(final ResolveState state) { this.state.isValidToChangeTo(state); this.state = state; }
/** * Returns false while object is having its field set up. */ public boolean respondToChangesInPersistentObjects() { // note: SERIALIZING_TRANSIENT is included twice here, through either isTransient() or isSerializing() return !( isNew() || isTransient() || isResolving() || isUpdating() || isSerializing() ); }
public boolean isPersistent() { return this == GHOST || this == PART_RESOLVED || this == RESOLVED || isResolving() || isUpdating() || (isSerializing() && this != SERIALIZING_TRANSIENT); }
public Object getEntity(final String entityName, final Serializable id) throws CallbackException { if (LOG.isDebugEnabled()) { LOG.debug("getEntity entityName=" + entityName + ", id=" + id); } final HibernateOid oid = new HibernateOid(entityName, id); final NakedObject adapter = NakedObjectsContext.getObjectLoader().getAdapterFor(oid); if (adapter != null) { LOG.debug("getEntity found naked object with same oid - " + oid); if (adapter.getResolveState().isGhost() || adapter.getResolveState().isPartlyResolved() || adapter.getResolveState().isResolving()) { // change for lazy loading objects - this prevents hibernate // picking up the GHOST object as an already loaded entity by only returning // the object if it is resolved return null; } return adapter.getObject(); } return null; }
private boolean executeRemotely(final NakedObject target) { return target.getResolveState().isPersistent(); }
public boolean isTransient() { return object != null && object.getResolveState().isTransient(); }
public void objectChanged(final NakedObject object) { ResolveState resolveState = object.getResolveState(); if (resolveState.respondToChangesInPersistentObjects()) { NakedObjectSpecification specification = object.getSpecification(); if (Features.isAlwaysImmutable(specification) || (Features.isImmutableOncePersisted(specification) && resolveState.isPersistent())) { throw new ObjectPersistenceException("cannot change immutable object"); } object.getSpecification().lifecycleEvent(object, NakedObjectSpecification.UPDATING); getTransaction().addCommand(objectStore.createSaveObjectCommand(object)); object.getSpecification().lifecycleEvent(object, NakedObjectSpecification.UPDATED); NakedObjectsContext.getUpdateNotifer().addChangedObject(object); } if (resolveState.respondToChangesInPersistentObjects() || resolveState.isTransient()) { object.fireChangedEvent(); NakedObjectsContext.getUpdateNotifer().addChangedObject(object); } }
public void onInitializeCollection(final InitializeCollectionEvent event) throws HibernateException { if (LOG.isDebugEnabled()) { LOG.info("InitializeCollectionEvent"); } NakedObjectLoader loader = NakedObjectsContext.getObjectLoader(); NakedObject adapter = loader.getAdapterFor(event.getCollection()); if (adapter != null && adapter.getResolveState().isResolvable(ResolveState.RESOLVING)) { if (LOG.isDebugEnabled()) { LOG.debug("Setting collection to resolved "+adapter); } adapter.changeState(ResolveState.RESOLVING); adapter.changeState(ResolveState.RESOLVED); } }
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) { 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); }
protected void resolveObject(final Content content) { NakedObject object = ((ObjectContent) content).getObject(); if (!object.getResolveState().isResolved()) { NakedObjectsContext.getObjectPersistor().resolveImmediately(object); } }
public void objectChanged(final NakedObject object) { if (object.getResolveState().isTransient()) { NakedObjectsContext.getUpdateNotifer().addChangedObject(object); } if (object.getResolveState().respondToChangesInPersistentObjects()) { checkTransactionInProgress(); clientSideTransaction.addObjectChanged(object); } }
private View createView(final ViewSpecification specification, final Content content, ViewAxis axis) { ViewSpecification spec; if (specification == null) { LOG.warn("no suitable view for " + content + " using fallback view"); spec = new FallbackView.Specification(); } else { spec = specification; } View createView = spec.createView(content, axis); if (content.isObject()) { NakedObject adapter = (NakedObject) content.getNaked(); if (adapter != null && adapter.getResolveState().isDestroyed()) { createView = new DisposedObjectBorder(createView); } } return createView; }
public void viewMenuOptions(final UserActionSet options) { super.viewMenuOptions(options); TreeDisplayRules.menuOptions(options); options.add(new AbstractUserAction("Select node") { public void execute(final Workspace workspace, final View view, final Location at) { selectNode(); } public String getDescription(final View view) { return "Show this node in the right-hand pane"; } }); Naked object = getView().getContent().getNaked(); ResolveState resolveState = ((NakedReference) object).getResolveState(); if (object instanceof NakedReference && (resolveState.isGhost() || resolveState.isPartlyResolved())) { options.add(new AbstractUserAction("Load object") { public void execute(final Workspace workspace, final View view, final Location at) { resolveContent(); } }); } }
public int canOpen(final Content content) { NakedCollection collection = ((CollectionContent) content).getCollection(); if (collection.getResolveState().isGhost()) { return UNKNOWN; } else { return collection.size() > 0 ? CAN_OPEN : CANT_OPEN; } }
public boolean onPreUpdate(final PreUpdateEvent event) { if (LOG.isDebugEnabled()) { LOG.debug("PreUpdateEvent "+event.getEntity().getClass()+" "+event.getId()); } NakedObjectLoader objectLoader = NakedObjectsContext.getObjectLoader(); NakedObject adapter = objectLoader.getAdapterFor(event.getEntity()); // make sure objectchanged/resolve aren't fired when Hibernate accesses the object // TODO: if flush processing changes remove the if (leave the changeState) // make sure adapter not set to serializing by preflush if (!adapter.getResolveState().isSerializing()) { //adapter.changeState(ResolveState.UPDATING); objectLoader.start(adapter, ResolveState.UPDATING); } return false; // object not changed }
private boolean executeRemotely(final NakedObject target) { return target.getResolveState().isPersistent(); }
public boolean isTransient() { return object.getResolveState().isTransient(); }