# All Classes

- All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary
  Class | Description
  --- | ---
  AbortOnlyException | An `IllegalTxnStateException` thrown when a `Txn` is configured as abort only and a prepare/commit is executed.
  AbstractGammaObject |
  AbstractGammaTxnExecutor | An abstract `GammaTxnExecutor` implementation.
  AbstractTxnCollection<E> |
  AbstractTxnIterator<E> |
  AbstractTxnMap<K,​V> |
  AtomicOperationException | A `TxnExecutionException` thrown when an atomic operation has failed (e.g.
  BackoffPolicy | A policy to be used when `Txn` or an atomic operation can't make any progress, e.g.
  BaseGammaTxnRef |
  BinaryFunction<E> |
  BooleanFunction | A `Function` for primitives that accepts an argument of type boolean and returns a new value of the same type.
  BooleanPredicate | A predicate that checks if some value leads to true or false.
  Bugshaker | Contains some utility functions for shaking out bugs.
  CallableNode |
  CommitBarrier | A CommitBarrier is a blocking structure like the `CyclicBarrier` but tailored to work with transactions.
  CommitBarrierOpenException | An IllegalStateException that indicates that an operation was executed on the CommitBarrier while it already is opened.
  ControlFlowError | An `Error` thrown to regulate control flow inside multiverse `TxnExecutor`.
  CountDownCommitBarrier | A synchronization aid that allows a set of threads and transaction to all wait for each other to reach a common barrier point; once this barrier is opened, all transaction atomically commit.
  DeadTxnException | An `IllegalTxnStateException` thrown when an action is executed on a `Txn` that is either committed or aborted.
  DefaultBackoffPolicy | A `BackoffPolicy` that does an 'exponential' backoff.
  DefaultRetryLatch | A Cheap `RetryLatch` implementation based on the intrinsic lock.
  DoubleFunction | A `Function` for primitives that accepts an argument of type double and returns a new value of the same type.
  DoublePredicate | A predicate that checks if some value leads to true or false.
  FatFixedLengthGammaTxn | A Fat `GammaTxn` (supporting all features) but has a fixed capacity.
  FatGammaTxnExecutor | The `TxnExecutor` made for the GammaStm.
  FatMonoGammaTxn |
  FatVariableLengthGammaTxn |
  Function<E> | A Function that accepts an argument of a certain type and returns a new value of the same type.
  Functions | A utility class for `Function` functionality.
  GammaConstants | Contains the constants for the `GammaStm`.
  GammaObject |
  GammaObjectPool | A pool for tranlocals.
  GammaOrElseBlock |
  GammaStm |
  GammaStmConfig | Contains the default configuration for all transactions created by the GammaStm.
  GammaStmUtils |
  GammaTxn | Abstract GammaTxn to be used by all the concrete GammaTxn implementations.
  GammaTxnBoolean | A `TxnBoolean` for the `GammaStm`.
  GammaTxnConfig | A configuration object that contains the configuration for a GammaTxn.
  GammaTxnDouble |
  GammaTxnExecutor | An `TxnExecutor` tailored for the GammaStm.
  GammaTxnFactory | A `TxnFactory` tailored for the `GammaStm`.
  GammaTxnFactoryBuilder | A `TxnFactoryBuilder` tailored for the `GammaStm`.
  GammaTxnInteger |
  GammaTxnLong | A `TxnLong` for the `GammaStm`.
  GammaTxnPool | A pool for pooling GammaTxns.
  GammaTxnRef<E> | A `TxnRef` tailored for the `GammaStm`.
  GammaTxnRefFactory | A `TxnRefFactory` tailored for the GammaStm.
  GammaTxnRefFactoryBuilder | A `TxnRefFactoryBuilder` tailored for the GammaStm.
  GlobalConflictCounter | The GlobalConflictCounter is used as a mechanism for guaranteeing read consistency.
  GlobalStmInstance | A singleton that can be used for easy access to the `Stm` that is used globally.
  IllegalCommuteException | A `TxnExecutionException` thrown when `Txn` access is done while a commuting function is being evaluated.
  IllegalTxnFactoryException | An `IllegalStateException` thrown when a `TxnFactory` can't be created because the `TxnConfig` is not correct.
  IllegalTxnStateException | A `TxnExecutionException` thrown when an operation is executed on a `Txn` when it is not in a valid state for that operation.
  IncIntFunction | A `IntFunction` that increased the value with the supplied amount.
  IntFunction | A `Function` for primitives that accepts an argument of type int and returns a new value of the same type.
  IntPredicate | A predicate that checks if some value leads to true or false.
  InvisibleCheckedException | A `RuntimeException` thrown when a checked exception is thrown but can't be rethrown.
  IsolationLevel | With the IsolationLevel you have a way to provide declarative control to guarantee isolation between transactions.
  LeanFixedLengthGammaTxn | A Lean GammaTxn that is optimized for a fixed number of GammaTxnRefs.
  LeanGammaTxnExecutor | The `TxnExecutor` made for the GammaStm.
  LeanMonoGammaTxn | A Lean GammaTxn implementation that is optimized for dealing with only a single transactional reference.
  Listeners | A Listeners object contains all the Latches of blockingAllowed transactions that listen to a write on a transactional object.
  Lock | The Lock provides access to pessimistic behavior of a `TxnObject`.
  LockedException | An `AtomicOperationException` thrown when an atomic operation was executed on a `TxnObject` while it was locked.
  LockMode | Using the LockMode one can control the pessimistic nature of a `Txn`.
  LongFunction | A `Function` for primitives that accepts an argument of type long and returns a new value of the same type.
  LongPredicate | A predicate that checks if some value leads to true or false.
  MultiverseConstants | An interface containing global constants.
  NaiveTxnCollectionFactory |
  NaiveTxnHashMap<K,​V> |
  NaiveTxnHashSet<E> |
  NaiveTxnLinkedList<E> | A LinkedList implementation that also acts as a TxnQueue, TxnDeque.
  NaiveTxnStack<E> |
  OrElseBlock | The OrElse is responsible for executing the either block, or in case of a retry, the orelse block is executed.
  PanicError | An `Error` thrown when the state of the `Stm` has been compromised.
  Predicate<E> | A predicate that checks if some value leads to true or false.
  Predicates | Predicate utility class.
  PreparedTxnException | An `IllegalTxnStateException` thrown when an operation is executed on a `Txn` while the transaction is prepared.
  PropagationException | An `IllegalStateException` throw when there is a conflict with the `Txn` propagation.
  PropagationLevel | With the PropagationLevel you have control on how the `TxnExecutor` reacts on the existence or the non existence of a `Txn`.
  ReadonlyException | An `IllegalTxnStateException` thrown when a write action is executed using a readonly `Txn`.
  ReadWriteConflict | A `ControlFlowError` thrown when a reading or writing a `TxnObject` failed, e.g.
  RetryError | A `ControlFlowError` thrown when an explicit retry is done on a `Txn`.
  RetryException | A `TxnExecutionException` thrown when retrying a transaction for another attempt fails.
  RetryInterruptedException | A `RetryException` thrown when the blocking operation on a `Txn` using the retry has been interrupted.
  RetryLatch | A blockingAllowed structure that can be used to create blocking transactions.
  RetryNotAllowedException | A `RetryException` thrown when a `StmUtils.retry()` or `Txn.retry()` is done while the `Txn` doesn't allow blocking transactions.
  RetryNotPossibleException | A `RetryException` throw when a `StmUtils.retry()` or `Txn.retry()` done on a `Txn` without the possibility of progress, for example when the readset of a transaction is empty.
  RetryTimeoutException | A `RetryException` thrown when a transaction times out while it blocks on a retry (so waits for an update).
  SpeculativeConfigurationError | A `ControlFlowError` thrown for dealing with the speculative configuration mechanism.
  SpeculativeGammaConfiguration | The GammaStm uses a speculative mechanism (if enabled) to learn from executing transactions.
  StandardThreadFactory | A customizable implementation of the `ThreadFactory`.
  Stm | The main interface for software transactional memory.
  StmMismatchException | A `TxnExecutionException` thrown when a transaction encounters encounters a transactional object that belongs to a different Stm instance.
  StmUtils | A utility class with convenience methods to access the `Stm` or `Txn`.
  ThreadLocalGammaObjectPool | A ThreadLocal that contains the `GammaObjectPool`.
  ThreadLocalGammaTxnPool | A ThreadLocal that stores the `GammaTxnPool`.
  ThreadLocalRandom |
  TodoException | A `RuntimeException` thrown when some part of the implementation is missing.
  ToolUnsafe | A Utility class for accessing the `Unsafe`.
  TooManyRetriesException | A `RetryException` thrown when a `Txn` is retried too many times.
  TraceLevel | Using the TraceLevel you get some feedback on what is happening inside a transaction.
  Tranlocal<E> |
  Txn | The unit of work for `Stm`.
  TxnBoolean | A Transactional Reference comparable to the Clojure Ref.
  TxnBooleanCallable | A transactional callable contains the logic that needs to be executed transactionally and normally is executed by the `TxnExecutor`.
  TxnCallable<E> | A transactional callable contains the logic that needs to be executed transactionally and normally is executed by the `TxnExecutor`.
  TxnCollection<E> |
  TxnCollectionsFactory | A factory responsible for creating Transactional collections.
  TxnConfig | Contains the transaction configuration used by a `Txn`.
  TxnDeque<E> |
  TxnDouble | A Transactional Reference comparable to the Clojure Ref.
  TxnDoubleCallable | A transactional callable contains the logic that needs to be executed transactionally and normally is executed by the `TxnExecutor`.
  TxnEvent | An enumeration for all possible events for the `Txn` life-cycle.
  TxnExecutionException | A `RuntimeException` thrown when something fails while executing a `Txn`.
  TxnExecutor | An TxnExecutor is responsible for executing an atomic callable.
  TxnFactory | A Factory responsible for creating a `Txn`.
  TxnFactoryBuilder | A Builder for creating a `TxnFactory` and `TxnExecutor`.
  TxnIntCallable | A transactional callable contains the logic that needs to be executed transactionally and normally is executed by the `TxnExecutor`.
  TxnInteger | A Transactional Reference comparable to the Clojure Ref.
  TxnIterable<E> |
  TxnIterator<E> |
  TxnList<E> |
  TxnListener | A listener tailored for listening to events in the `Txn` life-cycle.
  TxnLong | A Transactional Reference comparable to the Clojure Ref.
  TxnLongCallable | A transactional callable contains the logic that needs to be executed transactionally and normally is executed by the `TxnExecutor`.
  TxnMandatoryException | A `PropagationException` thrown when no `Txn` is available while it is mandatory.
  TxnMap<K,​V> |
  TxnNotAllowedException | A `PropagationException` thrown when a `Txn` is found, but is not allowed.
  TxnObject | The interface each transactional object needs to implement.
  TxnQueue<E> |
  TxnRef<E> | A Transactional Reference comparable to the Clojure Ref.
  TxnRefFactory | A Factory for creating references.
  TxnRefFactoryBuilder | A Builder for creating a `TxnRefFactory`.
  TxnSet<E> |
  TxnStack<E> |
  TxnStatus | An enumeration of all possible states a `Txn` can have.
  TxnThreadLocal | A `ThreadLocal` that contains the current `Txn`.
  TxnThreadLocal.Container |
  TxnVoidCallable | A transactional callable contains the logic that needs to be executed transactionally and normally is executed by the `TxnExecutor`.
  VetoCommitBarrier | The VetoCommitBarrier is a synchronization primitive that makes it possible to execute a 2 phase commit; so all transaction within a VetoCommitBarrier commit, or they all abort.