public Object nullSafeGet(final ResultSet rs, final String[] names, final Object owner) throws HibernateException, SQLException { String id = rs.getString(names[0]); if (rs.wasNull()) return null; Oid oid = new HibernateOid(id,id,id); NakedObject adapter = NakedObjectsContext.getObjectLoader().getAdapterFor(oid); if (adapter == null) { throw new HibernateException("Unknown DomainModelResource: id="+id); } return adapter.getObject(); }
private NakedObject recreateObject(final ObjectData data) { SerialOid oid = data.getOid(); NakedObjectSpecification spec = specFor(data); NakedObject object = objectLoader().recreateAdapterForPersistent(oid, spec); initObject(object, data); return object; }
private Naked adaptedPojo(Object pojo, NakedObjectSpecification type) { if (pojo == null) { return null; } else { if (type.getType() == NakedObjectSpecification.VALUE) { NakedValue valueAdapter = NakedObjectsContext.getObjectLoader().createAdapterForValue(pojo); // TODO set up mask return valueAdapter; } else { return NakedObjectsContext.getObjectLoader().getAdapterForElseCreateAdapterForTransient(pojo); } } }
public final NakedValue getValue(NakedObject inObject) { String name = getValue(((Perspective) inObject.getObject())); if (name == null) { // return new StringAdapter(); return NakedObjectsContext.getObjectLoader().createValueInstance(stringSpec); } else { return NakedObjectsContext.getObjectLoader().createAdapterForValue(name); } }
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); }
public IdentityData oidForService(Session session, String id) { Object[] applicationServices = NakedObjectsContext.getObjectLoader().getServices(); for (int i = 0; i < applicationServices.length; i++) { if (id.equals(ServiceUtil.id(applicationServices[i]))) { NakedObject adapter = NakedObjectsContext.getObjectLoader().getAdapterFor(applicationServices[i]); return encoder.createIdentityData(adapter); } } throw new NakedObjectsRemoteException("Failed to find service " + id); }
/** * Occurs after an an entity instance is fully loaded. */ public void onPostLoad(final PostLoadEvent event) { if (LOG.isDebugEnabled()) { LOG.debug("PostLoadEvent "+event.getEntity().getClass()+" "+event.getId()); } NakedObjectLoader loader = NakedObjectsContext.getObjectLoader(); // adapter already created in onPreLoad/NakedInterceptor.instantiate NakedObject adapter = loader.getAdapterFor(event.getEntity()); loader.end(adapter); // TODO decide whether this should go into preLoad - put in NakedInterceptor.instantiate for now //loader.getObjectFactory().initRecreatedObject(event.getEntity()); adapter.getSpecification().clearDirty(adapter); }
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 }
public NakedObject getObject(final Oid oid, final NakedObjectSpecification specification) { Assert.assertNotNull("needs an OID", oid); Assert.assertNotNull("needs a specification", specification); NakedObject object; if (NakedObjectsContext.getObjectLoader().isIdentityKnown(oid)) { object = NakedObjectsContext.getObjectLoader().getAdapterFor(oid); } else { object = objectStore.getObject(oid, specification); } return object; }
private Object loadUnresolvedObject( final LoadEvent event, final EntityPersister persister, final EntityKey keyToLoad, final LoadEventListener.LoadType options, final PersistenceContext persistenceContext) { final HibernateOid oid = new HibernateOid(event.getEntityClassName(), event.getEntityId()); final NakedObjectSpecification spec = NakedObjectsContext.getReflector().loadSpecification(event.getEntityClassName()); final NakedObjectLoader loader = NakedObjectsContext.getObjectLoader(); NakedObject nakedObject = loader.getAdapterFor(oid); if (nakedObject == null) { nakedObject = loader.recreateAdapterForPersistent(oid, spec); Assert.assertFalse(persistenceContext.isEntryFor(nakedObject.getObject())); return nakedObject.getObject(); } else { return load(event, persister, keyToLoad, options); } } }
public Object instantiate(final String entityName, final EntityMode entityMode, final Serializable id) throws CallbackException { if (LOG.isDebugEnabled()) { LOG.debug("instantiate entityName=" + entityName + ", id=" + id + ", mode=" + entityMode); } NakedObjectLoader loader = NakedObjectsContext.getObjectLoader(); HibernateOid oid = new HibernateOid(entityName, id); NakedObjectSpecification spec = NakedObjectsContext.getReflector().loadSpecification(entityName); NakedObject adapter = loader.recreateAdapterForPersistent(oid, spec); // TODO fudge to work around problem in getEntity where entity is a subclass // (HibernateOid doesn't handle subclasses!) if (adapter.getResolveState().isResolved()) { loader.start(adapter, ResolveState.UPDATING); } else { loader.start(adapter, ResolveState.RESOLVING); } Object object = adapter.getObject(); // need to set the id in case the object has an id property (if not id is held in // the oid, and that's taken care of above) try { HibernateUtil.getSessionFactory().getClassMetadata(entityName).setIdentifier(object, id, entityMode); } catch (HibernateException e) { throw new CallbackException("Error getting identifier property for class " + entityName, e); } return adapter.getObject(); }
public void onPostInsert(final PostInsertEvent event) { if (LOG.isDebugEnabled()) { LOG.debug("PostInsertEvent "+event.getEntity().getClass()+" "+event.getId()); } // make sure the oid is loaded with the hibernate id // make sure the adapter is set to resolved NakedObjectLoader loader = NakedObjectsContext.getObjectLoader(); NakedObject adapter = loader.getAdapterFor(event.getEntity()); HibernateOid oid = (HibernateOid) adapter.getOid(); if (oid.isTransient()) { // in case id is a property of the object, and hence not set using OidAccessor oid.setHibernateId(event.getId()); // REVIEW is this the place to make the object persistent? Is it not already done in the PersistAlgorithm loader.madePersistent(adapter); // ((HibernateObjectLoaderImpl)loader).madePersistent(adapter); } else { // not sure we should ever get here! Check logs to see if it happens LOG.warn("Not transient: oid="+oid+", resolve state="+adapter.getResolveState()+" for "+event.getEntity()); } // if (adapter.getResolveState() != ResolveState.RESOLVED) { // LOG.info("PostInsertEvent resolve state="+adapter.getResolveState()+" for "+event.getEntity()); // adapter.changeState(ResolveState.RESOLVED); // } adapter.getSpecification().clearDirty(adapter); }
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 NakedObject recreateReference(final Data data) { NakedObjectLoader objectLoader = NakedObjectsContext.getObjectLoader(); synchronized (objectLoader) { Oid oid = data.oid; NakedObject ref; if (oid == null) { ref = null; } else { NakedObjectSpecification spec = NakedObjectsContext.getReflector().loadSpecification(data.className); ResolveState resolveState; if (oid.isTransient()) { ref = objectLoader.recreateTransientInstance(oid, spec); resolveState = ResolveState.getResolveState(data.resolveState); } else { ref = objectLoader.recreateAdapterForPersistent(oid, spec); resolveState = ResolveState.GHOST; } if (data instanceof ObjectData) { updateObject(ref, data, resolveState); } } return ref; } }
private void updateField(final NakedObject object, ObjectData od, NakedObjectField field) { Object fieldData = od.getEntry(field.getId()); if (field.isCollection()) { updateOneToManyAssociation(object, (OneToManyAssociation) field, (CollectionData) fieldData); } else if (field.isObject()) { updateOneToOneAssociation(object, (OneToOneAssociation) field, (Data) fieldData); } else if (field.isValue()) { NakedValue value = NakedObjectsContext.getObjectLoader().createValueInstance(field.getSpecification()); value.restoreFromEncodedString((String) fieldData); ((ValueAssociation) field).initValue(object, value); } }
private void setUpRegisterServices() { NakedObjectReflector reflector = NakedObjectsContext.getReflector(); NakedObjectLoader loader = NakedObjectsContext.getObjectLoader(); startTransaction(); for (int i = 0; i < services.length; i++) { reflector.installServiceSpecification(services[i].getClass()); Oid oid = getOidForService(ServiceUtil.id(services[i])); if (oid == null) { NakedObject adapter = loader.createAdapterForTransient(services[i], false); loader.madePersistent(adapter); oid = adapter.getOid(); registerService(ServiceUtil.id(services[i]), oid); } } endTransaction(); }
public DummyNakedCollection(final Vector vector) { for(Enumeration e = vector.elements(); e.hasMoreElements(); ) { Object element = e.nextElement(); collection.addElement(NakedObjectsContext.getObjectLoader().getAdapterForElseCreateAdapterForTransient(element)); /* if(! (element instanceof NakedObject)) { throw new IllegalArgumentException("Element not of type NakedObject: " + element); } */ } this.collection = vector; }
private synchronized void clearChanges() { if (checkObjectsForDirtyFlag) { LOG.debug("clearing changed objects"); Enumeration e = NakedObjectsContext.getObjectLoader().getIdentifiedObjects(); while (e.hasMoreElements()) { Object o = e.nextElement(); if (o instanceof NakedObject) { NakedObject object = (NakedObject) o; if (object.getSpecification().isDirty(object)) { LOG.debug(" found dirty object " + object); object.getSpecification().clearDirty(object); } } } } }
public void testClientSideActionWhereTransientObjectMadePersistent() throws Exception { system.setObjectPersistor(proxy); proxy.setOidGenerator(new SimpleOidGenerator(10)); DummyObjectData movieData = new DummyObjectData(new DummyOid(-1), Movie.class.getName(), true, null); NullData directorData = new DummyNullValue(Person.class.getName()); DummyValueData nameData = new DummyValueData("Star Wars", String.class.getName()); movieData.setFieldContent(new Data[] { directorData, nameData }); TestProxyOid newOid = new TestProxyOid(123, true); newOid.previous = new TestProxyOid(-1); DummyReferenceData updateData = new DummyReferenceData(newOid, "type", new DummyVersion(456)); NakedObject transientObject = new DummyNakedObject(newOid.previous, ResolveState.NEW); NakedObjectsContext.getObjectLoader().createAdapterForTransient(transientObject, false); // client needs to encode the object's transient aspects expect(encoder.createMakePersistentGraph(transientObject, new KnownObjects())).andReturn(movieData); // the server is called with data (movieData) for the object to be persisted remoteInterface.executeClientAction(eq(session), aryEq(new ReferenceData[] { movieData }), aryEq(new int[] { ClientTransactionEvent.ADD })); expectLastCall().andReturn(new DummyClientResultData(new ReferenceData[] { updateData }, null, new ObjectData[0])); replay(); proxy.startTransaction(); proxy.makePersistent(transientObject); proxy.endTransaction(); verify(); }