All Classes and Interfaces
Class
Description
Partial SendActionManager implementation which
uses the Asynchronous Call/Response delivery pattern.
Partial implementation of MessageHandler interface which helps to ensure
correct client behaviour.
Utility class to facilitate constructing a SampXmlRpcHandler which handles
particular named methods.
SampXmlRpcClient implementation based on Apache XMLRPC classes.
SampXmlRpcClientFactory implementation based on Apache XMLRPC classes.
SampXmlRpcServer implementation based on Apache XML-RPC library.
SampXmlRpcServerFactory implementation which uses Apache classes.
ResourceBundle for internationalising the Web Profile authorization
dialogue.
AuthResourceBundle with German text.
AuthResourceBundle with English text.
AuthResourceBundle with French text.
AuthResourceBundle with English text.
Defines the keys and value types required for a bundle of this class.
Basic ClientSet implementation.
HubService implementation.
Runs a bridging service between two or more hubs.
Runs a load of Calculator clients at once all sending messages to each other.
Test client.
Represents a delivery pattern.
Defines callbacks which the hub can make on a callable client.
Describes an application registered with a SAMP hub.
Defines authorization functionality which is used to determine whether
a client is permitted to register with the hub.
Utility class containing ClientAuthorizer implementations.
Component which displays details about a
Client.Defines an object that can be used to register with a running SAMP hub.
Data structure for keeping track of clients currently registered with a hub.
Marks a HubProfile that can also provide GUI-based configuration.
HttpServer which allows or rejects cross-origin access according to
the W3C Cross-Origin Resource Sharing standard.
Extracts credentials for presentation to the user from available
information, so that the user can decide whether to allow registration.
Aggregates credential information to be presented to the user.
Unchecked exception thrown when a data structure for use with
SAMP does not have the correct form.
Factory which supplies the default ClientProfile for use by SAMP clients.
Handler implementation which allows the server to serve a directory
full of resources.
Represents the error information associated with a SAMP response.
Dialog window which displays an error message, possibly with some
verbose details optionally visible.
Client authorizer implementation that does its very best to discourage
users from accepting regitrations.
HubService that provides hub functionality by accessing an existing
hub service.
Extends HubConnector to provide additional graphical functionality.
BasicHubService subclass which provides a GUI window displaying hub
status as well as the basic hub services.
Simple modular HTTP server.
Implemented to serve data for some URLs.
Represents a parsed HTTP client request.
Represents a response to an HTTP request.
Class which manages a hub and its associated profiles.
Represents a client registered with a hub.
Represents a registered client's connection to a running hub.
Manages a client's connection to SAMP hubs.
Deprecated.
Client application which uses a
GuiHubConnector
to connect to any running hub and display information about all currently
registered clients.Defines a hub profile.
Factory to produce hub profiles of a particular type.
Deprecated.
use
Hub insteadInterface defining the work that the hub has to do.
Specifies a particular hub implementation for use with
Hub.ClientAuthorizer implementation that queries the user for permission
via a popup dialogue.
Tester for a running hub.
Component displaying a list of SAMP
Clients,
usually those registered with a hub.Manages client icons.
SendActionManager which uses the Asynchronous Call/Response delivery
pattern, but allows a "broadcast" to send different message objects
to different recipients.
XML-RPC client implementation suitable for use with SAMP.
Freestanding SampXmlRpcClientFactory implementation.
SampXmlRpcServer implementation without external dependencies.
Freestanding SampXmlRpcServerFactory implementation.
Convenience class for invoking JSAMP command-line applications.
Object which can generate a sequence of private keys.
General purpose implementation of MessageRestriction.
Represents the information read from a SAMP Standard Profile Lockfile.
Writes records to a SAMP Standard Profile hub lockfile.
CorsHttpServer subclass which performs logging to a given print stream
at the HTTP level.
ResultHandler implementation which outputs some information about
responses received through the logging system.
Represents an encoded SAMP Message.
Interface for a client which wishes to receive messages.
Specifies restrictions on the message types that may be sent in
a particular context.
Sends a message to one or more other SAMP clients.
HubConnector implementation which provides facilities for keeping track
of incoming and outgoing messages as well as the other GUI features.
GuiHubService subclass which additionally keeps track of which messages
have been sent and received, and can provide a graphical display of these.
Represents the application metadata associated with a SAMP client.
Handler implementation which allows the server to serve multiple
separate resources which are available to it, but not necessarily to
external clients, as URLs.
SendActionManager subclass which works with messages of a single MType,
using the Notify delivery pattern.
HTTP resource handler suitable for serving static cross-origin policy files.
Controls which origins are authorized to perform cross-origin access
to resources.
Utility class containing OriginAuthorizer implementations.
Platform-dependent features required by the SAMP implementation.
ResultHandler which pops up a window displaying progress and success
of a message sent to one or many recipients.
Marker interface that identifies a hub profile.
Represents information provided to a client at registration by the hub.
Handler implementation which implements dynamic resource provision.
Defines one of the types of resource that can be turned into a
SAMP load-type message.
Represents an encoded SAMP response.
Interface for a client which wishes to receive responses to message it
has sent asynchrnonously using
call or callAll.Interface which consumes call responses.
InternalClient subclass which additionally logs all XML-RPC calls/responses
to an output stream.
Freestanding ClientFactory implementation which logs all XML-RPC
calls/responses to standard output.
InternalServer subclass which additionally logs all XML-RPC calls/responses
to an output stream.
Freestanding ServerFactory implementation which logs all XML-RPC
calls/responses to standard output.
Exception thrown when some error occurs in SAMP processing.
Dialog window for sending a fixed load-type message to a selected
client or clients.
Abstract superclass for objects represented within the SAMP package as
key-value maps.
Contains static utility methods for use with the SAMP toolkit.
Interface for a client which can make XML-RPC calls for SAMP.
Defines a factory which can create clients for communication with
XML-RPC servers.
Interface for an object which can process certain XML-RPC requests.
Interface for a server which can respond to XML-RPC calls for SAMP.
Defines a factory for SampXmlRpcServer instances.
ListModel implementation which sits on top of an existing ListModel
containing
Clients, but only includes a
subset of its elements.Manages actions to send SAMP messages to one or all recipients.
Defines a resource suitable for serving by the
ResourceHandler
HTTP server handler.Handles ordered running of cleanup processes at JVM shutdown.
Subscribes to SAMP messages and logs any received to an output stream.
Standard Profile implementation of ClientProfile.
HubProfile implementation for the SAMP Standard Profile.
HubProfileFactory implementation for Standard Profile.
Selective client list model which contains only those non-self clients
which are subscribed to one or more of a given list of MTypes.
Represents the set of subscribed messages for a SAMP client.
Provides basic access to the windowing system's System Tray.
No-frills test case superclass.
Exception thrown by a failed test.
Collection of Client objects which can be notified and interrogated
about the clients which are currently registered.
Describes the properties of a message which has been sent from one
client to another.
Describes the status of a transmission in terms that can be
presented in the GUI.
Icon which paints a graphical representation of a list of Transmissions.
Component which displays the details of a given Transmission object.
SendActionManager subclass which works with messages of a single MType,
using the Aysnchronous Call/Response delivery pattern.
Handler implementation which allows the server to serve resources which
are available to it as URLs.
Keeps track of which URLs have been seen in communications inbound to
and outbound from Web Profile clients.
Utility class for use with HttpServer.
ClientProfile implementation for Web Profile.
CredentialPresenter for use with the Web Profile.
HubProfile implementation for Web Profile.
Creates and configures the HTTP server on which the Web Profile resides.
HubProfileFactory implementation for Web Profile.
SampXmlRpcHandler implementation which passes Web Profile-type XML-RPC calls
to a hub connection factory to provide a Web Profile hub server.
InternalClient subclass which additionally logs all XML-RPC calls/responses
to an output stream.
Freestanding ClientFactory implementation which logs all incoming
and outgoing HTTP data.
Freestanding InternalServer implementation which logs all incoming
and outgoing HTTP data.
Freestanding ServerFactory implementation which logs all incoming
and outgoing HTTP data.
Represents the content of an XML-RPC methodCall element.
Partial HubConnection implementation based on XML-RPC.
Encapsulates the provision of XML-RPC client and server capabilities.
Utilities for XML manipulations required by SAMP/XML-RPC.
HubServiceModewithHubinstead