public interface MessageLite extends MessageLiteOrBuilder
This interface is implemented by all protocol message objects. Non-lite messages additionally implement the Message interface, which is a subclass of MessageLite. Use MessageLite instead when you only need the subset of features which it supports -- namely, nothing that uses descriptors or reflection. You can instruct the protocol compiler to generate classes which implement only MessageLite, not the full Message interface, by adding the follow line to the .proto file:
option optimize_for = LITE_RUNTIME;
This is particularly useful on resource-constrained systems where the full protocol buffers runtime library is too big.
Note that on non-constrained systems (e.g. servers) when you need to link
in lots of protocol definitions, a better way to reduce total code footprint
is to use optimize_for = CODE_SIZE. This will make the generated
code smaller while still supporting all the same features (at the expense of
speed). optimize_for = LITE_RUNTIME is best when you only have a
small number of message types linked into your binary, in which case the
size of the protocol buffers runtime itself is the biggest problem.
| Modifier and Type | Interface and Description |
|---|---|
static interface |
MessageLite.Builder
Abstract interface implemented by Protocol Message builders.
|
| Modifier and Type | Method and Description |
|---|---|
Parser<? extends MessageLite> |
getParserForType()
Gets the parser for a message of the same type as this message.
|
int |
getSerializedSize()
Get the number of bytes required to encode this message.
|
MessageLite.Builder |
newBuilderForType()
Constructs a new builder for a message of the same type as this message.
|
MessageLite.Builder |
toBuilder()
Constructs a builder initialized with the current message.
|
byte[] |
toByteArray()
Serializes the message to a
byte array and returns it. |
ByteString |
toByteString()
Serializes the message to a
ByteString and returns it. |
void |
writeDelimitedTo(java.io.OutputStream output)
Like
writeTo(OutputStream), but writes the size of the message
as a varint before writing the data. |
void |
writeTo(CodedOutputStream output)
Serializes the message and writes it to
output. |
void |
writeTo(java.io.OutputStream output)
Serializes the message and writes it to
output. |
getDefaultInstanceForType, isInitializedvoid writeTo(CodedOutputStream output) throws java.io.IOException
output. This does not
flush or close the stream.java.io.IOExceptionint getSerializedSize()
Parser<? extends MessageLite> getParserForType()
ByteString toByteString()
ByteString and returns it. This is
just a trivial wrapper around
writeTo(CodedOutputStream).byte[] toByteArray()
byte array and returns it. This is
just a trivial wrapper around
writeTo(CodedOutputStream).void writeTo(java.io.OutputStream output)
throws java.io.IOException
output. This is just a
trivial wrapper around writeTo(CodedOutputStream). This does
not flush or close the stream.
NOTE: Protocol Buffers are not self-delimiting. Therefore, if you write
any more data to the stream after the message, you must somehow ensure
that the parser on the receiving end does not interpret this as being
part of the protocol message. This can be done e.g. by writing the size
of the message before the data, then making sure to limit the input to
that size on the receiving end (e.g. by wrapping the InputStream in one
which limits the input). Alternatively, just use
writeDelimitedTo(OutputStream).
java.io.IOExceptionvoid writeDelimitedTo(java.io.OutputStream output)
throws java.io.IOException
writeTo(OutputStream), but writes the size of the message
as a varint before writing the data. This allows more data to be written
to the stream after the message without the need to delimit the message
data yourself. Use MessageLite.Builder.mergeDelimitedFrom(InputStream) (or
the static method YourMessageType.parseDelimitedFrom(InputStream))
to parse messages written by this method.java.io.IOExceptionMessageLite.Builder newBuilderForType()
MessageLite.Builder toBuilder()