AbstractTransaction (Apache TinkerPop 3.2.1-SNAPSHOT API)

java.lang.Object
- org.apache.tinkerpop.gremlin.structure.util.AbstractTransaction

All Implemented Interfaces:

AutoCloseable, Transaction

Direct Known Subclasses:

AbstractThreadedTransaction, AbstractThreadLocalTransaction
```
public abstract class AbstractTransaction
extends Object
implements Transaction
```
A simple base class for Transaction that provides some common functionality and default behavior. While providers can choose to use this class, it is generally better to extend from AbstractThreadedTransaction or AbstractThreadLocalTransaction which include default "listener" functionality. Implementers should note that this class assumes that threaded transactions are not enabled and should explicitly override createThreadedTx() to implement that functionality if required.

Author:

Stephen Mallette (http://stephen.genoprime.com)

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`AbstractTransaction.TransactionException` An "internal" exception thrown by providers when calls to `doCommit()` or `doRollback()` fail.

Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.structure.Transaction
Transaction.CLOSE_BEHAVIOR, Transaction.Exceptions, Transaction.READ_WRITE_BEHAVIOR, Transaction.Status, Transaction.Workload<R>

Constructor Summary

Constructors
Constructor and Description

AbstractTransaction(Graph g)

Constructors
Constructor and Description
`AbstractTransaction(Graph g)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`close()` Closes the transaction where the default close behavior defined by {`Transaction.onClose(Consumer)`} will be executed.
`void`	`commit()` Commits a transaction.
`<G extends Graph> G`	`createThreadedTx()` Creates a transaction that can be executed across multiple threads.
`protected abstract void`	`doClose()` Called `close()`.
`protected abstract void`	`doCommit()` Called with `commit()` after the `Transaction.onReadWrite(Consumer)` has been notified.
`protected abstract void`	`doOpen()` Called within `open()` if it is determined that the transaction is not yet open given `Transaction.isOpen()`.
`protected abstract void`	`doReadWrite()` Called `readWrite()`.
`protected abstract void`	`doRollback()` Called with `rollback()` after the `Transaction.onReadWrite(Consumer)` has been notified.
`protected abstract void`	`fireOnCommit()` Called within `commit()` just after the internal call to `doCommit()`.
`protected abstract void`	`fireOnRollback()` Called within `rollback()` just after the internal call to `doRollback()` ()}.
`void`	`open()` Opens a transaction.
`void`	`readWrite()` An internal function that signals a read or a write has occurred - not meant to be called directly by end users.
`void`	`rollback()` Rolls back a transaction.
`<R> Transaction.Workload<R>`	`submit(Function<Graph,R> work)` Submit a unit of work that represents a transaction returning a `Transaction.Workload` that can be automatically retried in the event of failure.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.apache.tinkerpop.gremlin.structure.Transaction
addTransactionListener, clearTransactionListeners, isOpen, onClose, onReadWrite, removeTransactionListener

- Constructor Detail
  - AbstractTransaction
```
public AbstractTransaction(Graph g)
```
- Method Detail
  - doOpen
```
protected abstract void doOpen()
```
    Called within open() if it is determined that the transaction is not yet open given Transaction.isOpen(). Implementers should assume the transaction is not yet started and should thus open one.
  - doCommit
```
protected abstract void doCommit()
                          throws AbstractTransaction.TransactionException
```
    Called with commit() after the Transaction.onReadWrite(Consumer) has been notified. Implementers should include their commit logic here.
    
    Throws:
    
    AbstractTransaction.TransactionException
  - doRollback
```
protected abstract void doRollback()
                            throws AbstractTransaction.TransactionException
```
    Called with rollback() after the Transaction.onReadWrite(Consumer) has been notified. Implementers should include their rollback logic here.
    
    Throws:
    
    AbstractTransaction.TransactionException
  - fireOnCommit
```
protected abstract void fireOnCommit()
```
    Called within commit() just after the internal call to doCommit(). Implementations of this method should raise Transaction.Status.COMMIT events to any listeners added via Transaction.addTransactionListener(Consumer).
  - fireOnRollback
```
protected abstract void fireOnRollback()
```
    Called within rollback() just after the internal call to doRollback() ()}. Implementations of this method should raise Transaction.Status.ROLLBACK events to any listeners added via Transaction.addTransactionListener(Consumer).
  - doReadWrite
```
protected abstract void doReadWrite()
```
    Called readWrite(). Implementers should run their readWrite consumer here.
  - doClose
```
protected abstract void doClose()
```
    Called close(). Implementers should run their readWrite consumer here.
  - open
```
public void open()
```
    Opens a transaction.
    
    Specified by:
    
    open in interface Transaction
  - commit
```
public void commit()
```
    Commits a transaction.
    
    Specified by:
    
    commit in interface Transaction
  - rollback
```
public void rollback()
```
    Rolls back a transaction.
    
    Specified by:
    
    rollback in interface Transaction
  - submit
```
public <R> Transaction.Workload<R> submit(Function<Graph,R> work)
```
    Submit a unit of work that represents a transaction returning a Transaction.Workload that can be automatically retried in the event of failure.
    
    Specified by:
    
    submit in interface Transaction
  - createThreadedTx
```
public <G extends Graph> G createThreadedTx()
```
    Creates a transaction that can be executed across multiple threads. The Graph returned from this method is not meant to represent some form of child transaction that can be committed from this object. A threaded transaction is a Graph instance that has a transaction context that enables multiple threads to collaborate on the same transaction. A standard transactional context tied to a Graph that supports transactions will typically bind a transaction to a single thread via ThreadLocal.
    
    Specified by:
    
    createThreadedTx in interface Transaction
  - readWrite
```
public void readWrite()
```
    An internal function that signals a read or a write has occurred - not meant to be called directly by end users.
    
    Specified by:
    
    readWrite in interface Transaction
  - close
```
public void close()
```
    Closes the transaction where the default close behavior defined by {Transaction.onClose(Consumer)} will be executed.
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface Transaction

Class AbstractTransaction

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.tinkerpop.gremlin.structure.Transaction

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.tinkerpop.gremlin.structure.Transaction

Constructor Detail

AbstractTransaction

Method Detail

doOpen

doCommit

doRollback

fireOnCommit

fireOnRollback

doReadWrite

doClose

open

commit

rollback

submit

createThreadedTx

readWrite

close