{@link Action} is a void consumer. It does not take any parameters and does not return any value.

{@link AfterWriteAction} denotes an action that will be executed in the writer thread once the write is successfully completed to the destination. <p>

{@link BufferedChannel} is an implementation of a {@link Channel} that has a fixed size buffer backing it. Once the buffer is full subsequent attempts

{@link Channel} is equivalent of a Golang channel in Java. It behaves like a queue on which messages can be passed from one thread to another. The cha

{@link ChannelAction} is a combination of a {@link Channel} and a {@link Consumer} that will be executed on each message of the channel.

An {@link Iterator} for {@link BufferedChannel}. It is a blocking iterator, where if there is no message on the channel, the iterator will block until

Exception thrown in case of attempting to operate on a {@link Channel} which has already been closed.

{@link Copier} provides the mechanism by which a {@link Channel} copies the incoming message to it's in-memory data-structure. @param <T> The type of

{@link JachChannels} is a utility class to access most of the common features without the explicit need for calling complex constructors or methods.

{@link JachTime} contains utility methods which exposes methods related to time using {@link Channel}.

{@link KryoCopier} uses Kryo serializer to do a deep copy of the object. For more information about Kryo, please check https://github.com/EsotericSoft

Exception thrown when the channel is closed while iterating over a {@link Channel}. It is thrown by the channel's iterator, but using forEach method w

{@link Readable} interface denotes a data-structure which can be used to read messages from some source. This interface is for internal purposes and s

{@link RefCopier} is the simplest {@link Copier} that returns the same object reference as the parameter. {@link RefCopier} is an identity function.

{@link Routines} are interfaces that are equivalent of go-routines.

{@link Selector} is used to run a select call over multiple {@link Channel}s and take action based on which channel a message appears (through a set o

{@link Timer} represents a single event. It is always instantiated with a fixed duration, after which it sends an event to it's channel and can option

{@link TooManySelectorException} is thrown when a particular {@link Channel} is used in too many {@link Selector}s and the system cannot sustain it.

{@link UnbufferedChannel} is a special {@link Channel} where only one message can be written and subsequent writes block until that message is read by

{@link Writable} interface denotes a data-structure which can be used to write messages which can then be read using a {@link Readable}. This interfac