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/interfaces inherited from interface org.apache.tinkerpop.gremlin.structure.Transaction

      `Transaction.CLOSE_BEHAVIOR, Transaction.Exceptions, Transaction.READ_WRITE_BEHAVIOR, Transaction.Status`

  - ### Constructor Summary

    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.

    - ### 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 TransactionException

      Called with `commit()` after the `Transaction.onReadWrite(Consumer)` has been notified. Implementers should include their commit logic here.
      Throws:
        `TransactionException`

    - #### doRollback

          protected abstract void doRollback()
                                      throws TransactionException

      Called with `rollback()` after the `Transaction.onReadWrite(Consumer)` has been notified. Implementers should include their rollback logic here.
      Throws:
        `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. This method may optionally throw `TransactionException` on error. Providers should consider wrapping their transaction exceptions in this TinkerPop exception as it will lead to better error handling with Gremlin Server and other parts of the stack.
      Specified by:
        `commit` in interface `Transaction`

    - #### rollback

          public void rollback()

      Rolls back a transaction. This method may optionally throw `TransactionException` on error. Providers should consider wrapping their transaction exceptions in this TinkerPop exception as it will lead to better error handling with Gremlin Server and other parts of the stack.
      Specified by:
        `rollback` 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`

Copyright © 2013–2020 Apache Software Foundation. All rights reserved.