All Classes and Interfaces
Class
Description
Convenient base class for ClientServices providing some default ClientService
interface implementations as well as a few convenience methods
such as getServiceManager() and getService(type).
Convenient base class for HostedServices providing some default HostedService
interface implementations as well as a few convenience methods
such as getServiceManager() and getService(type).
Convenient base class for HostedServices providing some default HostedService
interface implementations as well as a few convenience methods
such as getServiceManager() and getService(type).
Base implementation of the Kernel interface providing several
useful default implementations of some methods.
Interface implemented by all network messages.
A MessageListener implementation that will forward messages to methods
of a delegate object.
Base class providing some default Service interface implementations
as well as a few convenience methods such as getServiceManager()
and getService(type).
Array serializer
Indicates that a given method should be executed asynchronously
through the RMI service.
Boolean serializer.
Byte serializer.
Internal type denoting the type of call to make when remotely
invoking methods.
Contains information about any extra server channels (if they exist).
Char serializer.
Internal information about a shared class.
Internal registry of shared types and their ClassInfo and MethodInfo
objects.
Represents a remote connection to a server that can be used
for sending and receiving messages.
Client registration is a message that contains a unique ID.
A message-specific serializer to avoid compatibility issues
between versions.
Interface implemented by Client-side services that augment
a network Client's functionality.
Manages ClientServices on behalf of a network Client object.
Listener that is notified about the connection state of
a Client.
Provided with the clientDisconnected() notification to
include additional information about the disconnect.
Serializes collections.
CompressedMessage is a base class for all messages that
compress others.
Listener that is notified about connection arrivals and
removals within a server.
A single channel remote connection allowing the sending
and receiving of data.
Wraps a single Connector and forwards new messages
to the supplied message dispatcher.
Represents a client-side connection error, usually encapsulating
an IOException as its cause.
Creates Connectors for a specific host.
Date serializer.
A default implementation of the Client interface that delegates
its network connectivity to a kernel.Connector.
A default implementation of the Server interface that delegates
its network connectivity to kernel.Kernel.
Represents a disconnect message.
A message-specific serializer to avoid compatibility issues
between versions.
Double serializer.
An abstract endpoint in a Kernel that can be used for
sending/receiving messages within the kernel space.
Provides information about an added or
removed connection.
Enum serializer.
Encapsulates a received piece of data.
Notified when errors happen on a connection.
The field serializer is the default serializer used for custom class.
Determines a true or false value for a given input.
Static utility methods pertaining to Filter instances.
Float serializer.
A MessageBuffer implementation that will aggressively create
all messages as byte data comes in.
GZIPCompressedMessage is the class that you need to use should you want to
compress a message using Gzip.
Serializes GZIP messages.
This is the connection back to a client that is being
hosted in a server instance.
Interface implemented by Server-side services that augment
a network Server's functionality.
Manages HostedServices on behalf of a network Server object.
The Integer serializer serializes...integers.
Defines the basic byte[] passing messaging
kernel.
Wraps a single Kernel and forwards new messages
to the supplied message dispatcher and new endpoint
events to the connection dispatcher.
Represents a kernel-level error, usually encapsulating
an IOException as its cause.
Supplied to the DefaultServer to create any additional
channel kernels that might be required.
A MessageBuffer implementation that will deserialize messages as they
are returned instead of deserializing them as the data comes in.
Describes an RMI interface on the local machine.
The Long serializer.
Interface implemented by all network messages.
Accumulates network data into Message objects.
The source of a received message and the common abstract interface
of client->server and server->client objects.
Listener notified about new messages.
Keeps track of message listeners registered to specific
types or to any type.
Consolidates the conversion of messages to/from byte buffers
and provides a rolling message buffer.
Method definition is used to map methods on an RMI interface
to an implementation on a remote machine.
Internal information about shared methods.
A simple factory that delegates to java.util.concurrent's
default thread factory but adds a prefix to the beginning
of the thread name.
The main service provider for conveniently creating
server and client instances.
A Client whose network connection information can
be provided post-creation.
Endpoint implementation that encapsulates the
channel IO based connection information and keeps
track of the outbound data queue for the channel.
KernelFactory implementation for creating TCP kernels
using the NIO selector model.
A MessageListener implementation that will forward messages to methods
of a specified delegate object.
Sent to a remote client to make a remote method invocation.
Contains the return value for a remote method invocation, sent as a response
to a
RemoteMethodCallMessage with a non-zero invocationID.Contains various meta-data about an RMI interface.
Sent to expose RMI interfaces on the local client to other clients.
Used internally to remotely invoke methods on RMI shared objects.
A service that can be added to the client to support a simple
shared objects protocol.
Keeps track of the current connection performing a particular
RMI call.
A service that can be added to the host to support a simple
shared objects protocol.
RmiSerializer is responsible for serializing RMI messages
like define object, call, and return.Used internally to send RPC call information to
the other end of a connection for execution.
RPC service that can be added to a network Client to
add RPC send/receive capabilities.
Wraps a message connection to provide RPC call support.
Implementations of this interface can be registered with
the RpcClientService or RpcHostService to handle the
remote procedure calls for a given object or objects.
RPC service that can be added to a network Server to
add RPC send/receive capabilities.
Used internally to send an RPC call's response back to
the caller.
A Kernel implementation based on NIO selectors.
Use this annotation when a class is going to be transferred
over the network.
Serializes uses Java built-in method.
The main serializer class, which will serialize objects such that
they can be sent across the network.
A general exception from the serialization routines.
Implements a MessageProtocol providing message serializer/deserialization
based on the built-in Serializer code.
A SerializerRegistration represents a connection between a class, and
its serializer.
Holds a compiled set of message registration information that
can be sent over the wire.
Represents a host that can send and receive messages to
a set of remote client connections.
The base interface for managed services.
The base service manager class from which the HostedServiceManager
and ClientServiceManager classes are derived.
A MessageListener implementation that will forward messages to methods
of a delegate specified as a HostedConnection session attribute.
Short serializer.
A straight forward socket-based connector implementation that
does not use any separate threading.
String serializer.
Creates TCP connectors to a specific remote address.
A straight forward datagram socket-based UDP connector
implementation.
Endpoint implementation that encapsulates the
UDP connection information for return messaging,
identification of envelope sources, etc.
A Kernel implementation using UDP packets.
Compress a message using this ZIPCompressedMessage class
Serializes ZIP messages.