All Classes and Interfaces
Class
Description
Abstract base class of handler mappings, which are
using reflection.
An object implementing this interface may be used
to validate user names and passwords.
A callback interface for an asynchronous XML-RPC call.
Abstract base implementation of
TypeParser
for parsing an atomic value.The default instance of
XmlWriterFactory creates
instances of XMLWriterImpl.Parser for BigDecimal values.
A
TypeSerializer for BigDecimal.Parser for BigInteger values.
A
TypeSerializer for BigInteger.Parser for boolean values.
A
TypeSerializer for booleans.A parser for base64 elements.
A
TypeSerializer for byte arrays.Parser for integer values.
A
TypeSerializer for date values.An implementation of
XmlWriterFactory,
which creates instances of
CharSetXMLWriter.The
ClientFactory is a useful tool for simplifying the
use of Apache XML-RPC.Handler for a single clients connection.
Parser for integer values.
A
TypeSerializer for date values.The default implementation of
XmlWriterFactory
tests, whether the CharSetXmlWriterFactory
is usable.Parser for double values.
A
TypeSerializer for doubles.Base class for parsing external XML representations, like DOM,
or JAXB.
Base class for external XML representations, like DOM,
or JAXB.
Parser for float values.
A
TypeSerializer for floats.Stub implementation of a
HttpServletRequest
with lots of unimplemented methods.Stub implementation of a
HttpServletResponse
with lots of unimplemented methods.Provides utility functions useful in HTTP communications
Parser for byte values.
A
TypeSerializer for bytes.Parser for short values.
A
TypeSerializer for shorts.Parser for integer values.
A
TypeSerializer for integers.Parser for long values.
A
TypeSerializer for longs.A parser for JAXB objects.
A serializer for JAXB objects.
A type factory with support for JAXB objects.
A filtering
InputStream for proper handling of
the Content-Length header: It guarantees to return
at most a given number of bytes.A
TypeSerializer for lists.Implementation of
ServerStreamConnection for
use by the
XmlRpcLocalStreamTransport.Parser for long values.
TypeParser implementation
for maps.A
TypeSerializer for maps.A parser for DOM document.
The node serializer is serializing a DOM node.
SAX parser for a nil element (null value).
A
TypeSerializer for null values.Parser for an array of objects, as created by
ObjectArraySerializer.A
TypeSerializer for object arrays.A handler mapping based on a property file.
Abstract base class of a parser, that invokes other type
parsers recursively.
A utility class for using reflection.
Default implementation of
XmlRpcHandler.Default implementation of
XmlRpcMetaDataHandler.Web servers extension of
XmlRpcHttpRequestConfig,
which allows to store additional per request data.The request processor is the object, which is actually performing
the request.
This is the factory for request processors.
This is the default implementation of
RequestProcessorFactoryFactory.This is an alternative implementation of
RequestProcessorFactoryFactory.Utility class for working with SAX parsers.
A parser for serializable objects.
A
TypeSerializer for
instances of Serializable.Interface of a
ServerStreamConnection for HTTP
response transport.Interface of an object, which is able to provide
an XML stream, containing an XML-RPC request.
ServletWebServer's
ThreadPool.Task for handling a single
servlet connection.Default implementation of a servlet output stream.
This is a subclass of the
WebServer, which offers a minimal
servlet API.This exception is thrown by the request handling classes,
advising the server, that it should return an error response.
Parser implementation for parsing a string.
A
TypeSerializer for strings.Simple thread pool.
A task, which may be interrupted, if the pool is shutting down.
The thread pool contains instances of
ThreadPool.Task.A callback object that can wait up to a specified amount
of time for the XML-RPC response.
This exception is thrown, if the request times out.
A
TypeConverter is used when actually calling the
handler method or actually returning the result object.A
TypeConverterFactory is called for creating instances
of TypeConverter.Default implementation of
TypeConverterFactory.A type factory creates serializers or handlers, based on the object
type.
Default implementation of a type factory.
Interface of a SAX handler parsing a single parameter or
result object.
Abstract base implementation of a
TypeParser,
for derivation of subclasses.A
TypeSerializer is able to write a parameter
or result object to the XML RPC request or response.Abstract base implementation of a type serializer.
Utility class, which provides services to meta data
handlers and handler mappings.
The
WebServer is a minimal HTTP server, that might be used
as an embedded web server.The main access point of an XML-RPC client.
This interface is being implemented by an Apache XML-RPC clients
configuration object.
Default implementation of a clients request configuration.
This class is responsible to provide default settings.
This is thrown by many of the client classes if an error occured processing
and XML-RPC request or response due to client side processing.
Default implementation of
XmlRpcRequest.Object, which performs a request on the clients behalf.
A worker factory for the client, creating instances of
XmlRpcClientWorker.An HTTP transport factory, which is based on the Jakarta Commons
HTTP Client.
An HTTP transport factory, which is based on the Jakarta Commons
HTTP Client.
A common base interface for
XmlRpcClientConfig, and
XmlRpcServerConfig.Default implementation of
XmlRpcConfig.A common base class for
XmlRpcServer and
XmlRpcClient.An extension of
XmlRpcDateTimeFormat, which accepts
and/or creates instances of Date.An instance of
Format, which may be used
to parse and format dateTime values, as specified
by the XML-RPC specification.Instances of this class can be used to customize the servers
error logging.
This exception is thrown by the XmlRpcClient, if an invocation of the
remote method failed.
This exception is thrown, if an attempt to use extensions
is made, but extensions aren't explicitly enabled.
The XML-RPC server uses this interface to call a method of an RPC handler.
Maps from a handler name to a handler object.
Extension of
XmlRpcClientConfig
for HTTP based transport.Interface of a configuration for HTTP requests.
Extension of
XmlRpcClientConfig
for HTTP based transport.Default implementation of a request configuration.
Abstract extension of
XmlRpcStreamServer for deriving
HTTP servers.HTTP servers configuration.
Abstract base implementation of an HTTP transport.
Exception thrown if the HTTP status code sent by the server
indicates that the request could not be processed.
This exception is thrown, if the server catches an exception, which
is thrown by the handler.
This is a subclass of
IOException, which
allows to attach a linked exception.A listable handler mapping is able to provide support for
XML-RPC meta data, as specified
here.
A "light" HTTP transport implementation for Java 1.4.
Java 1.4 specific factory for the lite HTTP transport,
XmlRpcLiteHttpTransport.A "light" HTTP transport implementation.
Factory for the lite HTTP transport,
XmlRpcLiteHttpTransport.This exception is thrown, if the clients or servers maximum
number of concurrent threads is exceeded.
Interface of a client configuration for local rpc calls.
Server part of a local stream transport.
Another local transport for debugging and testing.
Another local transport factory for debugging and testing.
The default implementation of a local transport.
A transport factory being used for local XML-RPC calls.
A metadata handler is able to provide metadata about
itself, as specified
here.
This exception is thrown, if an unknown handler is called.
This exception must be thrown, if the user isn't authenticated.
Interface to an XML-RPC request made by a client.
Interface of a request configuration.
A SAX parser for an
XmlRpcClient's
request.Interface of an object, which is able to process
XML-RPC requests.
Interface of an object, which may be used
to create instances of
XmlRpcRequestProcessor.A SAX parser for an
XmlRpcServer's
response.A multithreaded, reusable XML-RPC server object.
Server specific extension of
XmlRpcConfig.Default implementation of
XmlRpcServerConfig.Server specific implementation of
XmlRpcWorker.Server specific worker factory.
A default servlet implementation The typical use would
be to derive a subclass, which is overwriting at least the
method
XmlRpcServlet.newXmlRpcHandlerMapping().An extension of
XmlRpcServer,
which is suitable for processing servlet requests.Interface of a configuration for a stream based transport.
Interface of a client configuration for a transport, which
is implemented by writing to a stream.
An instance of
XmlRpcRequestProcessor,
which is processing an XML stream.Extension of
XmlRpcServer with support for reading
requests from a stream and writing the response to another
stream.Implementation of a transport class, which is based on an output
stream for sending the request and an input stream for receiving
the response,
Abstract base implementation of a factory for stream transports.
Default implementation of an HTTP transport in Java 1.4, based on the
HttpURLConnection class.Default implementation of an HTTP transport factory in Java 1.4, based
on the
HttpURLConnection class.Default implementation of an HTTP transport in Java 1.4, based on the
HttpURLConnection class.Default implementation of an HTTP transport in Java 1.5, based on the
HttpURLConnection class.Default implementation of an HTTP transport, based on the
HttpURLConnection class.Default implementation of a HTTP transport factory, based on the
HttpURLConnection class.This class implements the various "system" calls,
as specifies by
XmlRpcListableHandlerMapping.Interface from XML-RPC to an underlying transport, most likely based on HTTP.
Interface of an object creating instances of
XmlRpcTransport.Abstract base implementation of an
XmlRpcTransportFactory.Abstract base implementation of an
XmlRpcTransport.An object, which executes requests on the controllers
behalf.
A factory for
XmlRpcWorker instances.This class is responsible for writing an XmlRpc request or an
XmlRpc response to an output stream.
This factory is responsible for creating instances of
XMLWriter.