com.google.protobuf

## Interface MessageLite

- All Superinterfaces:
    MessageLiteOrBuilder
  All Known Subinterfaces:
    Message
  All Known Implementing Classes:
    AbstractMessage, AbstractMessageLite, DescriptorProtos.DescriptorProto, DescriptorProtos.DescriptorProto.ExtensionRange, DescriptorProtos.DescriptorProto.ReservedRange, DescriptorProtos.EnumDescriptorProto, DescriptorProtos.EnumOptions, DescriptorProtos.EnumValueDescriptorProto, DescriptorProtos.EnumValueOptions, DescriptorProtos.FieldDescriptorProto, DescriptorProtos.FieldOptions, DescriptorProtos.FileDescriptorProto, DescriptorProtos.FileDescriptorSet, DescriptorProtos.FileOptions, DescriptorProtos.GeneratedCodeInfo, DescriptorProtos.GeneratedCodeInfo.Annotation, DescriptorProtos.MessageOptions, DescriptorProtos.MethodDescriptorProto, DescriptorProtos.MethodOptions, DescriptorProtos.OneofDescriptorProto, DescriptorProtos.OneofOptions, DescriptorProtos.ServiceDescriptorProto, DescriptorProtos.ServiceOptions, DescriptorProtos.SourceCodeInfo, DescriptorProtos.SourceCodeInfo.Location, DescriptorProtos.UninterpretedOption, DescriptorProtos.UninterpretedOption.NamePart, DynamicMessage, GeneratedMessage, GeneratedMessage.ExtendableMessage, GeneratedMessageLite, GeneratedMessageLite.ExtendableMessage, GeneratedMessageV3, GeneratedMessageV3.ExtendableMessage, MapEntry, UnknownFieldSet

      public interface MessageLite
      extends MessageLiteOrBuilder

  Abstract interface implemented by Protocol Message objects.

  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.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Interface and Description
    --- | ---
    `static interface` | `MessageLite.Builder` Abstract interface implemented by Protocol Message builders.

  - ### Method Summary

    Methods
    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`.

    - ### Methods inherited from interface com.google.protobuf.MessageLiteOrBuilder

      `getDefaultInstanceForType, isInitialized`

- - ### Method Detail

    - #### writeTo

          void writeTo(CodedOutputStream output)
                       throws java.io.IOException

      Serializes the message and writes it to `output`. This does not flush or close the stream.
      Throws:
        `java.io.IOException`

    - #### getSerializedSize

          int getSerializedSize()

      Get the number of bytes required to encode this message. The result is only computed on the first call and memoized after that.

    - #### getParserForType

          Parser<? extends MessageLite> getParserForType()

      Gets the parser for a message of the same type as this message.

    - #### toByteString

          ByteString toByteString()

      Serializes the message to a `ByteString` and returns it. This is just a trivial wrapper around `writeTo(CodedOutputStream)`.

    - #### toByteArray

          byte[] toByteArray()

      Serializes the message to a `byte` array and returns it. This is just a trivial wrapper around `writeTo(CodedOutputStream)`.

    - #### writeTo

          void writeTo(java.io.OutputStream output)
                       throws java.io.IOException

      Serializes the message and writes it to `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)`.

      Throws:
        `java.io.IOException`

    - #### writeDelimitedTo

          void writeDelimitedTo(java.io.OutputStream output)
                                throws java.io.IOException

      Like `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.
      Throws:
        `java.io.IOException`

    - #### newBuilderForType

          MessageLite.Builder newBuilderForType()

      Constructs a new builder for a message of the same type as this message.

    - #### toBuilder

          MessageLite.Builder toBuilder()

      Constructs a builder initialized with the current message. Use this to derive a new message from the current one.