org.apache.tinkerpop.gremlin.structure.util

Class AbstractTransaction

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)

Method Summary

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