| Class and Description |
|---|
| WeightedQueue.Weighable |
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Class and Description |
|---|
| AbstractFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| AsyncFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| Awaitable
A generic signal consumer, supporting all of the typical patterns used in Cassandra.
|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| RunnableFuture |
| SyncFuture
Netty's DefaultPromise uses a mutex to coordinate notifiers AND waiters between the eventLoop and the other threads.
|
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| OpOrder
A class for providing synchronization between producers and consumers that do not
communicate directly with each other, but where the consumers need to process their
work in contiguous batches.
|
| OpOrder.Group
Represents a group of identically ordered operations, i.e.
|
| Refs
A collection of managed Ref references to RefCounted objects, and the objects they are referencing.
|
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Semaphore |
| WaitQueue
A relatively easy to use utility for general purpose thread signalling.
|
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Refs
A collection of managed Ref references to RefCounted objects, and the objects they are referencing.
|
| Class and Description |
|---|
| Transactional
An abstraction for Transactional behaviour.
|
| Transactional.AbstractTransactional
A simple abstract implementation of Transactional behaviour.
|
| Class and Description |
|---|
| OpOrder.Group
Represents a group of identically ordered operations, i.e.
|
| Transactional
An abstraction for Transactional behaviour.
|
| Transactional.AbstractTransactional
A simple abstract implementation of Transactional behaviour.
|
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| OpOrder.Barrier
This class represents a synchronisation point providing ordering guarantees on operations started
against the enclosing OpOrder.
|
| OpOrder.Group
Represents a group of identically ordered operations, i.e.
|
| Class and Description |
|---|
| OpOrder.Group
Represents a group of identically ordered operations, i.e.
|
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Refs
A collection of managed Ref references to RefCounted objects, and the objects they are referencing.
|
| Class and Description |
|---|
| OpOrder.Group
Represents a group of identically ordered operations, i.e.
|
| Class and Description |
|---|
| Ref
An object that needs ref counting does the two following:
- defines a Tidy object that will cleanup once it's gone,
(this must retain no references to the object we're tracking (only its resources and how to clean up))
Then, one of two options:
1) Construct a Ref directly pointing to it, and always use this Ref; or
2)
- implements RefCounted
- encapsulates a Ref, we'll call selfRef, to which it proxies all calls to RefCounted behaviours
- users must ensure no references to the selfRef leak, or are retained outside of a method scope.
|
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Class and Description |
|---|
| WeightedQueue.Weighable |
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Class and Description |
|---|
| CountDownLatch |
| Class and Description |
|---|
| Ref.IdentityCollection |
| Transactional
An abstraction for Transactional behaviour.
|
| Transactional.AbstractTransactional
A simple abstract implementation of Transactional behaviour.
|
| Class and Description |
|---|
| Ref.IdentityCollection |
| SharedCloseable
A simple extension of AutoCloseable, that represents a resource that can be utilised in multiple locations,
each managing their own closure of the resource, so that when the last such instance is closed all are.
|
| SharedCloseableImpl
A simple abstract implementation of SharedCloseable
|
| Transactional
An abstraction for Transactional behaviour.
|
| Transactional.AbstractTransactional
A simple abstract implementation of Transactional behaviour.
|
| WrappedSharedCloseable
An implementation of SharedCloseable that wraps a normal AutoCloseable,
ensuring its close method is only called when all instances of SharedCloseable have been
|
| Class and Description |
|---|
| Ref
An object that needs ref counting does the two following:
- defines a Tidy object that will cleanup once it's gone,
(this must retain no references to the object we're tracking (only its resources and how to clean up))
Then, one of two options:
1) Construct a Ref directly pointing to it, and always use this Ref; or
2)
- implements RefCounted
- encapsulates a Ref, we'll call selfRef, to which it proxies all calls to RefCounted behaviours
- users must ensure no references to the selfRef leak, or are retained outside of a method scope.
|
| Ref.IdentityCollection |
| RefCounted
An object that needs ref counting does the two following:
- defines a Tidy object that will cleanup once it's gone,
(this must retain no references to the object we're tracking (only its resources and how to clean up))
Then, one of two options:
1) Construct a Ref directly pointing to it, and always use this Ref; or
2)
- implements RefCounted
- encapsulates a Ref, we'll call selfRef, to which it proxies all calls to RefCounted behaviours
- users must ensure no references to the selfRef leak, or are retained outside of a method scope.
|
| SelfRefCounted |
| Transactional
An abstraction for Transactional behaviour.
|
| Transactional.AbstractTransactional
A simple abstract implementation of Transactional behaviour.
|
| Class and Description |
|---|
| RefCounted
An object that needs ref counting does the two following:
- defines a Tidy object that will cleanup once it's gone,
(this must retain no references to the object we're tracking (only its resources and how to clean up))
Then, one of two options:
1) Construct a Ref directly pointing to it, and always use this Ref; or
2)
- implements RefCounted
- encapsulates a Ref, we'll call selfRef, to which it proxies all calls to RefCounted behaviours
- users must ensure no references to the selfRef leak, or are retained outside of a method scope.
|
| SelfRefCounted |
| Transactional
An abstraction for Transactional behaviour.
|
| Class and Description |
|---|
| Ref.IdentityCollection |
| RefCounted.Tidy |
| SharedCloseable
A simple extension of AutoCloseable, that represents a resource that can be utilised in multiple locations,
each managing their own closure of the resource, so that when the last such instance is closed all are.
|
| SharedCloseableImpl
A simple abstract implementation of SharedCloseable
|
| Transactional
An abstraction for Transactional behaviour.
|
| Transactional.AbstractTransactional
A simple abstract implementation of Transactional behaviour.
|
| Class and Description |
|---|
| AbstractFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| AsyncFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| AsyncPromise
Extends
AsyncFuture to implement the Promise interface. |
| AsyncPromise.WithExecutor |
| Awaitable
A generic signal consumer, supporting all of the typical patterns used in Cassandra.
|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Class and Description |
|---|
| AbstractFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| AsyncFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| Awaitable
A generic signal consumer, supporting all of the typical patterns used in Cassandra.
|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Class and Description |
|---|
| Awaitable
A generic signal consumer, supporting all of the typical patterns used in Cassandra.
|
| Class and Description |
|---|
| Condition
Simpler API than java.util.concurrent.Condition; would be nice to extend it, but also nice
to share API with Future, for which Netty's API is incompatible with java.util.concurrent.Condition
Awaitable for explicit external signals. |
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| IntrusiveStack
An efficient stack/list that is expected to be ordinarily either empty or close to, and for which
we need concurrent insertions and do not need to support removal - i.e.
|
| Class and Description |
|---|
| AbstractFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| AsyncFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| Awaitable
A generic signal consumer, supporting all of the typical patterns used in Cassandra.
|
| Class and Description |
|---|
| CountDownLatch |
| Class and Description |
|---|
| Accumulator
A simple append-only collection supporting an unbounded number of concurrent readers/writers,
but a bounded number of items.
|
| Class and Description |
|---|
| AbstractFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| AsyncFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| Awaitable
A generic signal consumer, supporting all of the typical patterns used in Cassandra.
|
| Class and Description |
|---|
| AbstractFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| AsyncFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| Awaitable
A generic signal consumer, supporting all of the typical patterns used in Cassandra.
|
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Class and Description |
|---|
| NonBlockingRateLimiter
A rate limiter implementation that allows callers to reserve permits that may only be available
in the future, delegating to them decisions about how to schedule/delay work and whether or not
to block execution to do so.
|
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| Ref.IdentityCollection |
| SharedCloseable
A simple extension of AutoCloseable, that represents a resource that can be utilised in multiple locations,
each managing their own closure of the resource, so that when the last such instance is closed all are.
|
| SharedCloseableImpl
A simple abstract implementation of SharedCloseable
|
| WrappedSharedCloseable
An implementation of SharedCloseable that wraps a normal AutoCloseable,
ensuring its close method is only called when all instances of SharedCloseable have been
|
| Class and Description |
|---|
| AbstractFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| AsyncFuture
Our default
Future implementation, with all state being managed without locks (except those used by the JVM). |
| AsyncPromise
Extends
AsyncFuture to implement the Promise interface. |
| Awaitable
A generic signal consumer, supporting all of the typical patterns used in Cassandra.
|
| Awaitable.AbstractAwaitable |
| Awaitable.AsyncAwaitable
A barebones asynchronous
Awaitable. |
| Awaitable.SyncAwaitable
A barebones
Awaitable that uses mutual exclusion. |
| Condition
Simpler API than java.util.concurrent.Condition; would be nice to extend it, but also nice
to share API with Future, for which Netty's API is incompatible with java.util.concurrent.Condition
Awaitable for explicit external signals. |
| Condition.Async
An asynchronous
Condition. |
| ConditionAsConsumer |
| CountDownLatch |
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| FutureCombiner
Netty's PromiseCombiner is not threadsafe, and we combine futures from multiple event executors.
|
| ImmediateFuture |
| IntrusiveStack
An efficient stack/list that is expected to be ordinarily either empty or close to, and for which
we need concurrent insertions and do not need to support removal - i.e.
|
| IntrusiveStack.Setter |
| LoadingMap.UnloadExecutionException
Thrown when unloading a value failed.
|
| NonBlockingRateLimiter
A rate limiter implementation that allows callers to reserve permits that may only be available
in the future, delegating to them decisions about how to schedule/delay work and whether or not
to block execution to do so.
|
| OpOrder.Barrier
This class represents a synchronisation point providing ordering guarantees on operations started
against the enclosing OpOrder.
|
| OpOrder.Group
Represents a group of identically ordered operations, i.e.
|
| Promise
A Promise that integrates
Promise with our Future API
to improve clarity and coherence in the codebase. |
| Ref
An object that needs ref counting does the two following:
- defines a Tidy object that will cleanup once it's gone,
(this must retain no references to the object we're tracking (only its resources and how to clean up))
Then, one of two options:
1) Construct a Ref directly pointing to it, and always use this Ref; or
2)
- implements RefCounted
- encapsulates a Ref, we'll call selfRef, to which it proxies all calls to RefCounted behaviours
- users must ensure no references to the selfRef leak, or are retained outside of a method scope.
|
| Ref.IdentityCollection |
| Ref.OnLeak |
| RefCounted
An object that needs ref counting does the two following:
- defines a Tidy object that will cleanup once it's gone,
(this must retain no references to the object we're tracking (only its resources and how to clean up))
Then, one of two options:
1) Construct a Ref directly pointing to it, and always use this Ref; or
2)
- implements RefCounted
- encapsulates a Ref, we'll call selfRef, to which it proxies all calls to RefCounted behaviours
- users must ensure no references to the selfRef leak, or are retained outside of a method scope.
|
| RefCounted.Tidy |
| Refs
A collection of managed Ref references to RefCounted objects, and the objects they are referencing.
|
| SelfRefCounted |
| Semaphore |
| SharedCloseable
A simple extension of AutoCloseable, that represents a resource that can be utilised in multiple locations,
each managing their own closure of the resource, so that when the last such instance is closed all are.
|
| SharedCloseableImpl
A simple abstract implementation of SharedCloseable
|
| SyncFuture
Netty's DefaultPromise uses a mutex to coordinate notifiers AND waiters between the eventLoop and the other threads.
|
| SyncPromise
Extends
SyncFuture to implement the Promise interface. |
| Transactional
An abstraction for Transactional behaviour.
|
| Transactional.AbstractTransactional.State |
| UncheckedInterruptedException
Unchecked
InterruptedException, to be thrown in places where an interrupt is unexpected |
| WaitQueue
A relatively easy to use utility for general purpose thread signalling.
|
| WaitQueue.Signal
A Signal is a one-time-use mechanism for a thread to wait for notification that some condition
state has transitioned that it may be interested in (and hence should check if it is).
|
| WeightedQueue.Weigher |
| WrappedSharedCloseable
An implementation of SharedCloseable that wraps a normal AutoCloseable,
ensuring its close method is only called when all instances of SharedCloseable have been
|
| Class and Description |
|---|
| Future
A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept,
integrating also with our
Awaitable abstraction, to overall improve coherency and clarity in the codebase. |
| OpOrder.Group
Represents a group of identically ordered operations, i.e.
|
| WaitQueue
A relatively easy to use utility for general purpose thread signalling.
|
| Class and Description |
|---|
| Ref.IdentityCollection |
Copyright © 2009-2022 The Apache Software Foundation