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.
CommitBarrier.Status
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.
Functions.IdentityDoubleFunction
Functions.IncDoubleFunction
Functions.IncIntFunction
Functions.IncLongFunction
GammaConstants	Contains the constants for the `GammaStm`.
GammaObject
GammaObjectPool	A pool for tranlocals.
GammaOrElseBlock
GammaStm
GammaStm.NonSpeculativeGammaTxnFactory
GammaStm.SpeculativeGammaTxnFactory
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>
NaiveTxnHashSet.It<E>
NaiveTxnLinkedList<E>	A LinkedList implementation that also acts as a TxnQueue, TxnDeque.
NaiveTxnLinkedList.Entry<E>
NaiveTxnStack<E>
NaiveTxnStack.It<E>
NaiveTxnStack.Node<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.