@Override public boolean isPessimisticLockingValueHolder() { return ((DatabaseValueHolder)this.unitOfWorkValueHolder).isPessimisticLockingValueHolder(); }
/** * INTERNAL: * Answers if this valueholder is a pessimistic locking one. Such valueholders * are special in that they can be triggered multiple times by different * UnitsOfWork. Each time a lock query will be issued. Hence even if * instantiated it may have to be instantiated again, and once instantatiated * all fields can not be reset. */ public boolean isPessimisticLockingValueHolder() { // This abstract method needs to be implemented but is not meaningfull for // this subclass. return ((this.wrappedValueHolder != null) && (this.wrappedValueHolder instanceof DatabaseValueHolder) && ((DatabaseValueHolder)this.wrappedValueHolder).isPessimisticLockingValueHolder()); }
/** * INTERNAL: * Answers if this valueholder is a pessimistic locking one. Such valueholders * are special in that they can be triggered multiple times by different * UnitsOfWork. Each time a lock query will be issued. Hence even if * instantiated it may have to be instantiated again, and once instantatiated * all fields can not be reset. */ public boolean isPessimisticLockingValueHolder() { // This abstract method needs to be implemented but is not meaningfull for // this subclass. return ((this.wrappedValueHolder != null) && (this.wrappedValueHolder instanceof DatabaseValueHolder) && ((DatabaseValueHolder)this.wrappedValueHolder).isPessimisticLockingValueHolder()); }
@Override public boolean isPessimisticLockingValueHolder() { return ((DatabaseValueHolder)this.unitOfWorkValueHolder).isPessimisticLockingValueHolder(); }
/** * INTERNAL: * Answers if this valueholder is a pessimistic locking one. Such valueholders * are special in that they can be triggered multiple times by different * UnitsOfWork. Each time a lock query will be issued. Hence even if * instantiated it may have to be instantiated again, and once instantatiated * all fields can not be reset. */ public boolean isPessimisticLockingValueHolder() { // This abstract method needs to be implemented but is not meaningfull for // this subclass. return ((getWrappedValueHolder() != null) && (getWrappedValueHolder() instanceof DatabaseValueHolder) && ((DatabaseValueHolder)getWrappedValueHolder()).isPessimisticLockingValueHolder()); }
/** * INTERNAL: * Answers if this valueholder is a pessimistic locking one. Such valueholders * are special in that they can be triggered multiple times by different * UnitsOfWork. Each time a lock query will be issued. Hence even if * instantiated it may have to be instantiated again, and once instantatiated * all fields can not be reset. * Note: This method is not thread-safe. It must be used in a synchronizaed manner */ public boolean isPessimisticLockingValueHolder() { // This abstract method needs to be implemented but is not meaningfull for // this subclass. if (getWrappedServerValueHolder() != null) { return ((getWrappedServerValueHolder() instanceof DatabaseValueHolder) && ((DatabaseValueHolder)getWrappedServerValueHolder()).isPessimisticLockingValueHolder()); } else { // Pessimistic locking may not be supported on remote sessions, but if // it is make every attempt to do the right thing. return ((getQuery() != null) && getQuery().isLockQuery(getSession())); } }
/** * INTERNAL: * Answers if this valueholder is a pessimistic locking one. Such valueholders * are special in that they can be triggered multiple times by different * UnitsOfWork. Each time a lock query will be issued. Hence even if * instantiated it may have to be instantiated again, and once instantatiated * all fields can not be reset. * Note: This method is not thread-safe. It must be used in a synchronizaed manner */ public boolean isPessimisticLockingValueHolder() { // This abstract method needs to be implemented but is not meaningfull for // this subclass. if (getWrappedServerValueHolder() != null) { return ((getWrappedServerValueHolder() instanceof DatabaseValueHolder) && ((DatabaseValueHolder)getWrappedServerValueHolder()).isPessimisticLockingValueHolder()); } else { // Pessimistic locking may not be supported on remote sessions, but if // it is make every attempt to do the right thing. return ((getQuery() != null) && getQuery().isLockQuery(getSession())); } }
/** * INTERNAL: * Answers if this valueholder is a pessimistic locking one. Such valueholders * are special in that they can be triggered multiple times by different * UnitsOfWork. Each time a lock query will be issued. Hence even if * instantiated it may have to be instantiated again, and once instantatiated * all fields can not be reset. * Note: This method is not thread-safe. It must be used in a synchronizaed manner */ public boolean isPessimisticLockingValueHolder() { // This abstract method needs to be implemented but is not meaningfull for // this subclass. if (getWrappedServerValueHolder() != null) { return ((getWrappedServerValueHolder() instanceof DatabaseValueHolder) && ((DatabaseValueHolder)getWrappedServerValueHolder()).isPessimisticLockingValueHolder()); } else { // Pessimistic locking may not be supported on remote sessions, but if // it is make every attempt to do the right thing. return ((getQuery() != null) && getQuery().isLockQuery(getSession())); } }
UnitOfWorkImpl unitOfWork = getUnitOfWork(); if (!wrapped.isEasilyInstantiated()) { if (wrapped.isPessimisticLockingValueHolder()) { if (!unitOfWork.getCommitManager().isActive() && !unitOfWork.wasTransactionBegunPrematurely()) { unitOfWork.beginEarlyTransaction();
UnitOfWorkImpl unitOfWork = getUnitOfWork(); if (!wrapped.isEasilyInstantiated()) { if (wrapped.isPessimisticLockingValueHolder()) { if (!unitOfWork.getCommitManager().isActive() && !unitOfWork.wasTransactionBegunPrematurely()) { unitOfWork.beginEarlyTransaction();
UnitOfWorkImpl unitOfWork = getUnitOfWork(); if (!wrapped.isEasilyInstantiated()) { if (wrapped.isPessimisticLockingValueHolder()) { if (!unitOfWork.getCommitManager().isActive() && !unitOfWork.wasTransactionBegunPrematurely()) { unitOfWork.beginEarlyTransaction();