All Classes and Interfaces

Class
Description
Base lexer.
Base parser
Used for (speeding up deser on) repeated/collection fields.
 
Annotation for messages, enums, services, rpc, fields
Base class for components that contain annotations.
Field mapping implemented on top of java array for lookup by number.
Used when a field is an array (Object[] or any polymorphic component type).
Built-in array schemas.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fast B64 Encoder/Decoder as described in RFC 1421.
A builder that can build a message.
Reads and decodes protocol buffer message fields from an internal byte array buffer.
Reads and decodes protocol buffer message fields from an internal byte array buffer.
Immutable array of bytes.
A proto loader that caches the protos for re-use.
Used when a field is declared as Class<?> (with or with-out generics).
Reads and decodes protocol message fields.
A schema for standard jdk collections.
 
Creates new Collection messages.
The main execution point of compiling protos.
When there is no matching compiler for the ProtoModule.getOutput().
Utilities and helpers for compiling protos.
The reference configured via options and annotations.
A schema (helper class) that wraps another schema and allows its subclasses to override certain methods for more customization.
The FQCN(fully qualified class name) will serve as the id (string).
 
 
 
 
 
 
Default proto loader for imported protos.
Controls how certain types are serialized and can even override the existing serializers because this has higher priority when the fields are being built.
This schema delegates to another schema derived from the input.
Represents an enum field defined in a Message.
Represents an enum declared in either the Proto or nested in a Message.
 
Determines how enums are serialized/deserialized.
Reads the enum by its name.
Reads the enum by its number.
Interface for an enum value for use with code-generated enums.
A sort of runtime error mechanism for st code generation to fail fast.
A field annotation to configure the field ignored.
Requires every messsage/pojo/enum/collection/map to be registered with unique ids.
 
 
 
 
 
 
This Registry is only way to register your pojos/enums/collections/maps/delegates.
Represents an extend block declared in either the Proto or nested in a Message.
Base class for fields defined in a Message.
Represents a field of a message/pojo.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Holds a reference to a Field.
Interface for map of fields - defines how to you get field by name or number (tag).
Utility methods for manipulations with file names
A FilterInput contains some other input, which it uses as its basic source of data.
A FilterOutput contains some other output, which it uses as its basic sink of data.
Formats a string.
Built-in formatters.
A ByteArrayInput w/c can handle cyclic dependencies when deserializing objects with graph transformations.
A CodedInput w/c can handle cyclic dependencies when deserializing objects with graph transformations.
An input that is stateful and keeps track of the references.
IO Utilities for graph objects (references and cyclic dependencies).
A ProtostuffOutput w/c can handle cyclic dependencies when serializing objects with graph transformations.
A trimed-down version of IdentityHashMap w/c caters to the specific needs of
invalid reference
GraphOutput
.
An entity that containts annotations.
Wraps a delegate.
 
Field mapping implemented on top of hash for field lookup by number.
 
Represents a component that should have a name.
Represents a component in a proto that can have options.
Represents a component that should belong to a proto.
Wraps a schema.
This base class handles all the IO for reading and writing polymorphic fields.
Responsible for instantiating custom IdStrategy impls.
 
Thrown when a type is not known by the IdStrategy.
 
A custom ComponentConfigurator which adds the project's runtime classpath elements to the classpath Source: http://mail-archives.apache.org/mod_mbox/maven-users/200808.mbox/%3C18785907.post@talk.nabble.com%3E
The ids are generated (incremental) on the fly and you can optionally register classes by reserving the first x ids via IncrementalIdStrategy.Registry.
 
To use IncrementalIdStrategy without registering anything, set the system property: "-Dprotostuff.runtime.id_strategy_factory=io.protostuff.runtime.IncrementalIdStrategy$Factory"
 
 
 
This Registry is only way to register your pojos/enums/collections/maps/delegates.
 
 
 
An Input lets an application read primitive data types and objects from a source of data.
Int32/Int64 serialization
Common io utils for the supported formats.
An input used for reading data with json format.
Thrown when a json-encoded protobuf message being parsed is invalid in some way.
Utility for the JSON serialization/deserialization of messages and objects tied to a schema.
A custom factory simply to expose certain fields.
An output used for writing data with json format.
Json serialization via JsonXOutput.
An optimized json output which is efficient in writing numeric keys and pre-encoded utf8 strings (in byte array form).
An input for deserializing kvp-encoded messages.
An input for deserializing kvp-encoded messages.
An output for serializing kvp-encoded messages (from a byte array as source).
An InputStream implementations which reads from some other InputStream but is limited to a particular number of bytes.
A list of ByteBuffers.
A buffer that wraps a byte array and has a reference to the next buffer for dynamic increase.
Provides an immutable view of List<T> around a List<F>.
Convert individual elements of the List from F to T.
Output that differs from the standard by attempting to avoid extra copies of large ByteBuffer fields.
Output that differs from the standard by attempting to avoid extra copies of large ByteBuffer fields.
A schema for a Map.
A Map.Entry w/c wraps a Map.
A message factory for standard Map implementations.
Creates new Map messages.
The serializable object where its schema handles its serialization and deserialization.
Represents the message defined in the Proto.
A schema for a Collection with Message or pojo values.
Represents a message field defined in a Proto.
A schema for a Map with Message or pojo keys.
Used to configure non-final pojos, map interfaces and collection interfaces.
An entity whose values can be overriden with new value.
An IO utility for dealing with raw ascii bytes.
Used when the type is Number.
Base class for numeric id strategies.
 
Register your pojos/enums/collections/maps/delegates here.
A schema for dynamic types (fields where the type is Object).
An array wrapper internally used for adding objects.
This class is expected not to load unless RuntimeEnv made sure that sun.reflect.ReflectionFactory is in the classpath.
An Output lets an application write primitive data types and objects to a sink of data.
Transfers data from an Input to an Output.
Schema for transferring data from a source (Input) to a different sink (Output).
A plugin proto compiler whose output relies on the 'output' param configured in ProtoModule.
Resolve the stg from the module.
Used when the type is an interface (Collection/List/Set/SortedSet).
Used when a field is declared as Enum<?> (with or with-out generics).
Used when the type is an interface (Map/SortedMap).
Will be used if RuntimeEnv.POJO_SCHEMA_ON_COLLECTION_FIELDS is enabled and the field is assignable from Collection.
Placeholder for annotated interface/object fields configured to use this.
Used when the type is either polymorphic or too complex.
A factory which creates a schema with the handler connected to it.
The handler who's job is to set the value to the owner.
Polymorphic types.
Used when the type is assignable from Throwable.
A filter for the fields that need to be included.
A predicate that includes only a single field with the provided number.
Built-in factories that filters based on the field number.
 
A predicate that includes fields that are greater than the provider number.
A predicate that includes fields that are lesser than the provider number.
A predicate that includes all fields except the provided number.
The opposite of Predicate.RANGE.
A predicate that includes fields if they are within range of the provided numbers, min and max.
Contains the metadata of parsed protos.
 
Thrown when a protocol message being parsed is invalid in some way, e.g.
Protobuf ser/deser util for messages/objects.
Protobuf serialization where the messages must be fully buffered on memory before it can be written to the socket ( OutputStream).
Proto compiler.
Compiles proto files to java/gwt/etc.
 
Configuration for the proto w/c ontains the compile options and arguments.
Specifically for the maven-plugin.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
The base io exception for all formats (protobuf/json/xml).
Protostuff ser/deser util for messages/objects.
Dual output for streaming or full buffering.
Compiles proto files to gwt overlays source (java) files.
Compiles proto files to protobuf java messages (pojos).
Compiles proto files to protobuf java messages (pojos).
Compiles proto files to protobuf java messages (pojos).
 
Generates a Schema from the code generated by the c++ v2 protoc.
Kind of preprocessor for proto files.
Utility for loading protos from various input.
Read/write from/to fields using reflection.
Specify rpc request qualifier.
Specify rpc response qualifier.
Marker annotation, indicates that an annotated method is a rpc service method.
A runtime field for a Collection.
Static utility for creating runtime Collection fields.
A runtime field w/c represents an abstract class, interface or a base type with many possible subclasses.
The runtime environment.
 
 
 
A factory to create runtime fields based on reflection.
A runtime field for a Map.
Static utility for creating runtime Map fields.
A runtime message field that lazily loads the schema to support cyclic dependencies.
A runtime field whose field type is Object (dynamic).
Runtime pipe schema.
Field factory via plain old reflection api.
Static utility for creating runtime repeated (list/collection) fields.
A schema that can be generated and cached at runtime for objects that have no schema.
Field factory via sun.misc.Unsafe.
A view schema can choose which fields to include during ser/deser.
The base schema used by the built-in factories.
Built-in view schema factories.
 
 
Handles the serialization and deserialization of a message/object tied to this.
Represents a service defined in the proto (for generating rpc services).
Rpc service annotation, specifies service namespace.
 
Smile IO utilities for messages.
A custom factory simply to expose certain fields.
An output that keeps the state of the schema being used.
Base class for code generators using StringTemplate.
UTF-8 String serialization
A schema for a Map with String keys.
UTF-8 String serialization
 
A field annotation to configure the field number explicitly.
Provide ascii text parsing and formatting support for proto2 instances.
Dummy file to please the ishy sonatype repository (javadoc friggin required).
Thrown when attempting to build a protocol message that is missing required fields.
Read/write from/to fields using sun.misc.Unsafe
 
This class is used internally by the Protocol Buffer library and generated message implementations.
This is here to support runtime schemas.
This is here to support runtime schemas.
Designed to be subclassed by implementations of Output for easier serialization code for streaming or full buffering.
 
The flexible output for outputs that use WriteSession.
An input used for reading data with xml format.
Thrown when an xml-encoded message being parsed is invalid in some way.
Resolves the target XMLInputFactory and XMLOutputFactory to use.
Utility for the XML serialization/deserialization of messages and objects tied to a schema.
An output used for writing data with xml format.
Wrapper for XMLStreamException.
IO Utils for writing xml via XmlXOutput.
Optimized xml output.
Utility for the YAML serialization of messages and objects tied to a schema.
An output used for writing data with yaml format.