content: /* Copyright (C) 2016-2018 Alibaba Group Holding Limited
  
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
  
      http://www.apache.org/licenses/LICENSE-2.0
  
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  ==============================================================================*/
  
  // Protocol Buffers - Google's data interchange format
  // Copyright 2008 Google Inc.  All rights reserved.
  // https://developers.google.com/protocol-buffers/
  //
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions are
  // met:
  //
  //     * Redistributions of source code must retain the above copyright
  // notice, this list of conditions and the following disclaimer.
  //     * Redistributions in binary form must reproduce the above
  // copyright notice, this list of conditions and the following disclaimer
  // in the documentation and/or other materials provided with the
  // distribution.
  //     * Neither the name of Google Inc. nor the names of its
  // contributors may be used to endorse or promote products derived from
  // this software without specific prior written permission.
  //
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
  // TODO(kenton):  Use generics?  E.g. Builder<BuilderType extends Builder>, then
  //   mergeFrom*() could return BuilderType for better type-safety.
  
  package com.google.protobuf;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  
  /**
   * Abstract interface implemented by Protocol Message objects.
   *
   * <p>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:
   * <pre>
   *   option optimize_for = LITE_RUNTIME;
   * </pre>
   *
   * <p>This is particularly useful on resource-constrained systems where the
   * full protocol buffers runtime library is too big.
   *
   * <p>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 {@code optimize_for = CODE_SIZE}.  This will make the generated
   * code smaller while still supporting all the same features (at the expense of
   * speed).  {@code 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.
   *
   * @author kenton@google.com Kenton Varda
   */
  public interface MessageLite extends MessageLiteOrBuilder {
  
  
    /**
     * Serializes the message and writes it to {@code output}.  This does not
     * flush or close the stream.
     */
    void writeTo(CodedOutputStream output) throws IOException;
  
    /**
     * Get the number of bytes required to encode this message.  The result
     * is only computed on the first call and memoized after that.
     */
    int getSerializedSize();
  
  
    /**
     * Gets the parser for a message of the same type as this message.
     */
    Parser<? extends MessageLite> getParserForType();
  
    // -----------------------------------------------------------------
    // Convenience methods.
  
    /**
     * Serializes the message to a {@code ByteString} and returns it. This is
     * just a trivial wrapper around
     * {@link #writeTo(CodedOutputStream)}.
     */
    ByteString toByteString();
  
    /**
     * Serializes the message to a {@code byte} array and returns it.  This is
     * just a trivial wrapper around
     * {@link #writeTo(CodedOutputStream)}.
     */
    byte[] toByteArray();
  
    /**
     * Serializes the message and writes it to {@code output}.  This is just a
     * trivial wrapper around {@link #writeTo(CodedOutputStream)}.  This does
     * not flush or close the stream.
     * <p>
     * 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
     * {@link #writeDelimitedTo(OutputStream)}.
     */
    void writeTo(OutputStream output) throws IOException;
  
    /**
     * Like {@link #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 {@link Builder#mergeDelimitedFrom(InputStream)} (or
     * the static method {@code YourMessageType.parseDelimitedFrom(InputStream)})
     * to parse messages written by this method.
     */
    void writeDelimitedTo(OutputStream output) throws IOException;
  
  
    // =================================================================
    // Builders
  
    /**
     * Constructs a new builder for a message of the same type as this message.
     */
    Builder newBuilderForType();
  
    /**
     * Constructs a builder initialized with the current message.  Use this to
     * derive a new message from the current one.
     */
    Builder toBuilder();
  
    /**
     * Abstract interface implemented by Protocol Message builders.
     */
    interface Builder extends MessageLiteOrBuilder, Cloneable {
      /** Resets all fields to their default values. */
      Builder clear();
  
      /**
       * Constructs the message based on the state of the Builder. Subsequent
       * changes to the Builder will not affect the returned message.
       * @throws UninitializedMessageException The message is missing one or more
       *         required fields (i.e. {@link #isInitialized()} returns false).
       *         Use {@link #buildPartial()} to bypass this check.
       */
      MessageLite build();
  
      /**
       * Like {@link #build()}, but does not throw an exception if the message
       * is missing required fields.  Instead, a partial message is returned.
       * Subsequent changes to the Builder will not affect the returned message.
       */
      MessageLite buildPartial();
  
      /**
       * Clones the Builder.
       * @see Object#clone()
       */
      Builder clone();
  
      /**
       * Parses a message of this type from the input and merges it with this
       * message.
       *
       * <p>Warning:  This does not verify that all required fields are present in
       * the input message.  If you call {@link #build()} without setting all
       * required fields, it will throw an {@link UninitializedMessageException},
       * which is a {@code RuntimeException} and thus might not be caught.  There
       * are a few good ways to deal with this:
       * <ul>
       *   <li>Call {@link #isInitialized()} to verify that all required fields
       *       are set before building.
       *   <li>Use {@code buildPartial()} to build, which ignores missing
       *       required fields.
       * </ul>
       *
       * <p>Note:  The caller should call
       * {@link CodedInputStream#checkLastTagWas(int)} after calling this to
       * verify that the last tag seen was the appropriate end-group tag,
       * or zero for EOF.
       */
      Builder mergeFrom(CodedInputStream input) throws IOException;
  
      /**
       * Like {@link Builder#mergeFrom(CodedInputStream)}, but also
       * parses extensions.  The extensions that you want to be able to parse
       * must be registered in {@code extensionRegistry}.  Extensions not in
       * the registry will be treated as unknown fields.
       */
      Builder mergeFrom(CodedInputStream input,
                        ExtensionRegistryLite extensionRegistry)
                        throws IOException;
  
      // ---------------------------------------------------------------
      // Convenience methods.
  
      /**
       * Parse {@code data} as a message of this type and merge it with the
       * message being built.  This is just a small wrapper around
       * {@link #mergeFrom(CodedInputStream)}.
       *
       * @return this
       */
      Builder mergeFrom(ByteString data) throws InvalidProtocolBufferException;
  
      /**
       * Parse {@code data} as a message of this type and merge it with the
       * message being built.  This is just a small wrapper around
       * {@link #mergeFrom(CodedInputStream,ExtensionRegistryLite)}.
       *
       * @return this
       */
      Builder mergeFrom(ByteString data,
                        ExtensionRegistryLite extensionRegistry)
                        throws InvalidProtocolBufferException;
  
      /**
       * Parse {@code data} as a message of this type and merge it with the
       * message being built.  This is just a small wrapper around
       * {@link #mergeFrom(CodedInputStream)}.
       *
       * @return this
       */
      Builder mergeFrom(byte[] data) throws InvalidProtocolBufferException;
  
      /**
       * Parse {@code data} as a message of this type and merge it with the
       * message being built.  This is just a small wrapper around
       * {@link #mergeFrom(CodedInputStream)}.
       *
       * @return this
       */
      Builder mergeFrom(byte[] data, int off, int len)
                        throws InvalidProtocolBufferException;
  
      /**
       * Parse {@code data} as a message of this type and merge it with the
       * message being built.  This is just a small wrapper around
       * {@link #mergeFrom(CodedInputStream,ExtensionRegistryLite)}.
       *
       * @return this
       */
      Builder mergeFrom(byte[] data,
                        ExtensionRegistryLite extensionRegistry)
                        throws InvalidProtocolBufferException;
  
      /**
       * Parse {@code data} as a message of this type and merge it with the
       * message being built.  This is just a small wrapper around
       * {@link #mergeFrom(CodedInputStream,ExtensionRegistryLite)}.
       *
       * @return this
       */
      Builder mergeFrom(byte[] data, int off, int len,
                        ExtensionRegistryLite extensionRegistry)
                        throws InvalidProtocolBufferException;
  
      /**
       * Parse a message of this type from {@code input} and merge it with the
       * message being built.  This is just a small wrapper around
       * {@link #mergeFrom(CodedInputStream)}.  Note that this method always
       * reads the <i>entire</i> input (unless it throws an exception).  If you
       * want it to stop earlier, you will need to wrap your input in some
       * wrapper stream that limits reading.  Or, use
       * {@link MessageLite#writeDelimitedTo(OutputStream)} to write your message
       * and {@link #mergeDelimitedFrom(InputStream)} to read it.
       * <p>
       * Despite usually reading the entire input, this does not close the stream.
       *
       * @return this
       */
      Builder mergeFrom(InputStream input) throws IOException;
  
      /**
       * Parse a message of this type from {@code input} and merge it with the
       * message being built.  This is just a small wrapper around
       * {@link #mergeFrom(CodedInputStream,ExtensionRegistryLite)}.
       *
       * @return this
       */
      Builder mergeFrom(InputStream input,
                        ExtensionRegistryLite extensionRegistry)
                        throws IOException;
      
      /**
       * Merge {@code other} into the message being built.  {@code other} must
       * have the exact same type as {@code this} (i.e.
       * {@code getClass().equals(getDefaultInstanceForType().getClass())}).
       *
       * Merging occurs as follows.  For each field:<br>
       * * For singular primitive fields, if the field is set in {@code other},
       *   then {@code other}'s value overwrites the value in this message.<br>
       * * For singular message fields, if the field is set in {@code other},
       *   it is merged into the corresponding sub-message of this message
       *   using the same merging rules.<br>
       * * For repeated fields, the elements in {@code other} are concatenated
       *   with the elements in this message.
       * * For oneof groups, if the other message has one of the fields set,
       *   the group of this message is cleared and replaced by the field
       *   of the other message, so that the oneof constraint is preserved.
       *
       * This is equivalent to the {@code Message::MergeFrom} method in C++.
       */
      Builder mergeFrom(MessageLite other);
  
      /**
       * Like {@link #mergeFrom(InputStream)}, but does not read until EOF.
       * Instead, the size of the message (encoded as a varint) is read first,
       * then the message data.  Use
       * {@link MessageLite#writeDelimitedTo(OutputStream)} to write messages in
       * this format.
       *
       * @return True if successful, or false if the stream is at EOF when the
       *         method starts.  Any other error (including reaching EOF during
       *         parsing) will cause an exception to be thrown.
       */
      boolean mergeDelimitedFrom(InputStream input)
                                 throws IOException;
  
      /**
       * Like {@link #mergeDelimitedFrom(InputStream)} but supporting extensions.
       */
      boolean mergeDelimitedFrom(InputStream input,
                                 ExtensionRegistryLite extensionRegistry)
                                 throws IOException;
    }
  }
  