Source artifact /private/tmp/play-electives-artifacts/ebean-core-15.1.0-sources.jar sha256 91e3b542f3245bd703b94a71ed27bf7f5b83f3bc9598d9a29949830167e45575
io/ebeaninternal/api/ScopedTransaction.java
20: 
21:   /**
22:    * Flag set when we clear the thread scope (on commit/rollback or end).
23:    */
24:   private boolean scopeCleared;
25: 
26:   public ScopedTransaction(TransactionScopeManager manager) {
27:     this.manager = manager;
28:   }
29: 
30:   @Override
31:   public String toString() {
32:     return "ScopedTransaction " + current;
33:   }
34: 
35:   @Override
36:   public void setNestedUseSavepoint() {
37:     current.setNestedUseSavepoint();
38:   }
39: 
40:   @Override
41:   public boolean isNestedUseSavepoint() {
42:     return current.isNestedUseSavepoint();
43:   }
io/ebeaninternal/api/ScopedTransaction.java
61:    * Exiting an enhanced transactional method.
62:    */
63:   public void complete(Object returnOrThrowable, int opCode) {
64:     current.complete(returnOrThrowable, opCode);
65:     // no finally here for pop() as we come in here twice if an
66:     // error is thrown on commit (due to enhancement finally block)
67:     pop();
68:   }
69: 
70:   /**
71:    * Internal programmatic complete - finally block, try to commit.
72:    */
73:   public void complete() {
74:     try {
75:       current.complete();
76:     } finally {
77:       pop();
78:     }
79:   }
80: 
81:   private void clearScopeOnce() {
82:     if (!scopeCleared) {
83:       manager.clear();
84:       scopeCleared = true;
io/ebeaninternal/api/ScopedTransaction.java
71:    * Internal programmatic complete - finally block, try to commit.
72:    */
73:   public void complete() {
74:     try {
75:       current.complete();
76:     } finally {
77:       pop();
78:     }
79:   }
80: 
81:   private void clearScopeOnce() {
82:     if (!scopeCleared) {
83:       manager.clear();
84:       scopeCleared = true;
85:     }
86:   }
87: 
88:   private boolean clearScope() {
89:     if (stack.isEmpty()) {
90:       clearScopeOnce();
91:       return true;
92:     }
93:     return false;
94:   }
io/ebeaninternal/api/ScopedTransaction.java
116: 
117:   @Override
118:   public void commit() {
119:     try {
120:       current.commitTransaction();
121:     } finally {
122:       clearScope();
123:     }
124:   }
125: 
126:   @Override
127:   public void rollbackAndContinue() {
128:     transaction.rollbackAndContinue();
129:   }
130: 
131:   @Override
132:   public void rollback() throws PersistenceException {
133:     try {
134:       current.rollback(null);
135:     } finally {
136:       clearScope();
137:     }
138:   }
139: 
io/ebeaninternal/api/ScopedTransaction.java
125: 
126:   @Override
127:   public void rollbackAndContinue() {
128:     transaction.rollbackAndContinue();
129:   }
130: 
131:   @Override
132:   public void rollback() throws PersistenceException {
133:     try {
134:       current.rollback(null);
135:     } finally {
136:       clearScope();
137:     }
138:   }
139: 
140:   @Override
141:   public void rollback(Throwable e) throws PersistenceException {
142:     try {
143:       current.rollback(e);
144:     } finally {
145:       clearScope();
146:     }
147:   }
148: 
io/ebeaninternal/api/ScopedTransaction.java
126:   @Override
127:   public void rollbackAndContinue() {
128:     transaction.rollbackAndContinue();
129:   }
130: 
131:   @Override
132:   public void rollback() throws PersistenceException {
133:     try {
134:       current.rollback(null);
135:     } finally {
136:       clearScope();
137:     }
138:   }
139: 
140:   @Override
141:   public void rollback(Throwable e) throws PersistenceException {
142:     try {
143:       current.rollback(e);
144:     } finally {
145:       clearScope();
146:     }
147:   }
148: 
149:   @Override
io/ebeaninternal/api/ScopedTransaction.java
130: 
131:   @Override
132:   public void rollback() throws PersistenceException {
133:     try {
134:       current.rollback(null);
135:     } finally {
136:       clearScope();
137:     }
138:   }
139: 
140:   @Override
141:   public void rollback(Throwable e) throws PersistenceException {
142:     try {
143:       current.rollback(e);
144:     } finally {
145:       clearScope();
146:     }
147:   }
148: 
149:   @Override
150:   public void setRollbackOnly() {
151:     current.setRollbackOnly();
152:   }
153: 
io/ebeaninternal/api/ScopedTransaction.java
132:   public void rollback() throws PersistenceException {
133:     try {
134:       current.rollback(null);
135:     } finally {
136:       clearScope();
137:     }
138:   }
139: 
140:   @Override
141:   public void rollback(Throwable e) throws PersistenceException {
142:     try {
143:       current.rollback(e);
144:     } finally {
145:       clearScope();
146:     }
147:   }
148: 
149:   @Override
150:   public void setRollbackOnly() {
151:     current.setRollbackOnly();
152:   }
153: 
154:   /**
155:    * Return the current transaction.
io/ebeaninternal/api/ScopedTransaction.java
139: 
140:   @Override
141:   public void rollback(Throwable e) throws PersistenceException {
142:     try {
143:       current.rollback(e);
144:     } finally {
145:       clearScope();
146:     }
147:   }
148: 
149:   @Override
150:   public void setRollbackOnly() {
151:     current.setRollbackOnly();
152:   }
153: 
154:   /**
155:    * Return the current transaction.
156:    */
157:   public SpiTransaction current() {
158:     return transaction;
159:   }
160: 
161:   /**
162:    * Rollback for Error.
io/ebeaninternal/api/ScopedTransaction.java
141:   public void rollback(Throwable e) throws PersistenceException {
142:     try {
143:       current.rollback(e);
144:     } finally {
145:       clearScope();
146:     }
147:   }
148: 
149:   @Override
150:   public void setRollbackOnly() {
151:     current.setRollbackOnly();
152:   }
153: 
154:   /**
155:    * Return the current transaction.
156:    */
157:   public SpiTransaction current() {
158:     return transaction;
159:   }
160: 
161:   /**
162:    * Rollback for Error.
163:    */
164:   public Error caughtError(Error e) {
io/ebeaninternal/api/ScopedTransaction.java
167: 
168:   /**
169:    * Maybe rollback based on TxScope rollback on settings.
170:    */
171:   public Exception caughtThrowable(Exception e) {
172:     return current.caughtThrowable(e);
173:   }
174: 
175:   /**
176:    * New user objects are always written to the current ScopeTrans.
177:    */
178:   @Override
179:   public void putUserObject(String name, Object value) {
180:     current.putUserObject(name, value);
181:   }
182: 
183:   /**
184:    * Returns the userObject in the stack, Herew we search
185:    * the stack and return the first found userObject
186:    */
187:   @Override
188:   public Object getUserObject(String name) {
189:     Object obj = current.getUserObject(name);
190:     if (obj != null) {
io/ebeaninternal/server/core/DefaultServer.java
628: 
629:   @Override
630:   public <T> T executeCall(Callable<T> callable) {
631:     return executeCall(null, callable);
632:   }
633: 
634:   @Override
635:   public <T> T executeCall(@Nullable TxScope scope, Callable<T> callable) {
636:     ScopedTransaction scopeTrans = transactionManager.beginScopedTransaction(scope);
637:     try {
638:       return callable.call();
639:     } catch (Error e) {
640:       throw scopeTrans.caughtError(e);
641:     } catch (Exception e) {
642:       throw new PersistenceException(scopeTrans.caughtThrowable(e));
643:     } finally {
644:       scopeTrans.complete();
645:     }
646:   }
647: 
648:   @Override
649:   public void execute(Runnable runnable) {
650:     execute(null, runnable);
651:   }
io/ebeaninternal/server/core/DefaultServer.java
633: 
634:   @Override
635:   public <T> T executeCall(@Nullable TxScope scope, Callable<T> callable) {
636:     ScopedTransaction scopeTrans = transactionManager.beginScopedTransaction(scope);
637:     try {
638:       return callable.call();
639:     } catch (Error e) {
640:       throw scopeTrans.caughtError(e);
641:     } catch (Exception e) {
642:       throw new PersistenceException(scopeTrans.caughtThrowable(e));
643:     } finally {
644:       scopeTrans.complete();
645:     }
646:   }
647: 
648:   @Override
649:   public void execute(Runnable runnable) {
650:     execute(null, runnable);
651:   }
652: 
653:   @Override
654:   public void execute(@Nullable TxScope scope, Runnable runnable) {
655:     ScopedTransaction t = transactionManager.beginScopedTransaction(scope);
656:     try {
io/ebeaninternal/server/core/DefaultServer.java
647: 
648:   @Override
649:   public void execute(Runnable runnable) {
650:     execute(null, runnable);
651:   }
652: 
653:   @Override
654:   public void execute(@Nullable TxScope scope, Runnable runnable) {
655:     ScopedTransaction t = transactionManager.beginScopedTransaction(scope);
656:     try {
657:       runnable.run();
658:     } catch (Error e) {
659:       throw t.caughtError(e);
660:     } catch (Exception e) {
661:       throw new PersistenceException(t.caughtThrowable(e));
662:     } finally {
663:       t.complete();
664:     }
665:   }
666: 
667:   @Override
668:   public void scopedTransactionEnter(TxScope txScope) {
669:     beginTransaction(txScope);
670:   }
io/ebeaninternal/server/core/DefaultServer.java
652: 
653:   @Override
654:   public void execute(@Nullable TxScope scope, Runnable runnable) {
655:     ScopedTransaction t = transactionManager.beginScopedTransaction(scope);
656:     try {
657:       runnable.run();
658:     } catch (Error e) {
659:       throw t.caughtError(e);
660:     } catch (Exception e) {
661:       throw new PersistenceException(t.caughtThrowable(e));
662:     } finally {
663:       t.complete();
664:     }
665:   }
666: 
667:   @Override
668:   public void scopedTransactionEnter(TxScope txScope) {
669:     beginTransaction(txScope);
670:   }
671: 
672:   @Override
673:   public void scopedTransactionExit(Object returnOrThrowable, int opCode) {
674:     transactionManager.exitScopedTransaction(returnOrThrowable, opCode);
675:   }
io/ebeaninternal/api/ScopeTrans.java
121:     }
122:     complete();
123:   }
124: 
125:   /**
126:    * Complete the transaction programmatically. Try to commit.
127:    */
128:   public void complete() {
129:     if (!rolledBack) {
130:       commitTransaction();
131:     }
132:   }
133: 
134:   public void end() {
135:     if (created || !nestedCommit) {
136:       transaction.end();
137:     }
138:   }
139: 
140:   void commitTransaction() {
141:     if (created) {
142:       transaction.commit();
143:     } else {
144:       nestedCommit = true;
145:       transaction.setFlushOnQuery(restoreBatchFlushOnQuery);
146:       if (restoreBatch != null) {
147:         transaction.setBatchMode(restoreBatch);
148:       }
149:       if (restoreBatchOnCascade != null) {
150:         transaction.setBatchOnCascade(restoreBatchOnCascade);
151:       }
152:       if (restoreBatchSize > 0) {
153:         transaction.setBatchSize(restoreBatchSize);
154:       }
