/** * Accessor for whether the passed object is detached. * @param obj The object * @return Whether it is detached */ public boolean isDetached(Object obj) { // Relay through to JDOHelper - TODO Change this when we JPOX-JPA doesnt depend on JDO return JDOHelper.isDetached(obj); }
/** * Accessor for whether the passed object is detached. * @param obj The object * @return Whether it is detached */ public boolean isDetached(Object obj) { // Relay through to JDOHelper - TODO Change this when we JPOX-JPA doesnt depend on JDO return JDOHelper.isDetached(obj); }
/** * Method to assert if the specified object is detached. * Throws a ObjectDetachedException if it is detached. * @param object The object to check */ private void assertNotDetached(Object object) { if (JDOHelper.isDetached(object)) { throw new ObjectDetachedException(object.getClass().getName()); } }
public static void dumpObjectState( PrintStream out, Object o ) { final String STATE = "[STATE] "; final String INDENT = " "; if ( o == null ) { out.println( STATE + "Object is null." ); return; } out.println( STATE + "Object " + o.getClass().getName() ); if ( !( o instanceof PersistenceCapable ) ) { out.println( INDENT + "is NOT PersistenceCapable (not a jdo object?)" ); return; } out.println( INDENT + "is PersistenceCapable." ); if ( o instanceof Detachable ) { out.println( INDENT + "is Detachable" ); } out.println( INDENT + "is new : " + Boolean.toString( JDOHelper.isNew( o ) ) ); out.println( INDENT + "is transactional : " + Boolean.toString( JDOHelper.isTransactional( o ) ) ); out.println( INDENT + "is deleted : " + Boolean.toString( JDOHelper.isDeleted( o ) ) ); out.println( INDENT + "is detached : " + Boolean.toString( JDOHelper.isDetached( o ) ) ); out.println( INDENT + "is dirty : " + Boolean.toString( JDOHelper.isDirty( o ) ) ); out.println( INDENT + "is persistent : " + Boolean.toString( JDOHelper.isPersistent( o ) ) ); out.println( INDENT + "object id : " + JDOHelper.getObjectId( o ) ); }
/** * Method to throw and EndOfFetchPlanGraphException since we're at the end of a branch in the tree. * @param fieldNumber Number of the field * @return Object to return */ protected Object endOfGraphOperation(int fieldNumber) { // check if the object here is PC and is in the detached cache anyway SingleValueFieldManager sfv = new SingleValueFieldManager(); sm.provideFields(new int[]{fieldNumber}, sfv); Object value = sfv.fetchObjectField(fieldNumber); if (value instanceof PersistenceCapable) { PersistenceCapable detached = ((DetachState)state).getDetachedCopyObject(value); if (detached != null) { // While we are at the end of a branch and this would go beyond the depth limits, // the object here *is* already detached so just return it return detached; } if (!copy && JDOHelper.isDetached(value)) { return value; } } // we reached a leaf of the object graph to detach throw new EndOfFetchPlanGraphException(); } }
/** * JDO method to make persistent an object. * @param obj The object */ public synchronized Object makePersistent(Object obj) { assertIsOpen(); assertActiveTransaction(); if (obj == null) { return null; } // Persist the object boolean detached = JDOHelper.isDetached(obj); Object persistedPc = internalMakePersistent(obj, null); StateManager sm = findStateManager((PersistenceCapable)persistedPc); if (apmf.getPersistenceByReachabilityAtCommit()) { if (sm != null) { if (detached || sm.isNew((PersistenceCapable)persistedPc)) { txKnownPersists.add(sm.getInternalObjectId()); } } } return persistedPc; }
/** * Utility to validate a key is ok for reading. * @param sm State Manager for the map. * @param key The key to check. * @return Whether it is validated. **/ protected boolean validateKeyForReading(StateManager sm, Object key) { validateKeyType(sm.getPersistenceManager().getClassLoaderResolver(), key); if (!keysAreEmbedded && !keysAreSerialised) { PersistenceManager pm = sm.getPersistenceManager(); if (key!=null && (!JDOHelper.isPersistent(key) || pm != JDOHelper.getPersistenceManager(key)) && !JDOHelper.isDetached(key)) { return false; } } return true; }
/** * Utility to validate a value is ok for reading. * @param sm State Manager for the map. * @param value The value to check. * @return Whether it is validated. **/ protected boolean validateValueForReading(StateManager sm, Object value) { validateValueType(sm.getPersistenceManager().getClassLoaderResolver(), value); if (!valuesAreEmbedded && !valuesAreSerialised) { PersistenceManager pm = sm.getPersistenceManager(); if (value!=null && (!JDOHelper.isPersistent(value) || pm != JDOHelper.getPersistenceManager(value)) && !JDOHelper.isDetached(value)) { return false; } } return true; }
/** * Method to check if an element is already persistent or is persistent but managed by * a different persistence manager. * @param sm The state manager of this owner * @param element The element * @return Whether it is valid for reading. */ protected boolean validateElementForReading(StateManager sm, Object element) { if (!validateElementType(sm.getPersistenceManager().getClassLoaderResolver(), element)) { return false; } if (element != null && !elementsAreEmbedded && !elementsAreSerialised) { PersistenceManager pm = sm.getPersistenceManager(); if ((!JDOHelper.isPersistent(element) || pm != JDOHelper.getPersistenceManager(element)) && !JDOHelper.isDetached(element)) { return false; } } return true; }
public void updateBuildResult( BuildResult build ) throws ContinuumStoreException { PersistenceManager pm = getPersistenceManager(); Transaction tx = pm.currentTransaction(); Project project = build.getProject(); try { tx.begin(); if ( !JDOHelper.isDetached( build ) ) { throw new ContinuumStoreException( "Not detached: " + build ); } pm.makePersistent( build ); if ( !JDOHelper.isDetached( project ) ) { throw new ContinuumStoreException( "Not detached: " + project ); } project.setState( build.getState() ); pm.makePersistent( project ); tx.commit(); } finally { rollback( tx ); } }
public void updateBuildResult( BuildResult build ) throws ContinuumStoreException { PersistenceManager pm = getPersistenceManager(); Transaction tx = pm.currentTransaction(); Project project = build.getProject(); try { tx.begin(); if ( !JDOHelper.isDetached( build ) ) { throw new ContinuumStoreException( "Not detached: " + build ); } pm.makePersistent( build ); if ( !JDOHelper.isDetached( project ) ) { throw new ContinuumStoreException( "Not detached: " + project ); } project.setState( build.getState() ); //TODO: Use projectDao pm.makePersistent( project ); tx.commit(); } finally { rollback( tx ); } }
if (JDOHelper.isDetached(element))
if (JDOHelper.isDetached(key))
if (JDOHelper.isDetached(value))
if ( ( JDOHelper.getObjectId( role ) != null ) && !JDOHelper.isDetached( role ) )
if ( !JDOHelper.isDetached( object ) )
public Object saveObject( Object object, String[] fetchGroups ) { PersistenceManager pm = getPersistenceManager(); Transaction tx = pm.currentTransaction(); try { tx.begin(); if ( ( JDOHelper.getObjectId( object ) != null ) && !JDOHelper.isDetached( object ) ) { // This is a fatal error that means we need to fix our code. // Leave it as a JDOUserException, it's intentional. throw new JDOUserException( "Existing object is not detached: " + object, object ); } if ( fetchGroups != null ) { for ( int i = 0; i >= fetchGroups.length; i++ ) { pm.getFetchPlan().addGroup( fetchGroups[i] ); } } pm.makePersistent( object ); object = pm.detachCopy( object ); tx.commit(); return object; } finally { rollbackIfActive( tx ); } }
assertDetachable(pc); if (JDOHelper.isDetached(pc))
if ( ( JDOHelper.getObjectId( object ) != null ) && !JDOHelper.isDetached( object ) )
assertTrue(JDOHelper.isDetached(tc1)); assertTrue(JDOHelper.isDetached(tc1b)); assertFalse(JDOHelper.isDetached(tc2)); assertFalse(JDOHelper.isDetached(tc2b));