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.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.
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
GraphOutputAn 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 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.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.
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.
Will be used if either
RuntimeEnv.POJO_SCHEMA_ON_COLLECTION_FIELDS or
RuntimeEnv.POJO_SCHEMA_ON_MAP_FIELDS is set.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
UTF-8 String serialization
A field annotation to configure the field number explicitly.
Provide ascii text parsing and formatting support for proto2 instances.
Thrown by
TextFormat.unescapeBytes(java.lang.CharSequence) and TextFormat.unescapeText(java.lang.String) when an invalid escape sequence is
seen.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.