public void releaseAll(Collection objs, OpCallbacks call) { beginOperation(false); try { List<Exception> exceps = null; for (Iterator<?> itr = objs.iterator(); itr.hasNext();) { try { release(itr.next(), call); } catch (UserException ue) { exceps = add(exceps, ue); } } throwNestedExceptions(exceps, false); } finally { endOperation(); } }
/** * Mark this object as a dereferenced dependent object. */ void setDereferencedDependent(boolean deref, boolean notify) { if (!deref && (_flags & FLAG_DEREF) > 0) { if (notify) _broker.removeDereferencedDependent(this); _flags &= ~FLAG_DEREF; } else if (deref && (_flags & FLAG_DEREF) == 0) { _flags |= FLAG_DEREF; if (notify) _broker.addDereferencedDependent(this); } }
public void refresh(Object obj, OpCallbacks call) { if (obj == null) return; beginOperation(true); try { assertNontransactionalRead(); gatherCascadeRefresh(obj, call); if (_operating.isEmpty()) return; if (_operating.size() == 1) refreshInternal(_operating.iterator().next(), call); else refreshInternal(_operating, call); } finally { endOperation(); } }
/** * Sets automatic detachment option. * <br> * If the given flag contains {@link AutoDetach#DETACH_NONE} option, * then no other option can be specified. */ public void setAutoDetach(int detachFlags) { assertOpen(); assertAutoDetachValue(detachFlags); _autoDetach = detachFlags; }
public void setRollbackOnly(Throwable cause) { beginOperation(true); try { assertTransactionOperation(); setRollbackOnlyInternal(cause); } finally { endOperation(); } }
return; beginOperation(true); try { assertOpen(); assertNontransactionalRead(); StateManagerImpl sm = getStateManagerImpl(obj, true); if ((processArgument(OpCallbacks.OP_RETRIEVE, obj, sm, call) & OpCallbacks.ACT_RUN) == 0) return; throw newDetachedException(obj, "retrieve"); if (sm.isPersistent()) { int mode = (dfgOnly) ? StateManagerImpl.LOAD_FGS sm.load(_fc, mode, null, null, false); } else if (assertPersistenceCapable(obj).pcIsDetached() == Boolean.TRUE) throw newDetachedException(obj, "retrieve"); } catch (OpenJPAException ke) { throw ke; throw new GeneralException(re); } finally { endOperation();
try { _broker.getStoreManager().beforeStateChange(this, _state, state); _broker.addToTransaction(this); if (_state.isDeleted() != wasDeleted) _broker.setDirty(this, !wasDirty || isFlushed()); else if (_state.isDirty() && !wasDirty) _broker.setDirty(this, true); } else if (!wasPending && _state.isPendingTransactional()) _broker.addToPendingTransaction(this); else if (wasPending && !_state.isPendingTransactional()) _broker.removeFromPendingTransaction(this); else _broker.removeFromTransaction(this);
public void evictAll(Collection objs, OpCallbacks call) { List<Exception> exceps = null; beginOperation(false); try { for (Iterator<?> itr = objs.iterator(); itr.hasNext();) { try { evict(itr.next(), call); } catch (UserException ue) { exceps = add(exceps, ue); } } } finally { endOperation(); } throwNestedExceptions(exceps, false); }
public void lock(Object obj, int level, int timeout, OpCallbacks call) { if (obj == null) return; beginOperation(true); try { assertActiveTransaction(); StateManagerImpl sm = getStateManagerImpl(obj, true); if ((processArgument(OpCallbacks.OP_LOCK, obj, sm, call) & OpCallbacks.ACT_RUN) == 0) return; if (sm == null || !sm.isPersistent()) return; _lm.lock(sm, level, timeout, null); sm.readLocked(level, level); // use same level for future write } catch (OpenJPAException ke) { throw ke; } catch (RuntimeException re) { throw new GeneralException(re); } finally { endOperation(); } }
public void nontransactionalAll(Collection objs, OpCallbacks call) { beginOperation(true); try { List<Exception> exceps = null; for (Iterator<?> itr = objs.iterator(); itr.hasNext();) { try { nontransactional(itr.next(), call); } catch (UserException ue) { exceps = add(exceps, ue); } } throwNestedExceptions(exceps, false); } finally { endOperation(); } }
/** * Optimization for single-object refresh. */ protected void refreshInternal(Object obj, OpCallbacks call) { try { StateManagerImpl sm = getStateManagerImpl(obj, true); if ((processArgument(OpCallbacks.OP_REFRESH, obj, sm, call) & OpCallbacks.ACT_RUN) == 0) return; if (sm != null) { if (sm.isDetached()) throw newDetachedException(obj, "refresh"); else if (sm.beforeRefresh(false)) { sm.load(_fc, StateManagerImpl.LOAD_FGS, null, null, false); sm.afterRefresh(); } fireLifecycleEvent(sm.getManagedInstance(), null, sm.getMetaData(), LifecycleEvent.AFTER_REFRESH); } else if (assertPersistenceCapable(obj).pcIsDetached() == Boolean.TRUE) throw newDetachedException(obj, "refresh"); } catch (OpenJPAException ke) { throw ke; } catch (RuntimeException re) { throw new GeneralException(re); } }
public void beginStore() { beginOperation(true); try { assertTransactionOperation(); if ((_flags & FLAG_STORE_ACTIVE) == 0) beginStoreManagerTransaction(false); } catch (OpenJPAException ke) { throw ke; } catch (RuntimeException re) { throw new StoreException(re); } finally { endOperation(); } }
return; beginOperation(true); try { StateManagerImpl sm = getStateManagerImpl(obj, true); if ((processArgument(OpCallbacks.OP_TRANSACTIONAL, obj, sm, call) & OpCallbacks.ACT_RUN) == 0) return; assertActiveTransaction(); sm.transactional(); sm.load(_fc, StateManagerImpl.LOAD_FGS, null, null, false); sm = newStateManagerImpl(id, meta); sm.initialize(assertPersistenceCapable(obj), PCState.TCLEAN); throw new GeneralException(re); } finally { endOperation();
/** * Return the {@link Class} for the given name, or null if name not valid. */ private Class toClass(String name) { if (_loader == null) _loader = _broker.getConfiguration().getClassResolverInstance(). getClassLoader(_class, _broker.getClassLoader()); try { return ClassUtil.toClass(name, _loader); } catch (RuntimeException re) { } catch (NoClassDefFoundError ncdfe) { } return null; }
public void rollback() { beginOperation(false); try { assertTransactionOperation(); javax.transaction.Transaction trans = _runtime.getTransactionManager().getTransaction(); if (trans != null) trans.rollback(); } catch (OpenJPAException ke) { if (_log.isTraceEnabled()) _log.trace(_loc.get("end-trans-error"), ke); throw ke; } catch (Exception e) { if (_log.isTraceEnabled()) _log.trace(_loc.get("end-trans-error"), e); throw new StoreException(e); } finally { endOperation(); } }
public void releaseSavepoint(String savepoint) { beginOperation(false); try { assertActiveTransaction(); int index = (_savepoints == null) ? -1 : _savepoints.indexOf(savepoint); if (index < 0) throw new UserException(_loc.get("no-savepoint", savepoint)); // clear old in reverse OpenJPASavepoint save; while (_savepoints.size() > index + 1) { save = (OpenJPASavepoint) _savepoints.remove (_savepoints.size() - 1); save.release(false); } save = (OpenJPASavepoint) _savepoints.remove(index); save.release(true); if (_savepointCache != null) _savepointCache.clear(); } catch (OpenJPAException ke) { throw ke; } catch (Exception e) { throw new GeneralException(e); } finally { endOperation(); } }
public Object newInstance(Class cls) { assertOpen(); if (!cls.isInterface() && Modifier.isAbstract(cls.getModifiers())) throw new UnsupportedOperationException(_loc.get ("new-abstract", cls).getMessage()); // 1.5 doesn't initialize classes without a true Class.forName if (!PCRegistry.isRegistered(cls)) { try { Class.forName(cls.getName(), true, AccessController.doPrivileged( J2DoPrivHelper.getClassLoaderAction(cls))); } catch (Throwable t) { } } if (_repo.getMetaData(cls, getClassLoader(), false) == null) throw new IllegalArgumentException( _loc.get("no-interface-metadata", cls.getName()).getMessage()); try { return PCRegistry.newInstance(cls, null, false); } catch (IllegalStateException ise) { IllegalArgumentException iae = new IllegalArgumentException(ise.getMessage()); iae.setStackTrace(ise.getStackTrace()); throw iae; } }
/** * Internal delete. */ void delete(Object obj, StateManagerImpl sm, OpCallbacks call) { if (!_operating.add(obj)) return; int action = processArgument(OpCallbacks.OP_DELETE, obj, sm, call); if (action == OpCallbacks.ACT_NONE) return; // ACT_CASCADE if ((action & OpCallbacks.ACT_RUN) == 0) { if (sm != null) sm.cascadeDelete(call); else cascadeTransient(OpCallbacks.OP_DELETE, obj, call, "delete"); return; } // ACT_RUN if (sm != null) { if (sm.isDetached()) throw newDetachedException(obj, "delete"); if ((action & OpCallbacks.ACT_CASCADE) != 0) sm.cascadeDelete(call); sm.delete(); } else if (assertPersistenceCapable(obj).pcIsDetached() == Boolean.TRUE) throw newDetachedException(obj, "delete"); }
public int getLockLevel(Object o) { assertOpen(); if (o == null) return LockLevels.LOCK_NONE; OpenJPAStateManager sm = getStateManager(o); if (sm == null) return LockLevels.LOCK_NONE; return getLockManager().getLockLevel(sm); }
PersistenceCapable pc = assertPersistenceCapable(obj); throw newDetachedException(obj, errOp); StateManagerImpl sm = newStateManagerImpl(StateManagerId. newInstance(this), meta); sm.initialize(pc, PCState.TLOADED);