All Classes

Aggregates information required for handling responses which correspond to a particular message tag.

Utility class to facilitate constructing a SampXmlRpcHandler which handles particular named methods.

Characterises a method signature.

SampXmlRpcClientFactory implementation based on Apache XMLRPC classes.

Convenience class which aggregates a WebServer and an endpoint.

Provides utility methods to perform translations between the data structurs used by the org.apache.xmlrpc classes and those used by JSAMP.

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.

HubService implementation.

Encapsulates information about a MessageId.

BrowserLauncher is a class that provides one static method, openURL, which opens the default web browser for the current user of the system to the given URL.

Test client.

Defines callbacks which the hub can make on a callable client.

Map representing a client callback from the hub.

Defines the methods which an XML-RPC callable client must implement.

Utility class containing ClientAuthorizer implementations.

List Cell Renderer for use with Client objects.

Defines an object that can be used to register with a running SAMP hub.

Message handler which watches hub event messages to keep track of what clients are currently registered and what their attributes are on behalf of the hub.

Data structure for holding ClientOperation objects which (may) need to be applied in the future.

Provides the means to obtain list models containing pending sent and received transmissions.

Implementation of the ClientActor interface which does the work for this class.

Marks a HubProfile that can also provide GUI-based configuration.

Unchecked exception thrown when a data structure for use with SAMP does not have the correct form.

Represents the error information associated with a SAMP response.

Client authorizer implementaion that does its very best to discourage users from accepting regitrations.

Utility HubConnection class which allows hub event notifications to be sent to clients.

Extends HubConnector to provide additional graphical functionality.

TrackedClientSet implementation used by this class.

Simple modular HTTP server.

Convenience class for representing an error whose content should be returned to the user as an HTTP erro response of some kind.

Represents a parsed HTTP client request.

Class which manages a hub and its associated profiles.

CallableClient implementation used by the hub client.

MouseListener which provides a popup menu with per-client options for use with a JList containing HubClient objects.

Manages a client's connection to SAMP hubs.

HubMode implemenetation for modes which cannot be used because they rely on classes unavailable at runtime.

Defines a hub profile.

Specifies a particular hub implementation for use with Hub.

HubServiceMode implementation for modes which cannot be used because they rely on classes unavailable at runtime.

Aggregates a HubService and an associated monitor/control window.

Utility abstract class to define an object which can be tidied up on hub shutdown.

Tester for a running hub.

CallableClient implementation for testing.

Component displaying a list of SAMP Clients, usually those registered with a hub.

Implementation of the HubActor interface which does the work for this class.

Component which displays the contents of a ListModel as icons.

Convenience struct-type class which aggregates an icon and a tooltip.

Icon implementation which looks like an existing one, but is resized down if necessary.

XML-RPC client implementation suitable for use with SAMP.

Freestanding SampXmlRpcClientFactory implementation.

Freestanding SampXmlRpcServerFactory implementation.

Simple JSON parser which only copes with SAMP-friendly JSON, that is strings, lists and objects.

Outputs a SAMP object as JSON.

General purpose implementation of MessageRestriction.

Writes records to a SAMP Standard Profile hub lockfile.

OutputStream subclass which counts the number of bytes it is being asked to write, but otherwise does nothing.

Represents an encoded SAMP Message.

Specifies restrictions on the message types that may be sent in a particular context.

MessageSender implementation which uses the Asynchronous Call/Response pattern.

Map implementation which dispenses its contents via an iterator which will block until all the results are in.

Client implementation which may know about metadata.

MessageSender implementation which uses the Synchronous Call/Response pattern.

GuiHubService subclass which additionally keeps track of which messages have been sent and received, and can provide a graphical display of these.

ListCellRenderer which draws a representation of incoming and outgoing messages alongside the default representation.

Implements MType for querying registered clients by metadata item.

SendActionManager subclass which works with messages of a single MType, using the Notify delivery pattern.

Controls which origins are authorized to perform cross-origin access to resources.

Implements samp.app.ping MType.

Thread which reads the contents of a stream into a string buffer.

Platform implementation for Microsoft Windows-like systems.

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.

Interface for a client which wishes to receive responses to message it has sent asynchrnonously using call or callAll.

InternalClient subclass which additionally logs all XML-RPC calls/responses to an output stream.

InternalServer subclass which additionally logs all XML-RPC calls/responses to an output stream.

Exception thrown when some error occurs in SAMP processing.

Helper class for performing a SAMP operation from within the Event Dispatch Thread.

Interface for a client which can make XML-RPC calls for SAMP.

Interface for an object which can process certain XML-RPC requests.

Defines a factory for SampXmlRpcServer instances.

Manages actions to send SAMP messages to one or all recipients.

Defines a resource suitable for serving by the ResourceHandler HTTP server handler.

Aggregates a runnable and an associated sequence value.

Standard Profile implementation of ClientProfile.

HubProfile implementation for the SAMP 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.

OriginAuthorizer which uses a popup dialogue to ask the user.

Implementation which provides system tray access using J2SE 1.6 classes by reflection.

No-frills test case superclass.

SampXmlrpcClient implementation for testing success or failure of XML-RPC method invocations.

Describes the properties of a message which has been sent from one client to another.

CellRenderer for transmission objects.

Component which displays the details of a given Transmission object.

Template custom TableCellRenderer for subclassing.

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.

HubConnection wrapper implementation which intercepts all incoming and outgoing communications, scans them for URLs in the payload, and notifies a supplied UrlTracker object.

CallableClient implementation used internally by the Web Profile hub.

Defines the XML-RPC methods which must be implemented by a Web Profile hub.

Thread that performs repeated long polls to pull callbacks from the hub and passes them on to this connection's CallableClient for execution.

Helper class to generate toggle button models for hub configuration.

HubProfileFactory implementation for Web Profile.

Utility class to aggregate information about a registered client.

WebHubActor implementation.

HubConnection implementation that delegates all calls to a base instance.

Freestanding ClientFactory implementation which logs all incoming and outgoing HTTP data.

Freestanding ServerFactory implementation which logs all incoming and outgoing HTTP data.

Exception thrown when an XML document which is intended for XML-RPC processing has the wrong format, for instance violates the XML-RPC spec.

Encapsulates the provision of XML-RPC client and server capabilities.

XmlRpcKit implementation which always returns false from isAvailable and throws exceptions from getServer/Client factory methods.

Utility class for writing XML.