Interface Summary
Interface	Description
CancelRequestCallback	A class implementing `EReplier` is not required to override `EReplier.cancelRequest(EReplyFeed.ERequest)`.
ECondition	This interface allows `ESubscribeFeed` and `EReplyFeed` to automatically test a message in order to determine if it should be passed on to a client.
EMultiFeed.MultiFeedFactory<M extends EMultiFeed,C extends EMessage,F extends EFeed>	This interface is used by `EMultiFeed` to instantiate a new multi-key, sub-class feed.
EMultiFeed.SubordinateFeedFactory<R extends EObject,F extends net.sf.eBus.client.ESingleFeed>	This interface is used by `EMultiFeed` to instantiate a new subordinate feed for a multi-key feed.
EObject	This interface solves the problem of start up and shutting down from a non-eBus thread.
EPublisher	Classes wanting to send eBus notifications need to implement this interface.
EReplier	Classes able to reply to eBus requests must implement this interface.
ERequestor	Classes wanting to send eBus requests must implement this interface.
ESubscriber	Classes wanting to receive eBus notification messages need to implement this interface.
FeedStatusCallback<T extends IEFeed>	An eBus client implementing either `ESubscriber`, `EPublisher`, or `ERequestor` is not required to override the matching feed status method ( `ESubscriber.feedStatus(EFeedState, IESubscribeFeed)`, `EPublisher.publishStatus(EFeedState, IEPublishFeed)`, or `ERequestor.feedStatus(EFeedState, ERequestFeed)`).
IEFeed	Common base interface for single- and multi-key feeds.
IEPublishFeed	Provides a common view for `EPublishFeed` and `EMultiPublishFeed` feeds.
IEReplyFeed	Provides a common view of single- and multi-key reply feeds, allowing such feeds to be referenced in a common way.
IERequestFeed	Provides a common view of single- and multi-key request feeds, allowing such feeds to be referenced in a common way.
IESubscribeFeed	Provides a common view of single- and multi-key subscription feeds, allowing such feeds to be referenced in a common way.
NotifyCallback	This functional interface may be used to handle notification message delivery instead of `ESubscriber.notify(ENotificationMessage, IESubscribeFeed)` by passing a `NotifyCallback` instance to `ESubscribeFeed.notifyCallback(NotifyCallback)`.
ReplyCallback	This functional interface may be used to handle reply message delivery instead of `ERequestor.reply(int, EReplyMessage, ERequestFeed.ERequest)` by passing a `ReplyCallback` instance to `ERequestFeed.replyCallback(ReplyCallback)`.
RequestCallback	This functional interface may be used to handle request delivery instead of `EReplier.request(EReplyFeed.ERequest)` by passing a `RequestCallback` instance to `EReplyFeed.requestCallback(RequestCallback)`.

Class Summary
Class	Description
AbstractEBusMessage	Base class for eBus `ConnectionMessage` and `ServerMessage` classes.
AbstractEBusMessage.Builder<M extends AbstractEBusMessage,B extends AbstractEBusMessage.Builder<M,?>>	Base class builder for `AbstractEBusMessage` builders.
ConnectionMessage	This message reports when a `remote connection` has either `logged on or logged off`.
ConnectionMessage.Builder	Use this builder to create `ConnectionMessage` instances.
EClient	`EClient` ties together eBus message routing and message processing.
EFeed	Applications interface with eBus through feed instances.
EFeed.AbstractClientTask	Base class for eBus client callback tasks created by feeds.
EMultiFeed<C extends EMessage,F extends net.sf.eBus.client.ESingleFeed>	Multiple key feeds act as a proxy between application objects and multiple subordinate simple feeds (`EPublishFeed`, `ESubscribeFeed`, `EReplyFeed`, and `ERequestFeed`), all for a single message class.
EMultiPublishFeed	This feed allows an `EPublisher` to open one feed for a given notification message class and multiple message subjects.
EMultiReplyFeed	This feed allows an `EReplier` to open one feed for a given request message class and multiple message subjects.
EMultiRequestFeed	This feed acts as a proxy for handling multiple `ERequestFeed`s on behalf of a `ERequestor` client.
EMultiSubscribeFeed	This feeds acts as a proxy for handling multiple `ESubscribeFeed`s on behalf of a `ESubscriber` client.
ENotifyFeed	Abstract base class for `EPublishFeed` and `ESubscribeFeed` classes.
EPublishFeed	`EPublishFeed` is the application entry point for publishing `notification messages` to subscribers.
ERemoteApp	This class encapsulates a connection between eBus applications.
ERemoteAppContext
EReplyFeed	`EReplyFeed` is the application entry point for posting replies to `request messages` to requestors.
EReplyFeed.ERequest	`ERequest` is responsible for matching an `ERequestFeed.ERequest` with a single `EReplyFeed`.
ERequestFeed	`ERequestFeed` is the application entry point for posting `request messages` to repliers.
ERequestFeed.ERequest	This class represents an individual request, tracking the current request state and the remaining repliers.
EServer	Accepts new connections to this eBus application.
ESubscribeFeed	`ESubscribeFeed` is the application entry point for receiving `notification messages`.
ServerMessage	This message reports the `remote Internet address and TCP port` of a connection newly accepted by `EServer` but not yet logged in.
ServerMessage.Builder	Use this builder to create `ServerMessage` instances.
TestPublisherContext
TestReplierContext
TestRequestorContext
TestSubscriberContext

Enum Summary
Enum	Description
ConnectionMessage.ConnectionState	A remote eBus is either logged on or logged off.
EClient.ClientLocation	An eBus client is either local to this JVM or in a remote JVM.
EFeed.FeedScope	Feed scope is either restricted to this JVM, to both this JVM and remote JVMs, and to remote JVMs only.
EFeedState	Enumerates an eBus notification message feed state: either up or down.
ERequestFeed.RequestState	A request is either not placed, active, done, or canceled.
ThreadType	Lists the thread types available to eBus users when configuring eBus.

Package net.sf.eBus.client Description

This package contains the top-level eBus API which applications use to interact with eBus. This interaction is done through EFeed objects. All feed objects are associated with a unique type+topic message key.

Message Key Dictionary

eBus v. 4.5.0 added the ability to directly add messages keys to the eBus message key dictionary and retrieve keys from said dictionary. Prior to this version, message keys were indirectly added to the dictionary when opening feeds. This feature added to support the new multikey feeds. Multi-key feeds may use a query to match a variable number of keys. This is why EFeed#addKey(net.sf.eBus.messages.EMessageKey), EFeed#addAllKeys(java.util.Collection) and EFeed#loadKeys(java.io.ObjectInputStream) methods are provided: unless the message key dictionary is populated with keys prior to creating a multi-key query feed, the query would find no matching keys.

Simple Feeds

A simple feed is associated with a single message key and messages are sent to or received from the feed only after the feed is opened and advertised/subscribed. Simple feeds provide no value added capabilities beyond this.

EPublishFeed: Publishers advertise and publish notification messages via a publish feed instance.
ESubscribeFeed: Subscribers hook into this feed to receive notification messages.
EReplyFeed: Repliers advertise their ability to send reply messages in response to a request messages.
Note that replies are sent back using a EReplyFeed.ERequest and not the EReplyFeed.
ERequestFeed: Requestors place request messages and receive replies using the request feed.

Multi-Key Feeds

eBus v. 4.5.0 introduced multi-key feeds, one for each of the above four simple feeds. A multi-key feed is not a true EFeed subclass but acts as a proxy between an application object and multiple subordinate feeds. The multi-key feed is responsible for keeping the subordinate feeds in the same state (opened, advertised/subscribed, un-advertised/un-subscribed, closed), configuring the subordinate feeds with the same callbacks.

A multi-key feed is configured to work with a single notification/request message class and multiple message subjects. An application object needing a multi-key feed for multiple message classes must open a different multi-key feed for each message class.

The supported multi-key feeds are:

EMultiPublishFeed: uses EPublishFeed subordinate feeds.
EMultiSubscribeFeed: uses ESubscribeFeed subordinate feeds.
EMultiRequestFeed: uses ERequestFeed subordinate feeds.
EMultiReplyFeed: uses EReplyFeed subordinate feeds.

Roles

Each of the above feeds has a matching interface which an application class must implement if it is to work with that feed type:

EPublisher: Required interface for publishing notification messages.
ESubscriber: Required interface for subscribing to notification messages.
EReplier: Required interface for replying to requests.
ERequestor: Required interface for posting requests.

eBus v. 4.2.0 added support for using Java lambda expressions as a callback target. An application still must implement the matching role interface for a given feed but is not required to override interface methods. Instead, an application uses Java lambda expressions to define the callback target. See FeedStatusCallback, NotifyCallback, ReplyCallback, and RequestCallback for more information.

Remote Communication

eBus applications may communicate with one another by establishing TCP connections between them. This is done by having one eBus application open a EServer on a configurable port and the other eBus application open a ERemoteApp to the first application's host address and server port. Note that only one connection is allowed between eBus applications. eBus applications are not allowed to both open server ports and both establish a remote connection to the other.

(Note that all eBus applications are allowed to open an EServer port. But if an eBus application attempts to connect to another application and a connection already exists, then the second connection will be automatically closed.)

An application can monitor eBus connections by creating an ESubscriber which subscribes to ServerMessage.MESSAGE_KEY for EServer events and ConnectionMessage.MESSAGE_KEY for ERemoteApp events.

Applications may configure eBus server and remote connections by using either a properties file, user preferences or programmatically with EConfigure.ServerBuilder and EConfigure.ConnectionBuilder classes. See EConfigure document for a detailed explanation of connection properties. The builders are covered under a their respective documents.