All Classes and Interfaces
Class
Description
Beta Abstract base class for an Atom feed parser when the feed type is known in advance.
Abstract data store implementation.
Abstract data store factory implementation.
Tests
DataStoreFactory.Abstract implementation of an HTTP content with typical options.
Serializes HTTP request content from an input stream into an output stream.
Abstract test case for testing a
JsonFactory.Abstract, thread-safe, in-memory implementation of a data store factory.
Beta Abstract serializer for XML HTTP content based on the data key/value mapping object for an item.
Thread-safe HTTP transport based on the Apache HTTP Client library.
Builder for
ApacheHttpTransport.Memory-efficient map of keys to values with list-style random-access semantics.
Collects the array values of a key/value data object, writing the fields or map values only after
all values have been collected.
Array values on a particular field.
Beta Atom Utilities.
Beta Serializes Atom XML HTTP content based on the data key/value mapping object for an Atom entry.
Beta Atom feed pull parser when the Atom entry class is known in advance.
Back-off policy when retrying an operation.
Deprecated.
Proxy for version 1.6 (or newer) of the Apache Commons Codec
Base64 implementation.Basic authentication HTTP request initializer as specified in Basic Authentication Scheme
Use this annotation to indicate that a public API (class, method or field) is beta.
Findbugs plugin detector which detects usage of
Beta in your code.Concrete implementation of
AbstractInputStreamContent that generates repeatable input
streams based on the contents of byte array.Streaming content whose source is a byte array.
Output stream that throws away any content and only retains the count of bytes written to the
stream.
Provides utility methods for working with byte arrays and I/O streams.
Utility functions for dealing with
CharEscapers, and some commonly used
CharEscaper instances.Contains constant definitions for some standard
Charset instances that are guaranteed to
be supported by all Java platform implementations.Computes class information to determine data key name/value pairs associated with the class.
Clock which can be used to get the amount of elapsed milliseconds in system time.
Static utility methods pertaining to
Collection instances.Given a
URL instance, produces an HttpURLConnection.Beta Customizes the behavior of a JSON parser.
Utilities for working with key/value data based on the
Key annotation.Map that uses
ClassInfo to parse the key/value pairs into a map for use in
Data.mapOf(Object).Stores and manages serializable data of a specific type, where the key is a string and the value
is a
Serializable object.Factory for a store that manages serializable data, where the key is a string and the value is a
Serializable object.Utilities for data stores.
Immutable representation of a date with an optional time and an optional time zone based on RFC 3339.
Default implementation of
ConnectionFactory, which simply attempts to open the connection
with an optional Proxy.Empty HTTP content of length zero just to force
HttpRequest.execute() to add the header
Content-Length: 0.An object that converts literal text into a format safe for inclusion in a particular context
(such as an XML document).
Implementation of
BackOff that increases the back off period for each retry attempt using
a randomization function that grows exponentially.Builder for
ExponentialBackOff.Deprecated.
(scheduled to be removed in 1.18).
Deprecated.
Parses field information to determine data key name/value pair associated with the field.
Concrete implementation of
AbstractInputStreamContent that generates repeatable input
streams based on the contents of a file.Thread-safe file implementation of a credential store.
File data store that inherits from the abstract memory data store because the key-value pairs
are stored in a memory cache, and saved in the file (see
FileDataStoreFactory.FileDataStore.save() when changing values.Beta A thread-safe fixed time implementation of the Clock to be used for unit testing.
Generic data that stores all unknown data key name/value pairs.
Flags that impact behavior of generic data.
Generic JSON data that stores all unknown key name/value pairs.
URL builder in which the query parameters are specified as generic data key/value pairs, based on
the specification RFC 3986: Uniform Resource
Identifier (URI).
Beta Generic XML data that stores all unknown key name/value pairs.
Low-level JSON library implementation based on GSON.
Holder for the result of
GsonFactory.getDefaultInstance().Low-level JSON serializer implementation based on GSON.
Hack to support numbers encoded as a string for JsonWriter.
Low-level JSON serializer implementation based on GSON.
GZip HTTP content encoding.
Serializes HTTP request content into an output stream.
HTTP content encoding.
Streaming content based on an HTTP encoding.
HTTP request execute interceptor to intercept the start of
HttpRequest.execute() before
executing the HTTP request.HTTP extension method.
Stores HTTP headers used in an HTTP request or response, as defined in Header Field Definitions.
LowLevelHttpRequest which will call the .parseHeader() method for every header added.
State container for
HttpHeaders.parseHeader(String, String, ParseHeaderState).HTTP Media-type as specified in the HTTP RFC (
}).
invalid @link
{@link "http://tools.ietf.org/html/rfc2616#section-3.7"
HTTP request method constants specified in RFC 2616 Section 5.1.1.
HTTP request.
Thread-safe light-weight HTTP request factory layer on top of the HTTP transport that has an
optional
HTTP request initializer for initializing requests.HTTP request initializer.
HTTP response.
Exception thrown when an error status code is detected in an HTTP response.
Builder.
HTTP response interceptor to intercept the end of
HttpRequest.execute() before returning
a successful response or throwing an exception for an unsuccessful response.Constants enumerating the HTTP status codes.
Beta Utilities and constants related to testing the HTTP library.
Thread-safe abstract HTTP transport.
Interface which handles abnormal HTTP responses (in other words not 2XX).
Concrete implementation of
AbstractInputStreamContent that simply handles the transfer of
data from an input stream to an output stream.Utilities for I/O streams.
Low-level JSON library implementation based on Jackson.
Low-level JSON library implementation based on Jackson 2.
Holder for the result of
JacksonFactory.getDefaultInstance().Low-level JSON serializer implementation based on Jackson.
Low-level JSON serializer implementation based on Jackson.
Low-level JSON serializer implementation based on Jackson.
Low-level JSON serializer implementation based on Jackson.
Thread-safe JDO implementation of a data store factory.
JDO value class that contains the key-value pair, as well as the data store ID.
Package private utilities class so the classes here isn't considered to be an external part of
the library.
See JDO :
PrimaryKey Classes for a reference.
JSON utilities.
Abstract low-level JSON factory.
Abstract low-level JSON serializer.
Serializes JSON HTTP content based on the data key/value mapping object for an item.
Parses JSON data into an data class of key/value pairs.
Builder.
Abstract low-level JSON parser.
Beta Declares that the data type enclosing this field is polymorphic, and that the value of this field in a heterogeneous JSON schema will determine what type the data should be parsed into.
Declares a mapping between a key value and a referenced class.
Beta JSON-RPC 2.0 request object.
Use this annotation to specify that a declared numeric Java field should map to a JSON string.
JSON token in the low-level JSON library.
Header as specified in Reserved
Header Parameter Names.
JWS parser.
Header as specified in JWT Header.
Payload as specified in Reserved Claim
Names.
Use this annotation to specify that a field is a data key, optionally providing the data key name
to use.
Static utility methods pertaining to
List instances.Thread-safe byte array output stream that logs what was written to it when the stream is closed.
Thread-safe input stream wrapper that forwards all reads to a given input stream, while logging
all reads to a
LoggingByteArrayOutputStream.Thread-safe output stream wrapper that forwards all writes to a given output stream, while
logging all writes to a
LoggingByteArrayOutputStream.Wraps another streaming content without modifying the content, but also logging content using
LoggingOutputStream.Beta Logging handler that stores log records.
Low-level HTTP request.
Low-level HTTP response.
Static utility methods pertaining to
Map instances.Thread-safe in-memory implementation of a data store factory.
Holder for the result of
MemoryDataStoreFactory.getDefaultInstance().Serializes MIME multipart content as specified by RFC 2387: The MIME Multipart/Related Content-type
and RFC 2046: Multipurpose Internet
Mail Extensions: The Multipart/mixed (primary) subtype.
Single part of a multi-part request.
Nano clock which can be used to measure elapsed time in nanoseconds.
Thread-safe HTTP low-level transport based on the
java.net package.Builder for
NetHttpTransport.Use this annotation to specify that an enum constant is the "null" data value to use for
Data.nullOf(Class).Parses a data source into the specified data type.
Helper functions that can operate on any
Object.Support class for
Objects.toStringHelper(java.lang.Object).Beta PEM file reader.
Section in the PEM file.
A
UnicodeEscaper that escapes some set of Java characters using the URI percent encoding
scheme.Methods factored out so that they can be emulated differently in GWT.
Simple static methods to be called at the start of your own methods to verify correct arguments
and state.
Beta Utilities for protocol buffers.
Beta Serializes of a protocol buffer message to HTTP content.
Beta Parses protocol buffer HTTP response content into a protocol buffer message.
Utilities related to Java security.
Static utility methods pertaining to
Set instances.Sleeper interface to use for requesting the current thread to sleep as specified in
Thread.sleep(long).Implementation of SSL socket factory that extends Apache's implementation to provide
functionality missing from the Android SDK that is available in Apache HTTP Client.
SSL utilities.
Streaming content interface to write bytes to an output stream.
Static utility methods pertaining to
String instances.Utilities for strings.
Beta Testable extension for a byte array input stream.
Beta Testable extension for a byte array output stream.
Beta Test certificates.
Beta Wrapper for a PEM encoded certificate providing utility routines.
Static utility methods pertaining to instances of
Throwable.Utilities for working with Java types.
An
Escaper that converts literal text into a format safe for inclusion in a particular
context (such as an XML document).Expands URI Templates.
Contains information on how to output a composite value.
Implements support for HTTP form content encoding serialization of type
application/x-www-form-urlencoded as specified in the HTML 4.0 Specification.Implements support for HTTP form content encoding parsing of type
application/x-www-form-urlencoded as specified in the HTML 4.0
Specification.Use this annotation to specify that an enum constant is a string data value, optionally providing
the string data value to use.
Beta XML utilities.
Customizes the behavior of XML parsing.
Beta Serializes XML HTTP content based on the data key/value mapping object for an item.
Beta Thread-safe XML namespace dictionary that provides a one-to-one map of namespace alias to URI.
Beta XML HTTP parser into an data class of key/value pairs.
HttpBackOffUnsuccessfulResponseHandlerinstead.