com.google.protobuf/protobuf-java/3.10.0 : com/google/protobuf/compiler/PluginProtos.java

PluginProtos
https://developers.google.com/protocol-buffers/protobuf-java/: Core Protocol Buffers library. Protocol Buffers are a way of encoding structured data in an efficient yet extensible format.
3-Clause BSD License
Hao Nguyen (Google)
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: google/protobuf/compiler/plugin.proto

package com.google.protobuf.compiler;

public final class PluginProtos {
  private PluginProtos() {}
  public static void registerAllExtensions(
      com.google.protobuf.ExtensionRegistryLite registry) {
  }

  public static void registerAllExtensions(
      com.google.protobuf.ExtensionRegistry registry) {
    registerAllExtensions(
        (com.google.protobuf.ExtensionRegistryLite) registry);
  }
  public interface VersionOrBuilder extends
      // @@protoc_insertion_point(interface_extends:google.protobuf.compiler.Version)
      com.google.protobuf.MessageOrBuilder {

    optional int32 major = 1;
Returns: Whether the major field is set./**
     * <code>optional int32 major = 1;</code>
     * @return Whether the major field is set.
     */
    boolean hasMajor();
    optional int32 major = 1;
Returns: The major./**
     * <code>optional int32 major = 1;</code>
     * @return The major.
     */
    int getMajor();

    optional int32 minor = 2;
Returns: Whether the minor field is set./**
     * <code>optional int32 minor = 2;</code>
     * @return Whether the minor field is set.
     */
    boolean hasMinor();
    optional int32 minor = 2;
Returns: The minor./**
     * <code>optional int32 minor = 2;</code>
     * @return The minor.
     */
    int getMinor();

    optional int32 patch = 3;
Returns: Whether the patch field is set./**
     * <code>optional int32 patch = 3;</code>
     * @return Whether the patch field is set.
     */
    boolean hasPatch();
    optional int32 patch = 3;
Returns: The patch./**
     * <code>optional int32 patch = 3;</code>
     * @return The patch.
     */
    int getPatch();

    A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
be empty for mainline stable releases.

optional string suffix = 4;
Returns: Whether the suffix field is set./**
     * <pre>
     * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     * be empty for mainline stable releases.
     * </pre>
     *
     * <code>optional string suffix = 4;</code>
     * @return Whether the suffix field is set.
     */
    boolean hasSuffix();
    A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
be empty for mainline stable releases.

optional string suffix = 4;
Returns: The suffix./**
     * <pre>
     * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     * be empty for mainline stable releases.
     * </pre>
     *
     * <code>optional string suffix = 4;</code>
     * @return The suffix.
     */
    java.lang.String getSuffix();
    A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
be empty for mainline stable releases.

optional string suffix = 4;
Returns: The bytes for suffix./**
     * <pre>
     * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     * be empty for mainline stable releases.
     * </pre>
     *
     * <code>optional string suffix = 4;</code>
     * @return The bytes for suffix.
     */
    com.google.protobuf.ByteString
        getSuffixBytes();
  }
  The version number of protocol compiler.
 Protobuf type google.protobuf.compiler.Version /**
   * <pre>
   * The version number of protocol compiler.
   * </pre>
   *
   * Protobuf type {@code google.protobuf.compiler.Version}
   */
  public  static final class Version extends
      com.google.protobuf.GeneratedMessageV3 implements
      // @@protoc_insertion_point(message_implements:google.protobuf.compiler.Version)
      VersionOrBuilder {
  private static final long serialVersionUID = 0L;
    // Use Version.newBuilder() to construct.
    private Version(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
      super(builder);
    }
    private Version() {
      suffix_ = "";
    }

    @java.lang.Override
    @SuppressWarnings({"unused"})
    protected java.lang.Object newInstance(
        UnusedPrivateParameter unused) {
      return new Version();
    }

    @java.lang.Override
    public final com.google.protobuf.UnknownFieldSet
    getUnknownFields() {
      return this.unknownFields;
    }
    private Version(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      this();
      if (extensionRegistry == null) {
        throw new java.lang.NullPointerException();
      }
      int mutable_bitField0_ = 0;
      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder();
      try {
        boolean done = false;
        while (!done) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              done = true;
              break;
            case 8: {
              bitField0_ |= 0x00000001;
              major_ = input.readInt32();
              break;
            }
            case 16: {
              bitField0_ |= 0x00000002;
              minor_ = input.readInt32();
              break;
            }
            case 24: {
              bitField0_ |= 0x00000004;
              patch_ = input.readInt32();
              break;
            }
            case 34: {
              com.google.protobuf.ByteString bs = input.readBytes();
              bitField0_ |= 0x00000008;
              suffix_ = bs;
              break;
            }
            default: {
              if (!parseUnknownField(
                  input, unknownFields, extensionRegistry, tag)) {
                done = true;
              }
              break;
            }
          }
        }
      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
        throw e.setUnfinishedMessage(this);
      } catch (java.io.IOException e) {
        throw new com.google.protobuf.InvalidProtocolBufferException(
            e).setUnfinishedMessage(this);
      } finally {
        this.unknownFields = unknownFields.build();
        makeExtensionsImmutable();
      }
    }
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_Version_descriptor;
    }

    @java.lang.Override
    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_Version_fieldAccessorTable
          .ensureFieldAccessorsInitialized(
              com.google.protobuf.compiler.PluginProtos.Version.class, com.google.protobuf.compiler.PluginProtos.Version.Builder.class);
    }

    private int bitField0_;
    public static final int MAJOR_FIELD_NUMBER = 1;
    private int major_;
    optional int32 major = 1;
Returns: Whether the major field is set./**
     * <code>optional int32 major = 1;</code>
     * @return Whether the major field is set.
     */
    public boolean hasMajor() {
      return ((bitField0_ & 0x00000001) != 0);
    }
    optional int32 major = 1;
Returns: The major./**
     * <code>optional int32 major = 1;</code>
     * @return The major.
     */
    public int getMajor() {
      return major_;
    }

    public static final int MINOR_FIELD_NUMBER = 2;
    private int minor_;
    optional int32 minor = 2;
Returns: Whether the minor field is set./**
     * <code>optional int32 minor = 2;</code>
     * @return Whether the minor field is set.
     */
    public boolean hasMinor() {
      return ((bitField0_ & 0x00000002) != 0);
    }
    optional int32 minor = 2;
Returns: The minor./**
     * <code>optional int32 minor = 2;</code>
     * @return The minor.
     */
    public int getMinor() {
      return minor_;
    }

    public static final int PATCH_FIELD_NUMBER = 3;
    private int patch_;
    optional int32 patch = 3;
Returns: Whether the patch field is set./**
     * <code>optional int32 patch = 3;</code>
     * @return Whether the patch field is set.
     */
    public boolean hasPatch() {
      return ((bitField0_ & 0x00000004) != 0);
    }
    optional int32 patch = 3;
Returns: The patch./**
     * <code>optional int32 patch = 3;</code>
     * @return The patch.
     */
    public int getPatch() {
      return patch_;
    }

    public static final int SUFFIX_FIELD_NUMBER = 4;
    private volatile java.lang.Object suffix_;
    A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
be empty for mainline stable releases.

optional string suffix = 4;
Returns: Whether the suffix field is set./**
     * <pre>
     * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     * be empty for mainline stable releases.
     * </pre>
     *
     * <code>optional string suffix = 4;</code>
     * @return Whether the suffix field is set.
     */
    public boolean hasSuffix() {
      return ((bitField0_ & 0x00000008) != 0);
    }
    A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
be empty for mainline stable releases.

optional string suffix = 4;
Returns: The suffix./**
     * <pre>
     * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     * be empty for mainline stable releases.
     * </pre>
     *
     * <code>optional string suffix = 4;</code>
     * @return The suffix.
     */
    public java.lang.String getSuffix() {
      java.lang.Object ref = suffix_;
      if (ref instanceof java.lang.String) {
        return (java.lang.String) ref;
      } else {
        com.google.protobuf.ByteString bs = 
            (com.google.protobuf.ByteString) ref;
        java.lang.String s = bs.toStringUtf8();
        if (bs.isValidUtf8()) {
          suffix_ = s;
        }
        return s;
      }
    }
    A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
be empty for mainline stable releases.

optional string suffix = 4;
Returns: The bytes for suffix./**
     * <pre>
     * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     * be empty for mainline stable releases.
     * </pre>
     *
     * <code>optional string suffix = 4;</code>
     * @return The bytes for suffix.
     */
    public com.google.protobuf.ByteString
        getSuffixBytes() {
      java.lang.Object ref = suffix_;
      if (ref instanceof java.lang.String) {
        com.google.protobuf.ByteString b = 
            com.google.protobuf.ByteString.copyFromUtf8(
                (java.lang.String) ref);
        suffix_ = b;
        return b;
      } else {
        return (com.google.protobuf.ByteString) ref;
      }
    }

    private byte memoizedIsInitialized = -1;
    @java.lang.Override
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized == 1) return true;
      if (isInitialized == 0) return false;

      memoizedIsInitialized = 1;
      return true;
    }

    @java.lang.Override
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      if (((bitField0_ & 0x00000001) != 0)) {
        output.writeInt32(1, major_);
      }
      if (((bitField0_ & 0x00000002) != 0)) {
        output.writeInt32(2, minor_);
      }
      if (((bitField0_ & 0x00000004) != 0)) {
        output.writeInt32(3, patch_);
      }
      if (((bitField0_ & 0x00000008) != 0)) {
        com.google.protobuf.GeneratedMessageV3.writeString(output, 4, suffix_);
      }
      unknownFields.writeTo(output);
    }

    @java.lang.Override
    public int getSerializedSize() {
      int size = memoizedSize;
      if (size != -1) return size;

      size = 0;
      if (((bitField0_ & 0x00000001) != 0)) {
        size += com.google.protobuf.CodedOutputStream
          .computeInt32Size(1, major_);
      }
      if (((bitField0_ & 0x00000002) != 0)) {
        size += com.google.protobuf.CodedOutputStream
          .computeInt32Size(2, minor_);
      }
      if (((bitField0_ & 0x00000004) != 0)) {
        size += com.google.protobuf.CodedOutputStream
          .computeInt32Size(3, patch_);
      }
      if (((bitField0_ & 0x00000008) != 0)) {
        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, suffix_);
      }
      size += unknownFields.getSerializedSize();
      memoizedSize = size;
      return size;
    }

    @java.lang.Override
    public boolean equals(final java.lang.Object obj) {
      if (obj == this) {
       return true;
      }
      if (!(obj instanceof com.google.protobuf.compiler.PluginProtos.Version)) {
        return super.equals(obj);
      }
      com.google.protobuf.compiler.PluginProtos.Version other = (com.google.protobuf.compiler.PluginProtos.Version) obj;

      if (hasMajor() != other.hasMajor()) return false;
      if (hasMajor()) {
        if (getMajor()
            != other.getMajor()) return false;
      }
      if (hasMinor() != other.hasMinor()) return false;
      if (hasMinor()) {
        if (getMinor()
            != other.getMinor()) return false;
      }
      if (hasPatch() != other.hasPatch()) return false;
      if (hasPatch()) {
        if (getPatch()
            != other.getPatch()) return false;
      }
      if (hasSuffix() != other.hasSuffix()) return false;
      if (hasSuffix()) {
        if (!getSuffix()
            .equals(other.getSuffix())) return false;
      }
      if (!unknownFields.equals(other.unknownFields)) return false;
      return true;
    }

    @java.lang.Override
    public int hashCode() {
      if (memoizedHashCode != 0) {
        return memoizedHashCode;
      }
      int hash = 41;
      hash = (19 * hash) + getDescriptor().hashCode();
      if (hasMajor()) {
        hash = (37 * hash) + MAJOR_FIELD_NUMBER;
        hash = (53 * hash) + getMajor();
      }
      if (hasMinor()) {
        hash = (37 * hash) + MINOR_FIELD_NUMBER;
        hash = (53 * hash) + getMinor();
      }
      if (hasPatch()) {
        hash = (37 * hash) + PATCH_FIELD_NUMBER;
        hash = (53 * hash) + getPatch();
      }
      if (hasSuffix()) {
        hash = (37 * hash) + SUFFIX_FIELD_NUMBER;
        hash = (53 * hash) + getSuffix().hashCode();
      }
      hash = (29 * hash) + unknownFields.hashCode();
      memoizedHashCode = hash;
      return hash;
    }

    public static com.google.protobuf.compiler.PluginProtos.Version parseFrom(
        java.nio.ByteBuffer data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data);
    }
    public static com.google.protobuf.compiler.PluginProtos.Version parseFrom(
        java.nio.ByteBuffer data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.Version parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data);
    }
    public static com.google.protobuf.compiler.PluginProtos.Version parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.Version parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data);
    }
    public static com.google.protobuf.compiler.PluginProtos.Version parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.Version parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseWithIOException(PARSER, input);
    }
    public static com.google.protobuf.compiler.PluginProtos.Version parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseWithIOException(PARSER, input, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.Version parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseDelimitedWithIOException(PARSER, input);
    }
    public static com.google.protobuf.compiler.PluginProtos.Version parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.Version parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseWithIOException(PARSER, input);
    }
    public static com.google.protobuf.compiler.PluginProtos.Version parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseWithIOException(PARSER, input, extensionRegistry);
    }

    @java.lang.Override
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder() {
      return DEFAULT_INSTANCE.toBuilder();
    }
    public static Builder newBuilder(com.google.protobuf.compiler.PluginProtos.Version prototype) {
      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
    }
    @java.lang.Override
    public Builder toBuilder() {
      return this == DEFAULT_INSTANCE
          ? new Builder() : new Builder().mergeFrom(this);
    }

    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    The version number of protocol compiler.
 Protobuf type google.protobuf.compiler.Version /**
     * <pre>
     * The version number of protocol compiler.
     * </pre>
     *
     * Protobuf type {@code google.protobuf.compiler.Version}
     */
    public static final class Builder extends
        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
        // @@protoc_insertion_point(builder_implements:google.protobuf.compiler.Version)
        com.google.protobuf.compiler.PluginProtos.VersionOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_Version_descriptor;
      }

      @java.lang.Override
      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_Version_fieldAccessorTable
            .ensureFieldAccessorsInitialized(
                com.google.protobuf.compiler.PluginProtos.Version.class, com.google.protobuf.compiler.PluginProtos.Version.Builder.class);
      }

      // Construct using com.google.protobuf.compiler.PluginProtos.Version.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }

      private Builder(
          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessageV3
                .alwaysUseFieldBuilders) {
        }
      }
      @java.lang.Override
      public Builder clear() {
        super.clear();
        major_ = 0;
        bitField0_ = (bitField0_ & ~0x00000001);
        minor_ = 0;
        bitField0_ = (bitField0_ & ~0x00000002);
        patch_ = 0;
        bitField0_ = (bitField0_ & ~0x00000004);
        suffix_ = "";
        bitField0_ = (bitField0_ & ~0x00000008);
        return this;
      }

      @java.lang.Override
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_Version_descriptor;
      }

      @java.lang.Override
      public com.google.protobuf.compiler.PluginProtos.Version getDefaultInstanceForType() {
        return com.google.protobuf.compiler.PluginProtos.Version.getDefaultInstance();
      }

      @java.lang.Override
      public com.google.protobuf.compiler.PluginProtos.Version build() {
        com.google.protobuf.compiler.PluginProtos.Version result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }

      @java.lang.Override
      public com.google.protobuf.compiler.PluginProtos.Version buildPartial() {
        com.google.protobuf.compiler.PluginProtos.Version result = new com.google.protobuf.compiler.PluginProtos.Version(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) != 0)) {
          result.major_ = major_;
          to_bitField0_ |= 0x00000001;
        }
        if (((from_bitField0_ & 0x00000002) != 0)) {
          result.minor_ = minor_;
          to_bitField0_ |= 0x00000002;
        }
        if (((from_bitField0_ & 0x00000004) != 0)) {
          result.patch_ = patch_;
          to_bitField0_ |= 0x00000004;
        }
        if (((from_bitField0_ & 0x00000008) != 0)) {
          to_bitField0_ |= 0x00000008;
        }
        result.suffix_ = suffix_;
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }

      @java.lang.Override
      public Builder clone() {
        return super.clone();
      }
      @java.lang.Override
      public Builder setField(
          com.google.protobuf.Descriptors.FieldDescriptor field,
          java.lang.Object value) {
        return super.setField(field, value);
      }
      @java.lang.Override
      public Builder clearField(
          com.google.protobuf.Descriptors.FieldDescriptor field) {
        return super.clearField(field);
      }
      @java.lang.Override
      public Builder clearOneof(
          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
        return super.clearOneof(oneof);
      }
      @java.lang.Override
      public Builder setRepeatedField(
          com.google.protobuf.Descriptors.FieldDescriptor field,
          int index, java.lang.Object value) {
        return super.setRepeatedField(field, index, value);
      }
      @java.lang.Override
      public Builder addRepeatedField(
          com.google.protobuf.Descriptors.FieldDescriptor field,
          java.lang.Object value) {
        return super.addRepeatedField(field, value);
      }
      @java.lang.Override
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof com.google.protobuf.compiler.PluginProtos.Version) {
          return mergeFrom((com.google.protobuf.compiler.PluginProtos.Version)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }

      public Builder mergeFrom(com.google.protobuf.compiler.PluginProtos.Version other) {
        if (other == com.google.protobuf.compiler.PluginProtos.Version.getDefaultInstance()) return this;
        if (other.hasMajor()) {
          setMajor(other.getMajor());
        }
        if (other.hasMinor()) {
          setMinor(other.getMinor());
        }
        if (other.hasPatch()) {
          setPatch(other.getPatch());
        }
        if (other.hasSuffix()) {
          bitField0_ |= 0x00000008;
          suffix_ = other.suffix_;
          onChanged();
        }
        this.mergeUnknownFields(other.unknownFields);
        onChanged();
        return this;
      }

      @java.lang.Override
      public final boolean isInitialized() {
        return true;
      }

      @java.lang.Override
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.compiler.PluginProtos.Version parsedMessage = null;
        try {
          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
          parsedMessage = (com.google.protobuf.compiler.PluginProtos.Version) e.getUnfinishedMessage();
          throw e.unwrapIOException();
        } finally {
          if (parsedMessage != null) {
            mergeFrom(parsedMessage);
          }
        }
        return this;
      }
      private int bitField0_;

      private int major_ ;
      optional int32 major = 1;
Returns: Whether the major field is set./**
       * <code>optional int32 major = 1;</code>
       * @return Whether the major field is set.
       */
      public boolean hasMajor() {
        return ((bitField0_ & 0x00000001) != 0);
      }
      optional int32 major = 1;
Returns: The major./**
       * <code>optional int32 major = 1;</code>
       * @return The major.
       */
      public int getMajor() {
        return major_;
      }
      optional int32 major = 1;
Params: value – The major to set.
Returns: This builder for chaining./**
       * <code>optional int32 major = 1;</code>
       * @param value The major to set.
       * @return This builder for chaining.
       */
      public Builder setMajor(int value) {
        bitField0_ |= 0x00000001;
        major_ = value;
        onChanged();
        return this;
      }
      optional int32 major = 1;
Returns: This builder for chaining./**
       * <code>optional int32 major = 1;</code>
       * @return This builder for chaining.
       */
      public Builder clearMajor() {
        bitField0_ = (bitField0_ & ~0x00000001);
        major_ = 0;
        onChanged();
        return this;
      }

      private int minor_ ;
      optional int32 minor = 2;
Returns: Whether the minor field is set./**
       * <code>optional int32 minor = 2;</code>
       * @return Whether the minor field is set.
       */
      public boolean hasMinor() {
        return ((bitField0_ & 0x00000002) != 0);
      }
      optional int32 minor = 2;
Returns: The minor./**
       * <code>optional int32 minor = 2;</code>
       * @return The minor.
       */
      public int getMinor() {
        return minor_;
      }
      optional int32 minor = 2;
Params: value – The minor to set.
Returns: This builder for chaining./**
       * <code>optional int32 minor = 2;</code>
       * @param value The minor to set.
       * @return This builder for chaining.
       */
      public Builder setMinor(int value) {
        bitField0_ |= 0x00000002;
        minor_ = value;
        onChanged();
        return this;
      }
      optional int32 minor = 2;
Returns: This builder for chaining./**
       * <code>optional int32 minor = 2;</code>
       * @return This builder for chaining.
       */
      public Builder clearMinor() {
        bitField0_ = (bitField0_ & ~0x00000002);
        minor_ = 0;
        onChanged();
        return this;
      }

      private int patch_ ;
      optional int32 patch = 3;
Returns: Whether the patch field is set./**
       * <code>optional int32 patch = 3;</code>
       * @return Whether the patch field is set.
       */
      public boolean hasPatch() {
        return ((bitField0_ & 0x00000004) != 0);
      }
      optional int32 patch = 3;
Returns: The patch./**
       * <code>optional int32 patch = 3;</code>
       * @return The patch.
       */
      public int getPatch() {
        return patch_;
      }
      optional int32 patch = 3;
Params: value – The patch to set.
Returns: This builder for chaining./**
       * <code>optional int32 patch = 3;</code>
       * @param value The patch to set.
       * @return This builder for chaining.
       */
      public Builder setPatch(int value) {
        bitField0_ |= 0x00000004;
        patch_ = value;
        onChanged();
        return this;
      }
      optional int32 patch = 3;
Returns: This builder for chaining./**
       * <code>optional int32 patch = 3;</code>
       * @return This builder for chaining.
       */
      public Builder clearPatch() {
        bitField0_ = (bitField0_ & ~0x00000004);
        patch_ = 0;
        onChanged();
        return this;
      }

      private java.lang.Object suffix_ = "";
      A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
be empty for mainline stable releases.

optional string suffix = 4;
Returns: Whether the suffix field is set./**
       * <pre>
       * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
       * be empty for mainline stable releases.
       * </pre>
       *
       * <code>optional string suffix = 4;</code>
       * @return Whether the suffix field is set.
       */
      public boolean hasSuffix() {
        return ((bitField0_ & 0x00000008) != 0);
      }
      A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
be empty for mainline stable releases.

optional string suffix = 4;
Returns: The suffix./**
       * <pre>
       * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
       * be empty for mainline stable releases.
       * </pre>
       *
       * <code>optional string suffix = 4;</code>
       * @return The suffix.
       */
      public java.lang.String getSuffix() {
        java.lang.Object ref = suffix_;
        if (!(ref instanceof java.lang.String)) {
          com.google.protobuf.ByteString bs =
              (com.google.protobuf.ByteString) ref;
          java.lang.String s = bs.toStringUtf8();
          if (bs.isValidUtf8()) {
            suffix_ = s;
          }
          return s;
        } else {
          return (java.lang.String) ref;
        }
      }
      A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
be empty for mainline stable releases.

optional string suffix = 4;
Returns: The bytes for suffix./**
       * <pre>
       * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
       * be empty for mainline stable releases.
       * </pre>
       *
       * <code>optional string suffix = 4;</code>
       * @return The bytes for suffix.
       */
      public com.google.protobuf.ByteString
          getSuffixBytes() {
        java.lang.Object ref = suffix_;
        if (ref instanceof String) {
          com.google.protobuf.ByteString b = 
              com.google.protobuf.ByteString.copyFromUtf8(
                  (java.lang.String) ref);
          suffix_ = b;
          return b;
        } else {
          return (com.google.protobuf.ByteString) ref;
        }
      }
      A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
be empty for mainline stable releases.

optional string suffix = 4;
Params: value – The suffix to set.
Returns: This builder for chaining./**
       * <pre>
       * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
       * be empty for mainline stable releases.
       * </pre>
       *
       * <code>optional string suffix = 4;</code>
       * @param value The suffix to set.
       * @return This builder for chaining.
       */
      public Builder setSuffix(
          java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000008;
        suffix_ = value;
        onChanged();
        return this;
      }
      A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
be empty for mainline stable releases.

optional string suffix = 4;
Returns: This builder for chaining./**
       * <pre>
       * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
       * be empty for mainline stable releases.
       * </pre>
       *
       * <code>optional string suffix = 4;</code>
       * @return This builder for chaining.
       */
      public Builder clearSuffix() {
        bitField0_ = (bitField0_ & ~0x00000008);
        suffix_ = getDefaultInstance().getSuffix();
        onChanged();
        return this;
      }
      A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
be empty for mainline stable releases.

optional string suffix = 4;
Params: value – The bytes for suffix to set.
Returns: This builder for chaining./**
       * <pre>
       * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
       * be empty for mainline stable releases.
       * </pre>
       *
       * <code>optional string suffix = 4;</code>
       * @param value The bytes for suffix to set.
       * @return This builder for chaining.
       */
      public Builder setSuffixBytes(
          com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000008;
        suffix_ = value;
        onChanged();
        return this;
      }
      @java.lang.Override
      public final Builder setUnknownFields(
          final com.google.protobuf.UnknownFieldSet unknownFields) {
        return super.setUnknownFields(unknownFields);
      }

      @java.lang.Override
      public final Builder mergeUnknownFields(
          final com.google.protobuf.UnknownFieldSet unknownFields) {
        return super.mergeUnknownFields(unknownFields);
      }


      // @@protoc_insertion_point(builder_scope:google.protobuf.compiler.Version)
    }

    // @@protoc_insertion_point(class_scope:google.protobuf.compiler.Version)
    private static final com.google.protobuf.compiler.PluginProtos.Version DEFAULT_INSTANCE;
    static {
      DEFAULT_INSTANCE = new com.google.protobuf.compiler.PluginProtos.Version();
    }

    public static com.google.protobuf.compiler.PluginProtos.Version getDefaultInstance() {
      return DEFAULT_INSTANCE;
    }

    @java.lang.Deprecated public static final com.google.protobuf.Parser<Version>
        PARSER = new com.google.protobuf.AbstractParser<Version>() {
      @java.lang.Override
      public Version parsePartialFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return new Version(input, extensionRegistry);
      }
    };

    public static com.google.protobuf.Parser<Version> parser() {
      return PARSER;
    }

    @java.lang.Override
    public com.google.protobuf.Parser<Version> getParserForType() {
      return PARSER;
    }

    @java.lang.Override
    public com.google.protobuf.compiler.PluginProtos.Version getDefaultInstanceForType() {
      return DEFAULT_INSTANCE;
    }

  }

  public interface CodeGeneratorRequestOrBuilder extends
      // @@protoc_insertion_point(interface_extends:google.protobuf.compiler.CodeGeneratorRequest)
      com.google.protobuf.MessageOrBuilder {

    The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Returns: A list containing the fileToGenerate./**
     * <pre>
     * The .proto files that were explicitly listed on the command-line.  The
     * code generator should generate code only for these files.  Each file's
     * descriptor will be included in proto_file, below.
     * </pre>
     *
     * <code>repeated string file_to_generate = 1;</code>
     * @return A list containing the fileToGenerate.
     */
    java.util.List<java.lang.String>
        getFileToGenerateList();
    The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Returns: The count of fileToGenerate./**
     * <pre>
     * The .proto files that were explicitly listed on the command-line.  The
     * code generator should generate code only for these files.  Each file's
     * descriptor will be included in proto_file, below.
     * </pre>
     *
     * <code>repeated string file_to_generate = 1;</code>
     * @return The count of fileToGenerate.
     */
    int getFileToGenerateCount();
    The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Params: index – The index of the element to return.
Returns: The fileToGenerate at the given index./**
     * <pre>
     * The .proto files that were explicitly listed on the command-line.  The
     * code generator should generate code only for these files.  Each file's
     * descriptor will be included in proto_file, below.
     * </pre>
     *
     * <code>repeated string file_to_generate = 1;</code>
     * @param index The index of the element to return.
     * @return The fileToGenerate at the given index.
     */
    java.lang.String getFileToGenerate(int index);
    The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Params: index – The index of the value to return.
Returns: The bytes of the fileToGenerate at the given index./**
     * <pre>
     * The .proto files that were explicitly listed on the command-line.  The
     * code generator should generate code only for these files.  Each file's
     * descriptor will be included in proto_file, below.
     * </pre>
     *
     * <code>repeated string file_to_generate = 1;</code>
     * @param index The index of the value to return.
     * @return The bytes of the fileToGenerate at the given index.
     */
    com.google.protobuf.ByteString
        getFileToGenerateBytes(int index);

    The generator parameter passed on the command-line.

optional string parameter = 2;
Returns: Whether the parameter field is set./**
     * <pre>
     * The generator parameter passed on the command-line.
     * </pre>
     *
     * <code>optional string parameter = 2;</code>
     * @return Whether the parameter field is set.
     */
    boolean hasParameter();
    The generator parameter passed on the command-line.

optional string parameter = 2;
Returns: The parameter./**
     * <pre>
     * The generator parameter passed on the command-line.
     * </pre>
     *
     * <code>optional string parameter = 2;</code>
     * @return The parameter.
     */
    java.lang.String getParameter();
    The generator parameter passed on the command-line.

optional string parameter = 2;
Returns: The bytes for parameter./**
     * <pre>
     * The generator parameter passed on the command-line.
     * </pre>
     *
     * <code>optional string parameter = 2;</code>
     * @return The bytes for parameter.
     */
    com.google.protobuf.ByteString
        getParameterBytes();

    FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
     * <pre>
     * FileDescriptorProtos for all files in files_to_generate and everything
     * they import.  The files will appear in topological order, so each file
     * appears before any file that imports it.
     * protoc guarantees that all proto_files will be written after
     * the fields above, even though this is not technically guaranteed by the
     * protobuf wire format.  This theoretically could allow a plugin to stream
     * in the FileDescriptorProtos and handle them one by one rather than read
     * the entire set into memory at once.  However, as of this writing, this
     * is not similarly optimized on protoc's end -- it will store all fields in
     * memory at once before sending them to the plugin.
     * Type names of fields and extensions in the FileDescriptorProto are always
     * fully qualified.
     * </pre>
     *
     * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
     */
    java.util.List<com.google.protobuf.DescriptorProtos.FileDescriptorProto> 
        getProtoFileList();
    FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
     * <pre>
     * FileDescriptorProtos for all files in files_to_generate and everything
     * they import.  The files will appear in topological order, so each file
     * appears before any file that imports it.
     * protoc guarantees that all proto_files will be written after
     * the fields above, even though this is not technically guaranteed by the
     * protobuf wire format.  This theoretically could allow a plugin to stream
     * in the FileDescriptorProtos and handle them one by one rather than read
     * the entire set into memory at once.  However, as of this writing, this
     * is not similarly optimized on protoc's end -- it will store all fields in
     * memory at once before sending them to the plugin.
     * Type names of fields and extensions in the FileDescriptorProto are always
     * fully qualified.
     * </pre>
     *
     * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
     */
    com.google.protobuf.DescriptorProtos.FileDescriptorProto getProtoFile(int index);
    FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
     * <pre>
     * FileDescriptorProtos for all files in files_to_generate and everything
     * they import.  The files will appear in topological order, so each file
     * appears before any file that imports it.
     * protoc guarantees that all proto_files will be written after
     * the fields above, even though this is not technically guaranteed by the
     * protobuf wire format.  This theoretically could allow a plugin to stream
     * in the FileDescriptorProtos and handle them one by one rather than read
     * the entire set into memory at once.  However, as of this writing, this
     * is not similarly optimized on protoc's end -- it will store all fields in
     * memory at once before sending them to the plugin.
     * Type names of fields and extensions in the FileDescriptorProto are always
     * fully qualified.
     * </pre>
     *
     * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
     */
    int getProtoFileCount();
    FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
     * <pre>
     * FileDescriptorProtos for all files in files_to_generate and everything
     * they import.  The files will appear in topological order, so each file
     * appears before any file that imports it.
     * protoc guarantees that all proto_files will be written after
     * the fields above, even though this is not technically guaranteed by the
     * protobuf wire format.  This theoretically could allow a plugin to stream
     * in the FileDescriptorProtos and handle them one by one rather than read
     * the entire set into memory at once.  However, as of this writing, this
     * is not similarly optimized on protoc's end -- it will store all fields in
     * memory at once before sending them to the plugin.
     * Type names of fields and extensions in the FileDescriptorProto are always
     * fully qualified.
     * </pre>
     *
     * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
     */
    java.util.List<? extends com.google.protobuf.DescriptorProtos.FileDescriptorProtoOrBuilder> 
        getProtoFileOrBuilderList();
    FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
     * <pre>
     * FileDescriptorProtos for all files in files_to_generate and everything
     * they import.  The files will appear in topological order, so each file
     * appears before any file that imports it.
     * protoc guarantees that all proto_files will be written after
     * the fields above, even though this is not technically guaranteed by the
     * protobuf wire format.  This theoretically could allow a plugin to stream
     * in the FileDescriptorProtos and handle them one by one rather than read
     * the entire set into memory at once.  However, as of this writing, this
     * is not similarly optimized on protoc's end -- it will store all fields in
     * memory at once before sending them to the plugin.
     * Type names of fields and extensions in the FileDescriptorProto are always
     * fully qualified.
     * </pre>
     *
     * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
     */
    com.google.protobuf.DescriptorProtos.FileDescriptorProtoOrBuilder getProtoFileOrBuilder(
        int index);

    The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
Returns: Whether the compilerVersion field is set./**
     * <pre>
     * The version number of protocol compiler.
     * </pre>
     *
     * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
     * @return Whether the compilerVersion field is set.
     */
    boolean hasCompilerVersion();
    The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
Returns: The compilerVersion./**
     * <pre>
     * The version number of protocol compiler.
     * </pre>
     *
     * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
     * @return The compilerVersion.
     */
    com.google.protobuf.compiler.PluginProtos.Version getCompilerVersion();
    The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
/**
     * <pre>
     * The version number of protocol compiler.
     * </pre>
     *
     * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
     */
    com.google.protobuf.compiler.PluginProtos.VersionOrBuilder getCompilerVersionOrBuilder();
  }
  An encoded CodeGeneratorRequest is written to the plugin's stdin.
 Protobuf type google.protobuf.compiler.CodeGeneratorRequest /**
   * <pre>
   * An encoded CodeGeneratorRequest is written to the plugin's stdin.
   * </pre>
   *
   * Protobuf type {@code google.protobuf.compiler.CodeGeneratorRequest}
   */
  public  static final class CodeGeneratorRequest extends
      com.google.protobuf.GeneratedMessageV3 implements
      // @@protoc_insertion_point(message_implements:google.protobuf.compiler.CodeGeneratorRequest)
      CodeGeneratorRequestOrBuilder {
  private static final long serialVersionUID = 0L;
    // Use CodeGeneratorRequest.newBuilder() to construct.
    private CodeGeneratorRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
      super(builder);
    }
    private CodeGeneratorRequest() {
      fileToGenerate_ = com.google.protobuf.LazyStringArrayList.EMPTY;
      parameter_ = "";
      protoFile_ = java.util.Collections.emptyList();
    }

    @java.lang.Override
    @SuppressWarnings({"unused"})
    protected java.lang.Object newInstance(
        UnusedPrivateParameter unused) {
      return new CodeGeneratorRequest();
    }

    @java.lang.Override
    public final com.google.protobuf.UnknownFieldSet
    getUnknownFields() {
      return this.unknownFields;
    }
    private CodeGeneratorRequest(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      this();
      if (extensionRegistry == null) {
        throw new java.lang.NullPointerException();
      }
      int mutable_bitField0_ = 0;
      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder();
      try {
        boolean done = false;
        while (!done) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              done = true;
              break;
            case 10: {
              com.google.protobuf.ByteString bs = input.readBytes();
              if (!((mutable_bitField0_ & 0x00000001) != 0)) {
                fileToGenerate_ = new com.google.protobuf.LazyStringArrayList();
                mutable_bitField0_ |= 0x00000001;
              }
              fileToGenerate_.add(bs);
              break;
            }
            case 18: {
              com.google.protobuf.ByteString bs = input.readBytes();
              bitField0_ |= 0x00000001;
              parameter_ = bs;
              break;
            }
            case 26: {
              com.google.protobuf.compiler.PluginProtos.Version.Builder subBuilder = null;
              if (((bitField0_ & 0x00000002) != 0)) {
                subBuilder = compilerVersion_.toBuilder();
              }
              compilerVersion_ = input.readMessage(com.google.protobuf.compiler.PluginProtos.Version.PARSER, extensionRegistry);
              if (subBuilder != null) {
                subBuilder.mergeFrom(compilerVersion_);
                compilerVersion_ = subBuilder.buildPartial();
              }
              bitField0_ |= 0x00000002;
              break;
            }
            case 122: {
              if (!((mutable_bitField0_ & 0x00000004) != 0)) {
                protoFile_ = new java.util.ArrayList<com.google.protobuf.DescriptorProtos.FileDescriptorProto>();
                mutable_bitField0_ |= 0x00000004;
              }
              protoFile_.add(
                  input.readMessage(com.google.protobuf.DescriptorProtos.FileDescriptorProto.PARSER, extensionRegistry));
              break;
            }
            default: {
              if (!parseUnknownField(
                  input, unknownFields, extensionRegistry, tag)) {
                done = true;
              }
              break;
            }
          }
        }
      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
        throw e.setUnfinishedMessage(this);
      } catch (java.io.IOException e) {
        throw new com.google.protobuf.InvalidProtocolBufferException(
            e).setUnfinishedMessage(this);
      } finally {
        if (((mutable_bitField0_ & 0x00000001) != 0)) {
          fileToGenerate_ = fileToGenerate_.getUnmodifiableView();
        }
        if (((mutable_bitField0_ & 0x00000004) != 0)) {
          protoFile_ = java.util.Collections.unmodifiableList(protoFile_);
        }
        this.unknownFields = unknownFields.build();
        makeExtensionsImmutable();
      }
    }
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorRequest_descriptor;
    }

    @java.lang.Override
    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorRequest_fieldAccessorTable
          .ensureFieldAccessorsInitialized(
              com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest.class, com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest.Builder.class);
    }

    private int bitField0_;
    public static final int FILE_TO_GENERATE_FIELD_NUMBER = 1;
    private com.google.protobuf.LazyStringList fileToGenerate_;
    The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Returns: A list containing the fileToGenerate./**
     * <pre>
     * The .proto files that were explicitly listed on the command-line.  The
     * code generator should generate code only for these files.  Each file's
     * descriptor will be included in proto_file, below.
     * </pre>
     *
     * <code>repeated string file_to_generate = 1;</code>
     * @return A list containing the fileToGenerate.
     */
    public com.google.protobuf.ProtocolStringList
        getFileToGenerateList() {
      return fileToGenerate_;
    }
    The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Returns: The count of fileToGenerate./**
     * <pre>
     * The .proto files that were explicitly listed on the command-line.  The
     * code generator should generate code only for these files.  Each file's
     * descriptor will be included in proto_file, below.
     * </pre>
     *
     * <code>repeated string file_to_generate = 1;</code>
     * @return The count of fileToGenerate.
     */
    public int getFileToGenerateCount() {
      return fileToGenerate_.size();
    }
    The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Params: index – The index of the element to return.
Returns: The fileToGenerate at the given index./**
     * <pre>
     * The .proto files that were explicitly listed on the command-line.  The
     * code generator should generate code only for these files.  Each file's
     * descriptor will be included in proto_file, below.
     * </pre>
     *
     * <code>repeated string file_to_generate = 1;</code>
     * @param index The index of the element to return.
     * @return The fileToGenerate at the given index.
     */
    public java.lang.String getFileToGenerate(int index) {
      return fileToGenerate_.get(index);
    }
    The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Params: index – The index of the value to return.
Returns: The bytes of the fileToGenerate at the given index./**
     * <pre>
     * The .proto files that were explicitly listed on the command-line.  The
     * code generator should generate code only for these files.  Each file's
     * descriptor will be included in proto_file, below.
     * </pre>
     *
     * <code>repeated string file_to_generate = 1;</code>
     * @param index The index of the value to return.
     * @return The bytes of the fileToGenerate at the given index.
     */
    public com.google.protobuf.ByteString
        getFileToGenerateBytes(int index) {
      return fileToGenerate_.getByteString(index);
    }

    public static final int PARAMETER_FIELD_NUMBER = 2;
    private volatile java.lang.Object parameter_;
    The generator parameter passed on the command-line.

optional string parameter = 2;
Returns: Whether the parameter field is set./**
     * <pre>
     * The generator parameter passed on the command-line.
     * </pre>
     *
     * <code>optional string parameter = 2;</code>
     * @return Whether the parameter field is set.
     */
    public boolean hasParameter() {
      return ((bitField0_ & 0x00000001) != 0);
    }
    The generator parameter passed on the command-line.

optional string parameter = 2;
Returns: The parameter./**
     * <pre>
     * The generator parameter passed on the command-line.
     * </pre>
     *
     * <code>optional string parameter = 2;</code>
     * @return The parameter.
     */
    public java.lang.String getParameter() {
      java.lang.Object ref = parameter_;
      if (ref instanceof java.lang.String) {
        return (java.lang.String) ref;
      } else {
        com.google.protobuf.ByteString bs = 
            (com.google.protobuf.ByteString) ref;
        java.lang.String s = bs.toStringUtf8();
        if (bs.isValidUtf8()) {
          parameter_ = s;
        }
        return s;
      }
    }
    The generator parameter passed on the command-line.

optional string parameter = 2;
Returns: The bytes for parameter./**
     * <pre>
     * The generator parameter passed on the command-line.
     * </pre>
     *
     * <code>optional string parameter = 2;</code>
     * @return The bytes for parameter.
     */
    public com.google.protobuf.ByteString
        getParameterBytes() {
      java.lang.Object ref = parameter_;
      if (ref instanceof java.lang.String) {
        com.google.protobuf.ByteString b = 
            com.google.protobuf.ByteString.copyFromUtf8(
                (java.lang.String) ref);
        parameter_ = b;
        return b;
      } else {
        return (com.google.protobuf.ByteString) ref;
      }
    }

    public static final int PROTO_FILE_FIELD_NUMBER = 15;
    private java.util.List<com.google.protobuf.DescriptorProtos.FileDescriptorProto> protoFile_;
    FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
     * <pre>
     * FileDescriptorProtos for all files in files_to_generate and everything
     * they import.  The files will appear in topological order, so each file
     * appears before any file that imports it.
     * protoc guarantees that all proto_files will be written after
     * the fields above, even though this is not technically guaranteed by the
     * protobuf wire format.  This theoretically could allow a plugin to stream
     * in the FileDescriptorProtos and handle them one by one rather than read
     * the entire set into memory at once.  However, as of this writing, this
     * is not similarly optimized on protoc's end -- it will store all fields in
     * memory at once before sending them to the plugin.
     * Type names of fields and extensions in the FileDescriptorProto are always
     * fully qualified.
     * </pre>
     *
     * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
     */
    public java.util.List<com.google.protobuf.DescriptorProtos.FileDescriptorProto> getProtoFileList() {
      return protoFile_;
    }
    FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
     * <pre>
     * FileDescriptorProtos for all files in files_to_generate and everything
     * they import.  The files will appear in topological order, so each file
     * appears before any file that imports it.
     * protoc guarantees that all proto_files will be written after
     * the fields above, even though this is not technically guaranteed by the
     * protobuf wire format.  This theoretically could allow a plugin to stream
     * in the FileDescriptorProtos and handle them one by one rather than read
     * the entire set into memory at once.  However, as of this writing, this
     * is not similarly optimized on protoc's end -- it will store all fields in
     * memory at once before sending them to the plugin.
     * Type names of fields and extensions in the FileDescriptorProto are always
     * fully qualified.
     * </pre>
     *
     * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
     */
    public java.util.List<? extends com.google.protobuf.DescriptorProtos.FileDescriptorProtoOrBuilder> 
        getProtoFileOrBuilderList() {
      return protoFile_;
    }
    FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
     * <pre>
     * FileDescriptorProtos for all files in files_to_generate and everything
     * they import.  The files will appear in topological order, so each file
     * appears before any file that imports it.
     * protoc guarantees that all proto_files will be written after
     * the fields above, even though this is not technically guaranteed by the
     * protobuf wire format.  This theoretically could allow a plugin to stream
     * in the FileDescriptorProtos and handle them one by one rather than read
     * the entire set into memory at once.  However, as of this writing, this
     * is not similarly optimized on protoc's end -- it will store all fields in
     * memory at once before sending them to the plugin.
     * Type names of fields and extensions in the FileDescriptorProto are always
     * fully qualified.
     * </pre>
     *
     * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
     */
    public int getProtoFileCount() {
      return protoFile_.size();
    }
    FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
     * <pre>
     * FileDescriptorProtos for all files in files_to_generate and everything
     * they import.  The files will appear in topological order, so each file
     * appears before any file that imports it.
     * protoc guarantees that all proto_files will be written after
     * the fields above, even though this is not technically guaranteed by the
     * protobuf wire format.  This theoretically could allow a plugin to stream
     * in the FileDescriptorProtos and handle them one by one rather than read
     * the entire set into memory at once.  However, as of this writing, this
     * is not similarly optimized on protoc's end -- it will store all fields in
     * memory at once before sending them to the plugin.
     * Type names of fields and extensions in the FileDescriptorProto are always
     * fully qualified.
     * </pre>
     *
     * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
     */
    public com.google.protobuf.DescriptorProtos.FileDescriptorProto getProtoFile(int index) {
      return protoFile_.get(index);
    }
    FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
     * <pre>
     * FileDescriptorProtos for all files in files_to_generate and everything
     * they import.  The files will appear in topological order, so each file
     * appears before any file that imports it.
     * protoc guarantees that all proto_files will be written after
     * the fields above, even though this is not technically guaranteed by the
     * protobuf wire format.  This theoretically could allow a plugin to stream
     * in the FileDescriptorProtos and handle them one by one rather than read
     * the entire set into memory at once.  However, as of this writing, this
     * is not similarly optimized on protoc's end -- it will store all fields in
     * memory at once before sending them to the plugin.
     * Type names of fields and extensions in the FileDescriptorProto are always
     * fully qualified.
     * </pre>
     *
     * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
     */
    public com.google.protobuf.DescriptorProtos.FileDescriptorProtoOrBuilder getProtoFileOrBuilder(
        int index) {
      return protoFile_.get(index);
    }

    public static final int COMPILER_VERSION_FIELD_NUMBER = 3;
    private com.google.protobuf.compiler.PluginProtos.Version compilerVersion_;
    The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
Returns: Whether the compilerVersion field is set./**
     * <pre>
     * The version number of protocol compiler.
     * </pre>
     *
     * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
     * @return Whether the compilerVersion field is set.
     */
    public boolean hasCompilerVersion() {
      return ((bitField0_ & 0x00000002) != 0);
    }
    The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
Returns: The compilerVersion./**
     * <pre>
     * The version number of protocol compiler.
     * </pre>
     *
     * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
     * @return The compilerVersion.
     */
    public com.google.protobuf.compiler.PluginProtos.Version getCompilerVersion() {
      return compilerVersion_ == null ? com.google.protobuf.compiler.PluginProtos.Version.getDefaultInstance() : compilerVersion_;
    }
    The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
/**
     * <pre>
     * The version number of protocol compiler.
     * </pre>
     *
     * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
     */
    public com.google.protobuf.compiler.PluginProtos.VersionOrBuilder getCompilerVersionOrBuilder() {
      return compilerVersion_ == null ? com.google.protobuf.compiler.PluginProtos.Version.getDefaultInstance() : compilerVersion_;
    }

    private byte memoizedIsInitialized = -1;
    @java.lang.Override
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized == 1) return true;
      if (isInitialized == 0) return false;

      for (int i = 0; i < getProtoFileCount(); i++) {
        if (!getProtoFile(i).isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      memoizedIsInitialized = 1;
      return true;
    }

    @java.lang.Override
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      for (int i = 0; i < fileToGenerate_.size(); i++) {
        com.google.protobuf.GeneratedMessageV3.writeString(output, 1, fileToGenerate_.getRaw(i));
      }
      if (((bitField0_ & 0x00000001) != 0)) {
        com.google.protobuf.GeneratedMessageV3.writeString(output, 2, parameter_);
      }
      if (((bitField0_ & 0x00000002) != 0)) {
        output.writeMessage(3, getCompilerVersion());
      }
      for (int i = 0; i < protoFile_.size(); i++) {
        output.writeMessage(15, protoFile_.get(i));
      }
      unknownFields.writeTo(output);
    }

    @java.lang.Override
    public int getSerializedSize() {
      int size = memoizedSize;
      if (size != -1) return size;

      size = 0;
      {
        int dataSize = 0;
        for (int i = 0; i < fileToGenerate_.size(); i++) {
          dataSize += computeStringSizeNoTag(fileToGenerate_.getRaw(i));
        }
        size += dataSize;
        size += 1 * getFileToGenerateList().size();
      }
      if (((bitField0_ & 0x00000001) != 0)) {
        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, parameter_);
      }
      if (((bitField0_ & 0x00000002) != 0)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(3, getCompilerVersion());
      }
      for (int i = 0; i < protoFile_.size(); i++) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(15, protoFile_.get(i));
      }
      size += unknownFields.getSerializedSize();
      memoizedSize = size;
      return size;
    }

    @java.lang.Override
    public boolean equals(final java.lang.Object obj) {
      if (obj == this) {
       return true;
      }
      if (!(obj instanceof com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest)) {
        return super.equals(obj);
      }
      com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest other = (com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest) obj;

      if (!getFileToGenerateList()
          .equals(other.getFileToGenerateList())) return false;
      if (hasParameter() != other.hasParameter()) return false;
      if (hasParameter()) {
        if (!getParameter()
            .equals(other.getParameter())) return false;
      }
      if (!getProtoFileList()
          .equals(other.getProtoFileList())) return false;
      if (hasCompilerVersion() != other.hasCompilerVersion()) return false;
      if (hasCompilerVersion()) {
        if (!getCompilerVersion()
            .equals(other.getCompilerVersion())) return false;
      }
      if (!unknownFields.equals(other.unknownFields)) return false;
      return true;
    }

    @java.lang.Override
    public int hashCode() {
      if (memoizedHashCode != 0) {
        return memoizedHashCode;
      }
      int hash = 41;
      hash = (19 * hash) + getDescriptor().hashCode();
      if (getFileToGenerateCount() > 0) {
        hash = (37 * hash) + FILE_TO_GENERATE_FIELD_NUMBER;
        hash = (53 * hash) + getFileToGenerateList().hashCode();
      }
      if (hasParameter()) {
        hash = (37 * hash) + PARAMETER_FIELD_NUMBER;
        hash = (53 * hash) + getParameter().hashCode();
      }
      if (getProtoFileCount() > 0) {
        hash = (37 * hash) + PROTO_FILE_FIELD_NUMBER;
        hash = (53 * hash) + getProtoFileList().hashCode();
      }
      if (hasCompilerVersion()) {
        hash = (37 * hash) + COMPILER_VERSION_FIELD_NUMBER;
        hash = (53 * hash) + getCompilerVersion().hashCode();
      }
      hash = (29 * hash) + unknownFields.hashCode();
      memoizedHashCode = hash;
      return hash;
    }

    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
        java.nio.ByteBuffer data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
        java.nio.ByteBuffer data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseWithIOException(PARSER, input);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseWithIOException(PARSER, input, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseDelimitedWithIOException(PARSER, input);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseWithIOException(PARSER, input);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseWithIOException(PARSER, input, extensionRegistry);
    }

    @java.lang.Override
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder() {
      return DEFAULT_INSTANCE.toBuilder();
    }
    public static Builder newBuilder(com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest prototype) {
      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
    }
    @java.lang.Override
    public Builder toBuilder() {
      return this == DEFAULT_INSTANCE
          ? new Builder() : new Builder().mergeFrom(this);
    }

    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    An encoded CodeGeneratorRequest is written to the plugin's stdin.
 Protobuf type google.protobuf.compiler.CodeGeneratorRequest /**
     * <pre>
     * An encoded CodeGeneratorRequest is written to the plugin's stdin.
     * </pre>
     *
     * Protobuf type {@code google.protobuf.compiler.CodeGeneratorRequest}
     */
    public static final class Builder extends
        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
        // @@protoc_insertion_point(builder_implements:google.protobuf.compiler.CodeGeneratorRequest)
        com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequestOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorRequest_descriptor;
      }

      @java.lang.Override
      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorRequest_fieldAccessorTable
            .ensureFieldAccessorsInitialized(
                com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest.class, com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest.Builder.class);
      }

      // Construct using com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }

      private Builder(
          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessageV3
                .alwaysUseFieldBuilders) {
          getProtoFileFieldBuilder();
          getCompilerVersionFieldBuilder();
        }
      }
      @java.lang.Override
      public Builder clear() {
        super.clear();
        fileToGenerate_ = com.google.protobuf.LazyStringArrayList.EMPTY;
        bitField0_ = (bitField0_ & ~0x00000001);
        parameter_ = "";
        bitField0_ = (bitField0_ & ~0x00000002);
        if (protoFileBuilder_ == null) {
          protoFile_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000004);
        } else {
          protoFileBuilder_.clear();
        }
        if (compilerVersionBuilder_ == null) {
          compilerVersion_ = null;
        } else {
          compilerVersionBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000008);
        return this;
      }

      @java.lang.Override
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorRequest_descriptor;
      }

      @java.lang.Override
      public com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest getDefaultInstanceForType() {
        return com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest.getDefaultInstance();
      }

      @java.lang.Override
      public com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest build() {
        com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }

      @java.lang.Override
      public com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest buildPartial() {
        com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest result = new com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((bitField0_ & 0x00000001) != 0)) {
          fileToGenerate_ = fileToGenerate_.getUnmodifiableView();
          bitField0_ = (bitField0_ & ~0x00000001);
        }
        result.fileToGenerate_ = fileToGenerate_;
        if (((from_bitField0_ & 0x00000002) != 0)) {
          to_bitField0_ |= 0x00000001;
        }
        result.parameter_ = parameter_;
        if (protoFileBuilder_ == null) {
          if (((bitField0_ & 0x00000004) != 0)) {
            protoFile_ = java.util.Collections.unmodifiableList(protoFile_);
            bitField0_ = (bitField0_ & ~0x00000004);
          }
          result.protoFile_ = protoFile_;
        } else {
          result.protoFile_ = protoFileBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000008) != 0)) {
          if (compilerVersionBuilder_ == null) {
            result.compilerVersion_ = compilerVersion_;
          } else {
            result.compilerVersion_ = compilerVersionBuilder_.build();
          }
          to_bitField0_ |= 0x00000002;
        }
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }

      @java.lang.Override
      public Builder clone() {
        return super.clone();
      }
      @java.lang.Override
      public Builder setField(
          com.google.protobuf.Descriptors.FieldDescriptor field,
          java.lang.Object value) {
        return super.setField(field, value);
      }
      @java.lang.Override
      public Builder clearField(
          com.google.protobuf.Descriptors.FieldDescriptor field) {
        return super.clearField(field);
      }
      @java.lang.Override
      public Builder clearOneof(
          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
        return super.clearOneof(oneof);
      }
      @java.lang.Override
      public Builder setRepeatedField(
          com.google.protobuf.Descriptors.FieldDescriptor field,
          int index, java.lang.Object value) {
        return super.setRepeatedField(field, index, value);
      }
      @java.lang.Override
      public Builder addRepeatedField(
          com.google.protobuf.Descriptors.FieldDescriptor field,
          java.lang.Object value) {
        return super.addRepeatedField(field, value);
      }
      @java.lang.Override
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest) {
          return mergeFrom((com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }

      public Builder mergeFrom(com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest other) {
        if (other == com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest.getDefaultInstance()) return this;
        if (!other.fileToGenerate_.isEmpty()) {
          if (fileToGenerate_.isEmpty()) {
            fileToGenerate_ = other.fileToGenerate_;
            bitField0_ = (bitField0_ & ~0x00000001);
          } else {
            ensureFileToGenerateIsMutable();
            fileToGenerate_.addAll(other.fileToGenerate_);
          }
          onChanged();
        }
        if (other.hasParameter()) {
          bitField0_ |= 0x00000002;
          parameter_ = other.parameter_;
          onChanged();
        }
        if (protoFileBuilder_ == null) {
          if (!other.protoFile_.isEmpty()) {
            if (protoFile_.isEmpty()) {
              protoFile_ = other.protoFile_;
              bitField0_ = (bitField0_ & ~0x00000004);
            } else {
              ensureProtoFileIsMutable();
              protoFile_.addAll(other.protoFile_);
            }
            onChanged();
          }
        } else {
          if (!other.protoFile_.isEmpty()) {
            if (protoFileBuilder_.isEmpty()) {
              protoFileBuilder_.dispose();
              protoFileBuilder_ = null;
              protoFile_ = other.protoFile_;
              bitField0_ = (bitField0_ & ~0x00000004);
              protoFileBuilder_ = 
                com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
                   getProtoFileFieldBuilder() : null;
            } else {
              protoFileBuilder_.addAllMessages(other.protoFile_);
            }
          }
        }
        if (other.hasCompilerVersion()) {
          mergeCompilerVersion(other.getCompilerVersion());
        }
        this.mergeUnknownFields(other.unknownFields);
        onChanged();
        return this;
      }

      @java.lang.Override
      public final boolean isInitialized() {
        for (int i = 0; i < getProtoFileCount(); i++) {
          if (!getProtoFile(i).isInitialized()) {
            return false;
          }
        }
        return true;
      }

      @java.lang.Override
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest parsedMessage = null;
        try {
          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
          parsedMessage = (com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest) e.getUnfinishedMessage();
          throw e.unwrapIOException();
        } finally {
          if (parsedMessage != null) {
            mergeFrom(parsedMessage);
          }
        }
        return this;
      }
      private int bitField0_;

      private com.google.protobuf.LazyStringList fileToGenerate_ = com.google.protobuf.LazyStringArrayList.EMPTY;
      private void ensureFileToGenerateIsMutable() {
        if (!((bitField0_ & 0x00000001) != 0)) {
          fileToGenerate_ = new com.google.protobuf.LazyStringArrayList(fileToGenerate_);
          bitField0_ |= 0x00000001;
         }
      }
      The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Returns: A list containing the fileToGenerate./**
       * <pre>
       * The .proto files that were explicitly listed on the command-line.  The
       * code generator should generate code only for these files.  Each file's
       * descriptor will be included in proto_file, below.
       * </pre>
       *
       * <code>repeated string file_to_generate = 1;</code>
       * @return A list containing the fileToGenerate.
       */
      public com.google.protobuf.ProtocolStringList
          getFileToGenerateList() {
        return fileToGenerate_.getUnmodifiableView();
      }
      The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Returns: The count of fileToGenerate./**
       * <pre>
       * The .proto files that were explicitly listed on the command-line.  The
       * code generator should generate code only for these files.  Each file's
       * descriptor will be included in proto_file, below.
       * </pre>
       *
       * <code>repeated string file_to_generate = 1;</code>
       * @return The count of fileToGenerate.
       */
      public int getFileToGenerateCount() {
        return fileToGenerate_.size();
      }
      The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Params: index – The index of the element to return.
Returns: The fileToGenerate at the given index./**
       * <pre>
       * The .proto files that were explicitly listed on the command-line.  The
       * code generator should generate code only for these files.  Each file's
       * descriptor will be included in proto_file, below.
       * </pre>
       *
       * <code>repeated string file_to_generate = 1;</code>
       * @param index The index of the element to return.
       * @return The fileToGenerate at the given index.
       */
      public java.lang.String getFileToGenerate(int index) {
        return fileToGenerate_.get(index);
      }
      The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Params: index – The index of the value to return.
Returns: The bytes of the fileToGenerate at the given index./**
       * <pre>
       * The .proto files that were explicitly listed on the command-line.  The
       * code generator should generate code only for these files.  Each file's
       * descriptor will be included in proto_file, below.
       * </pre>
       *
       * <code>repeated string file_to_generate = 1;</code>
       * @param index The index of the value to return.
       * @return The bytes of the fileToGenerate at the given index.
       */
      public com.google.protobuf.ByteString
          getFileToGenerateBytes(int index) {
        return fileToGenerate_.getByteString(index);
      }
      The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Params: index – The index to set the value at.
value – The fileToGenerate to set.
Returns: This builder for chaining./**
       * <pre>
       * The .proto files that were explicitly listed on the command-line.  The
       * code generator should generate code only for these files.  Each file's
       * descriptor will be included in proto_file, below.
       * </pre>
       *
       * <code>repeated string file_to_generate = 1;</code>
       * @param index The index to set the value at.
       * @param value The fileToGenerate to set.
       * @return This builder for chaining.
       */
      public Builder setFileToGenerate(
          int index, java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  ensureFileToGenerateIsMutable();
        fileToGenerate_.set(index, value);
        onChanged();
        return this;
      }
      The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Params: value – The fileToGenerate to add.
Returns: This builder for chaining./**
       * <pre>
       * The .proto files that were explicitly listed on the command-line.  The
       * code generator should generate code only for these files.  Each file's
       * descriptor will be included in proto_file, below.
       * </pre>
       *
       * <code>repeated string file_to_generate = 1;</code>
       * @param value The fileToGenerate to add.
       * @return This builder for chaining.
       */
      public Builder addFileToGenerate(
          java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  ensureFileToGenerateIsMutable();
        fileToGenerate_.add(value);
        onChanged();
        return this;
      }
      The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Params: values – The fileToGenerate to add.
Returns: This builder for chaining./**
       * <pre>
       * The .proto files that were explicitly listed on the command-line.  The
       * code generator should generate code only for these files.  Each file's
       * descriptor will be included in proto_file, below.
       * </pre>
       *
       * <code>repeated string file_to_generate = 1;</code>
       * @param values The fileToGenerate to add.
       * @return This builder for chaining.
       */
      public Builder addAllFileToGenerate(
          java.lang.Iterable<java.lang.String> values) {
        ensureFileToGenerateIsMutable();
        com.google.protobuf.AbstractMessageLite.Builder.addAll(
            values, fileToGenerate_);
        onChanged();
        return this;
      }
      The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Returns: This builder for chaining./**
       * <pre>
       * The .proto files that were explicitly listed on the command-line.  The
       * code generator should generate code only for these files.  Each file's
       * descriptor will be included in proto_file, below.
       * </pre>
       *
       * <code>repeated string file_to_generate = 1;</code>
       * @return This builder for chaining.
       */
      public Builder clearFileToGenerate() {
        fileToGenerate_ = com.google.protobuf.LazyStringArrayList.EMPTY;
        bitField0_ = (bitField0_ & ~0x00000001);
        onChanged();
        return this;
      }
      The .proto files that were explicitly listed on the command-line.  The
code generator should generate code only for these files.  Each file's
descriptor will be included in proto_file, below.

repeated string file_to_generate = 1;
Params: value – The bytes of the fileToGenerate to add.
Returns: This builder for chaining./**
       * <pre>
       * The .proto files that were explicitly listed on the command-line.  The
       * code generator should generate code only for these files.  Each file's
       * descriptor will be included in proto_file, below.
       * </pre>
       *
       * <code>repeated string file_to_generate = 1;</code>
       * @param value The bytes of the fileToGenerate to add.
       * @return This builder for chaining.
       */
      public Builder addFileToGenerateBytes(
          com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  ensureFileToGenerateIsMutable();
        fileToGenerate_.add(value);
        onChanged();
        return this;
      }

      private java.lang.Object parameter_ = "";
      The generator parameter passed on the command-line.

optional string parameter = 2;
Returns: Whether the parameter field is set./**
       * <pre>
       * The generator parameter passed on the command-line.
       * </pre>
       *
       * <code>optional string parameter = 2;</code>
       * @return Whether the parameter field is set.
       */
      public boolean hasParameter() {
        return ((bitField0_ & 0x00000002) != 0);
      }
      The generator parameter passed on the command-line.

optional string parameter = 2;
Returns: The parameter./**
       * <pre>
       * The generator parameter passed on the command-line.
       * </pre>
       *
       * <code>optional string parameter = 2;</code>
       * @return The parameter.
       */
      public java.lang.String getParameter() {
        java.lang.Object ref = parameter_;
        if (!(ref instanceof java.lang.String)) {
          com.google.protobuf.ByteString bs =
              (com.google.protobuf.ByteString) ref;
          java.lang.String s = bs.toStringUtf8();
          if (bs.isValidUtf8()) {
            parameter_ = s;
          }
          return s;
        } else {
          return (java.lang.String) ref;
        }
      }
      The generator parameter passed on the command-line.

optional string parameter = 2;
Returns: The bytes for parameter./**
       * <pre>
       * The generator parameter passed on the command-line.
       * </pre>
       *
       * <code>optional string parameter = 2;</code>
       * @return The bytes for parameter.
       */
      public com.google.protobuf.ByteString
          getParameterBytes() {
        java.lang.Object ref = parameter_;
        if (ref instanceof String) {
          com.google.protobuf.ByteString b = 
              com.google.protobuf.ByteString.copyFromUtf8(
                  (java.lang.String) ref);
          parameter_ = b;
          return b;
        } else {
          return (com.google.protobuf.ByteString) ref;
        }
      }
      The generator parameter passed on the command-line.

optional string parameter = 2;
Params: value – The parameter to set.
Returns: This builder for chaining./**
       * <pre>
       * The generator parameter passed on the command-line.
       * </pre>
       *
       * <code>optional string parameter = 2;</code>
       * @param value The parameter to set.
       * @return This builder for chaining.
       */
      public Builder setParameter(
          java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000002;
        parameter_ = value;
        onChanged();
        return this;
      }
      The generator parameter passed on the command-line.

optional string parameter = 2;
Returns: This builder for chaining./**
       * <pre>
       * The generator parameter passed on the command-line.
       * </pre>
       *
       * <code>optional string parameter = 2;</code>
       * @return This builder for chaining.
       */
      public Builder clearParameter() {
        bitField0_ = (bitField0_ & ~0x00000002);
        parameter_ = getDefaultInstance().getParameter();
        onChanged();
        return this;
      }
      The generator parameter passed on the command-line.

optional string parameter = 2;
Params: value – The bytes for parameter to set.
Returns: This builder for chaining./**
       * <pre>
       * The generator parameter passed on the command-line.
       * </pre>
       *
       * <code>optional string parameter = 2;</code>
       * @param value The bytes for parameter to set.
       * @return This builder for chaining.
       */
      public Builder setParameterBytes(
          com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000002;
        parameter_ = value;
        onChanged();
        return this;
      }

      private java.util.List<com.google.protobuf.DescriptorProtos.FileDescriptorProto> protoFile_ =
        java.util.Collections.emptyList();
      private void ensureProtoFileIsMutable() {
        if (!((bitField0_ & 0x00000004) != 0)) {
          protoFile_ = new java.util.ArrayList<com.google.protobuf.DescriptorProtos.FileDescriptorProto>(protoFile_);
          bitField0_ |= 0x00000004;
         }
      }

      private com.google.protobuf.RepeatedFieldBuilderV3<
          com.google.protobuf.DescriptorProtos.FileDescriptorProto, com.google.protobuf.DescriptorProtos.FileDescriptorProto.Builder, com.google.protobuf.DescriptorProtos.FileDescriptorProtoOrBuilder> protoFileBuilder_;

      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public java.util.List<com.google.protobuf.DescriptorProtos.FileDescriptorProto> getProtoFileList() {
        if (protoFileBuilder_ == null) {
          return java.util.Collections.unmodifiableList(protoFile_);
        } else {
          return protoFileBuilder_.getMessageList();
        }
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public int getProtoFileCount() {
        if (protoFileBuilder_ == null) {
          return protoFile_.size();
        } else {
          return protoFileBuilder_.getCount();
        }
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public com.google.protobuf.DescriptorProtos.FileDescriptorProto getProtoFile(int index) {
        if (protoFileBuilder_ == null) {
          return protoFile_.get(index);
        } else {
          return protoFileBuilder_.getMessage(index);
        }
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public Builder setProtoFile(
          int index, com.google.protobuf.DescriptorProtos.FileDescriptorProto value) {
        if (protoFileBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureProtoFileIsMutable();
          protoFile_.set(index, value);
          onChanged();
        } else {
          protoFileBuilder_.setMessage(index, value);
        }
        return this;
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public Builder setProtoFile(
          int index, com.google.protobuf.DescriptorProtos.FileDescriptorProto.Builder builderForValue) {
        if (protoFileBuilder_ == null) {
          ensureProtoFileIsMutable();
          protoFile_.set(index, builderForValue.build());
          onChanged();
        } else {
          protoFileBuilder_.setMessage(index, builderForValue.build());
        }
        return this;
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public Builder addProtoFile(com.google.protobuf.DescriptorProtos.FileDescriptorProto value) {
        if (protoFileBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureProtoFileIsMutable();
          protoFile_.add(value);
          onChanged();
        } else {
          protoFileBuilder_.addMessage(value);
        }
        return this;
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public Builder addProtoFile(
          int index, com.google.protobuf.DescriptorProtos.FileDescriptorProto value) {
        if (protoFileBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureProtoFileIsMutable();
          protoFile_.add(index, value);
          onChanged();
        } else {
          protoFileBuilder_.addMessage(index, value);
        }
        return this;
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public Builder addProtoFile(
          com.google.protobuf.DescriptorProtos.FileDescriptorProto.Builder builderForValue) {
        if (protoFileBuilder_ == null) {
          ensureProtoFileIsMutable();
          protoFile_.add(builderForValue.build());
          onChanged();
        } else {
          protoFileBuilder_.addMessage(builderForValue.build());
        }
        return this;
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public Builder addProtoFile(
          int index, com.google.protobuf.DescriptorProtos.FileDescriptorProto.Builder builderForValue) {
        if (protoFileBuilder_ == null) {
          ensureProtoFileIsMutable();
          protoFile_.add(index, builderForValue.build());
          onChanged();
        } else {
          protoFileBuilder_.addMessage(index, builderForValue.build());
        }
        return this;
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public Builder addAllProtoFile(
          java.lang.Iterable<? extends com.google.protobuf.DescriptorProtos.FileDescriptorProto> values) {
        if (protoFileBuilder_ == null) {
          ensureProtoFileIsMutable();
          com.google.protobuf.AbstractMessageLite.Builder.addAll(
              values, protoFile_);
          onChanged();
        } else {
          protoFileBuilder_.addAllMessages(values);
        }
        return this;
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public Builder clearProtoFile() {
        if (protoFileBuilder_ == null) {
          protoFile_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000004);
          onChanged();
        } else {
          protoFileBuilder_.clear();
        }
        return this;
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public Builder removeProtoFile(int index) {
        if (protoFileBuilder_ == null) {
          ensureProtoFileIsMutable();
          protoFile_.remove(index);
          onChanged();
        } else {
          protoFileBuilder_.remove(index);
        }
        return this;
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public com.google.protobuf.DescriptorProtos.FileDescriptorProto.Builder getProtoFileBuilder(
          int index) {
        return getProtoFileFieldBuilder().getBuilder(index);
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public com.google.protobuf.DescriptorProtos.FileDescriptorProtoOrBuilder getProtoFileOrBuilder(
          int index) {
        if (protoFileBuilder_ == null) {
          return protoFile_.get(index);  } else {
          return protoFileBuilder_.getMessageOrBuilder(index);
        }
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public java.util.List<? extends com.google.protobuf.DescriptorProtos.FileDescriptorProtoOrBuilder> 
           getProtoFileOrBuilderList() {
        if (protoFileBuilder_ != null) {
          return protoFileBuilder_.getMessageOrBuilderList();
        } else {
          return java.util.Collections.unmodifiableList(protoFile_);
        }
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public com.google.protobuf.DescriptorProtos.FileDescriptorProto.Builder addProtoFileBuilder() {
        return getProtoFileFieldBuilder().addBuilder(
            com.google.protobuf.DescriptorProtos.FileDescriptorProto.getDefaultInstance());
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public com.google.protobuf.DescriptorProtos.FileDescriptorProto.Builder addProtoFileBuilder(
          int index) {
        return getProtoFileFieldBuilder().addBuilder(
            index, com.google.protobuf.DescriptorProtos.FileDescriptorProto.getDefaultInstance());
      }
      FileDescriptorProtos for all files in files_to_generate and everything
they import.  The files will appear in topological order, so each file
appears before any file that imports it.
protoc guarantees that all proto_files will be written after
the fields above, even though this is not technically guaranteed by the
protobuf wire format.  This theoretically could allow a plugin to stream
in the FileDescriptorProtos and handle them one by one rather than read
the entire set into memory at once.  However, as of this writing, this
is not similarly optimized on protoc's end -- it will store all fields in
memory at once before sending them to the plugin.
Type names of fields and extensions in the FileDescriptorProto are always
fully qualified.

repeated .google.protobuf.FileDescriptorProto proto_file = 15;
/**
       * <pre>
       * FileDescriptorProtos for all files in files_to_generate and everything
       * they import.  The files will appear in topological order, so each file
       * appears before any file that imports it.
       * protoc guarantees that all proto_files will be written after
       * the fields above, even though this is not technically guaranteed by the
       * protobuf wire format.  This theoretically could allow a plugin to stream
       * in the FileDescriptorProtos and handle them one by one rather than read
       * the entire set into memory at once.  However, as of this writing, this
       * is not similarly optimized on protoc's end -- it will store all fields in
       * memory at once before sending them to the plugin.
       * Type names of fields and extensions in the FileDescriptorProto are always
       * fully qualified.
       * </pre>
       *
       * <code>repeated .google.protobuf.FileDescriptorProto proto_file = 15;</code>
       */
      public java.util.List<com.google.protobuf.DescriptorProtos.FileDescriptorProto.Builder> 
           getProtoFileBuilderList() {
        return getProtoFileFieldBuilder().getBuilderList();
      }
      private com.google.protobuf.RepeatedFieldBuilderV3<
          com.google.protobuf.DescriptorProtos.FileDescriptorProto, com.google.protobuf.DescriptorProtos.FileDescriptorProto.Builder, com.google.protobuf.DescriptorProtos.FileDescriptorProtoOrBuilder> 
          getProtoFileFieldBuilder() {
        if (protoFileBuilder_ == null) {
          protoFileBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
              com.google.protobuf.DescriptorProtos.FileDescriptorProto, com.google.protobuf.DescriptorProtos.FileDescriptorProto.Builder, com.google.protobuf.DescriptorProtos.FileDescriptorProtoOrBuilder>(
                  protoFile_,
                  ((bitField0_ & 0x00000004) != 0),
                  getParentForChildren(),
                  isClean());
          protoFile_ = null;
        }
        return protoFileBuilder_;
      }

      private com.google.protobuf.compiler.PluginProtos.Version compilerVersion_;
      private com.google.protobuf.SingleFieldBuilderV3<
          com.google.protobuf.compiler.PluginProtos.Version, com.google.protobuf.compiler.PluginProtos.Version.Builder, com.google.protobuf.compiler.PluginProtos.VersionOrBuilder> compilerVersionBuilder_;
      The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
Returns: Whether the compilerVersion field is set./**
       * <pre>
       * The version number of protocol compiler.
       * </pre>
       *
       * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
       * @return Whether the compilerVersion field is set.
       */
      public boolean hasCompilerVersion() {
        return ((bitField0_ & 0x00000008) != 0);
      }
      The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
Returns: The compilerVersion./**
       * <pre>
       * The version number of protocol compiler.
       * </pre>
       *
       * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
       * @return The compilerVersion.
       */
      public com.google.protobuf.compiler.PluginProtos.Version getCompilerVersion() {
        if (compilerVersionBuilder_ == null) {
          return compilerVersion_ == null ? com.google.protobuf.compiler.PluginProtos.Version.getDefaultInstance() : compilerVersion_;
        } else {
          return compilerVersionBuilder_.getMessage();
        }
      }
      The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
/**
       * <pre>
       * The version number of protocol compiler.
       * </pre>
       *
       * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
       */
      public Builder setCompilerVersion(com.google.protobuf.compiler.PluginProtos.Version value) {
        if (compilerVersionBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          compilerVersion_ = value;
          onChanged();
        } else {
          compilerVersionBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000008;
        return this;
      }
      The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
/**
       * <pre>
       * The version number of protocol compiler.
       * </pre>
       *
       * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
       */
      public Builder setCompilerVersion(
          com.google.protobuf.compiler.PluginProtos.Version.Builder builderForValue) {
        if (compilerVersionBuilder_ == null) {
          compilerVersion_ = builderForValue.build();
          onChanged();
        } else {
          compilerVersionBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000008;
        return this;
      }
      The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
/**
       * <pre>
       * The version number of protocol compiler.
       * </pre>
       *
       * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
       */
      public Builder mergeCompilerVersion(com.google.protobuf.compiler.PluginProtos.Version value) {
        if (compilerVersionBuilder_ == null) {
          if (((bitField0_ & 0x00000008) != 0) &&
              compilerVersion_ != null &&
              compilerVersion_ != com.google.protobuf.compiler.PluginProtos.Version.getDefaultInstance()) {
            compilerVersion_ =
              com.google.protobuf.compiler.PluginProtos.Version.newBuilder(compilerVersion_).mergeFrom(value).buildPartial();
          } else {
            compilerVersion_ = value;
          }
          onChanged();
        } else {
          compilerVersionBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000008;
        return this;
      }
      The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
/**
       * <pre>
       * The version number of protocol compiler.
       * </pre>
       *
       * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
       */
      public Builder clearCompilerVersion() {
        if (compilerVersionBuilder_ == null) {
          compilerVersion_ = null;
          onChanged();
        } else {
          compilerVersionBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000008);
        return this;
      }
      The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
/**
       * <pre>
       * The version number of protocol compiler.
       * </pre>
       *
       * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
       */
      public com.google.protobuf.compiler.PluginProtos.Version.Builder getCompilerVersionBuilder() {
        bitField0_ |= 0x00000008;
        onChanged();
        return getCompilerVersionFieldBuilder().getBuilder();
      }
      The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
/**
       * <pre>
       * The version number of protocol compiler.
       * </pre>
       *
       * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
       */
      public com.google.protobuf.compiler.PluginProtos.VersionOrBuilder getCompilerVersionOrBuilder() {
        if (compilerVersionBuilder_ != null) {
          return compilerVersionBuilder_.getMessageOrBuilder();
        } else {
          return compilerVersion_ == null ?
              com.google.protobuf.compiler.PluginProtos.Version.getDefaultInstance() : compilerVersion_;
        }
      }
      The version number of protocol compiler.

optional .google.protobuf.compiler.Version compiler_version = 3;
/**
       * <pre>
       * The version number of protocol compiler.
       * </pre>
       *
       * <code>optional .google.protobuf.compiler.Version compiler_version = 3;</code>
       */
      private com.google.protobuf.SingleFieldBuilderV3<
          com.google.protobuf.compiler.PluginProtos.Version, com.google.protobuf.compiler.PluginProtos.Version.Builder, com.google.protobuf.compiler.PluginProtos.VersionOrBuilder> 
          getCompilerVersionFieldBuilder() {
        if (compilerVersionBuilder_ == null) {
          compilerVersionBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
              com.google.protobuf.compiler.PluginProtos.Version, com.google.protobuf.compiler.PluginProtos.Version.Builder, com.google.protobuf.compiler.PluginProtos.VersionOrBuilder>(
                  getCompilerVersion(),
                  getParentForChildren(),
                  isClean());
          compilerVersion_ = null;
        }
        return compilerVersionBuilder_;
      }
      @java.lang.Override
      public final Builder setUnknownFields(
          final com.google.protobuf.UnknownFieldSet unknownFields) {
        return super.setUnknownFields(unknownFields);
      }

      @java.lang.Override
      public final Builder mergeUnknownFields(
          final com.google.protobuf.UnknownFieldSet unknownFields) {
        return super.mergeUnknownFields(unknownFields);
      }


      // @@protoc_insertion_point(builder_scope:google.protobuf.compiler.CodeGeneratorRequest)
    }

    // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorRequest)
    private static final com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest DEFAULT_INSTANCE;
    static {
      DEFAULT_INSTANCE = new com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest();
    }

    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest getDefaultInstance() {
      return DEFAULT_INSTANCE;
    }

    @java.lang.Deprecated public static final com.google.protobuf.Parser<CodeGeneratorRequest>
        PARSER = new com.google.protobuf.AbstractParser<CodeGeneratorRequest>() {
      @java.lang.Override
      public CodeGeneratorRequest parsePartialFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return new CodeGeneratorRequest(input, extensionRegistry);
      }
    };

    public static com.google.protobuf.Parser<CodeGeneratorRequest> parser() {
      return PARSER;
    }

    @java.lang.Override
    public com.google.protobuf.Parser<CodeGeneratorRequest> getParserForType() {
      return PARSER;
    }

    @java.lang.Override
    public com.google.protobuf.compiler.PluginProtos.CodeGeneratorRequest getDefaultInstanceForType() {
      return DEFAULT_INSTANCE;
    }

  }

  public interface CodeGeneratorResponseOrBuilder extends
      // @@protoc_insertion_point(interface_extends:google.protobuf.compiler.CodeGeneratorResponse)
      com.google.protobuf.MessageOrBuilder {

    Error message.  If non-empty, code generation failed.  The plugin process
should exit with status code zero even if it reports an error in this way.
This should be used to indicate errors in .proto files which prevent the
code generator from generating correct code.  Errors which indicate a
problem in protoc itself -- such as the input CodeGeneratorRequest being
unparseable -- should be reported by writing a message to stderr and
exiting with a non-zero status code.

optional string error = 1;
Returns: Whether the error field is set./**
     * <pre>
     * Error message.  If non-empty, code generation failed.  The plugin process
     * should exit with status code zero even if it reports an error in this way.
     * This should be used to indicate errors in .proto files which prevent the
     * code generator from generating correct code.  Errors which indicate a
     * problem in protoc itself -- such as the input CodeGeneratorRequest being
     * unparseable -- should be reported by writing a message to stderr and
     * exiting with a non-zero status code.
     * </pre>
     *
     * <code>optional string error = 1;</code>
     * @return Whether the error field is set.
     */
    boolean hasError();
    Error message.  If non-empty, code generation failed.  The plugin process
should exit with status code zero even if it reports an error in this way.
This should be used to indicate errors in .proto files which prevent the
code generator from generating correct code.  Errors which indicate a
problem in protoc itself -- such as the input CodeGeneratorRequest being
unparseable -- should be reported by writing a message to stderr and
exiting with a non-zero status code.

optional string error = 1;
Returns: The error./**
     * <pre>
     * Error message.  If non-empty, code generation failed.  The plugin process
     * should exit with status code zero even if it reports an error in this way.
     * This should be used to indicate errors in .proto files which prevent the
     * code generator from generating correct code.  Errors which indicate a
     * problem in protoc itself -- such as the input CodeGeneratorRequest being
     * unparseable -- should be reported by writing a message to stderr and
     * exiting with a non-zero status code.
     * </pre>
     *
     * <code>optional string error = 1;</code>
     * @return The error.
     */
    java.lang.String getError();
    Error message.  If non-empty, code generation failed.  The plugin process
should exit with status code zero even if it reports an error in this way.
This should be used to indicate errors in .proto files which prevent the
code generator from generating correct code.  Errors which indicate a
problem in protoc itself -- such as the input CodeGeneratorRequest being
unparseable -- should be reported by writing a message to stderr and
exiting with a non-zero status code.

optional string error = 1;
Returns: The bytes for error./**
     * <pre>
     * Error message.  If non-empty, code generation failed.  The plugin process
     * should exit with status code zero even if it reports an error in this way.
     * This should be used to indicate errors in .proto files which prevent the
     * code generator from generating correct code.  Errors which indicate a
     * problem in protoc itself -- such as the input CodeGeneratorRequest being
     * unparseable -- should be reported by writing a message to stderr and
     * exiting with a non-zero status code.
     * </pre>
     *
     * <code>optional string error = 1;</code>
     * @return The bytes for error.
     */
    com.google.protobuf.ByteString
        getErrorBytes();

    repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
     * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
     */
    java.util.List<com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File> 
        getFileList();
    repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
     * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
     */
    com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File getFile(int index);
    repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
     * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
     */
    int getFileCount();
    repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
     * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
     */
    java.util.List<? extends com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.FileOrBuilder> 
        getFileOrBuilderList();
    repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
     * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
     */
    com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.FileOrBuilder getFileOrBuilder(
        int index);
  }
  The plugin writes an encoded CodeGeneratorResponse to stdout.
 Protobuf type google.protobuf.compiler.CodeGeneratorResponse /**
   * <pre>
   * The plugin writes an encoded CodeGeneratorResponse to stdout.
   * </pre>
   *
   * Protobuf type {@code google.protobuf.compiler.CodeGeneratorResponse}
   */
  public  static final class CodeGeneratorResponse extends
      com.google.protobuf.GeneratedMessageV3 implements
      // @@protoc_insertion_point(message_implements:google.protobuf.compiler.CodeGeneratorResponse)
      CodeGeneratorResponseOrBuilder {
  private static final long serialVersionUID = 0L;
    // Use CodeGeneratorResponse.newBuilder() to construct.
    private CodeGeneratorResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
      super(builder);
    }
    private CodeGeneratorResponse() {
      error_ = "";
      file_ = java.util.Collections.emptyList();
    }

    @java.lang.Override
    @SuppressWarnings({"unused"})
    protected java.lang.Object newInstance(
        UnusedPrivateParameter unused) {
      return new CodeGeneratorResponse();
    }

    @java.lang.Override
    public final com.google.protobuf.UnknownFieldSet
    getUnknownFields() {
      return this.unknownFields;
    }
    private CodeGeneratorResponse(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      this();
      if (extensionRegistry == null) {
        throw new java.lang.NullPointerException();
      }
      int mutable_bitField0_ = 0;
      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder();
      try {
        boolean done = false;
        while (!done) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              done = true;
              break;
            case 10: {
              com.google.protobuf.ByteString bs = input.readBytes();
              bitField0_ |= 0x00000001;
              error_ = bs;
              break;
            }
            case 122: {
              if (!((mutable_bitField0_ & 0x00000002) != 0)) {
                file_ = new java.util.ArrayList<com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File>();
                mutable_bitField0_ |= 0x00000002;
              }
              file_.add(
                  input.readMessage(com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.PARSER, extensionRegistry));
              break;
            }
            default: {
              if (!parseUnknownField(
                  input, unknownFields, extensionRegistry, tag)) {
                done = true;
              }
              break;
            }
          }
        }
      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
        throw e.setUnfinishedMessage(this);
      } catch (java.io.IOException e) {
        throw new com.google.protobuf.InvalidProtocolBufferException(
            e).setUnfinishedMessage(this);
      } finally {
        if (((mutable_bitField0_ & 0x00000002) != 0)) {
          file_ = java.util.Collections.unmodifiableList(file_);
        }
        this.unknownFields = unknownFields.build();
        makeExtensionsImmutable();
      }
    }
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_descriptor;
    }

    @java.lang.Override
    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_fieldAccessorTable
          .ensureFieldAccessorsInitialized(
              com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.class, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.Builder.class);
    }

    public interface FileOrBuilder extends
        // @@protoc_insertion_point(interface_extends:google.protobuf.compiler.CodeGeneratorResponse.File)
        com.google.protobuf.MessageOrBuilder {

      The file name, relative to the output directory.  The name must not
contain "." or ".." components and must be relative, not be absolute (so,
the file cannot lie outside the output directory).  "/" must be used as
the path separator, not "\".
If the name is omitted, the content will be appended to the previous
file.  This allows the generator to break large files into small chunks,
and allows the generated text to be streamed back to protoc so that large
files need not reside completely in memory at one time.  Note that as of
this writing protoc does not optimize for this -- it will read the entire
CodeGeneratorResponse before writing files to disk.

optional string name = 1;
Returns: Whether the name field is set./**
       * <pre>
       * The file name, relative to the output directory.  The name must not
       * contain "." or ".." components and must be relative, not be absolute (so,
       * the file cannot lie outside the output directory).  "/" must be used as
       * the path separator, not "&#92;".
       * If the name is omitted, the content will be appended to the previous
       * file.  This allows the generator to break large files into small chunks,
       * and allows the generated text to be streamed back to protoc so that large
       * files need not reside completely in memory at one time.  Note that as of
       * this writing protoc does not optimize for this -- it will read the entire
       * CodeGeneratorResponse before writing files to disk.
       * </pre>
       *
       * <code>optional string name = 1;</code>
       * @return Whether the name field is set.
       */
      boolean hasName();
      The file name, relative to the output directory.  The name must not
contain "." or ".." components and must be relative, not be absolute (so,
the file cannot lie outside the output directory).  "/" must be used as
the path separator, not "\".
If the name is omitted, the content will be appended to the previous
file.  This allows the generator to break large files into small chunks,
and allows the generated text to be streamed back to protoc so that large
files need not reside completely in memory at one time.  Note that as of
this writing protoc does not optimize for this -- it will read the entire
CodeGeneratorResponse before writing files to disk.

optional string name = 1;
Returns: The name./**
       * <pre>
       * The file name, relative to the output directory.  The name must not
       * contain "." or ".." components and must be relative, not be absolute (so,
       * the file cannot lie outside the output directory).  "/" must be used as
       * the path separator, not "&#92;".
       * If the name is omitted, the content will be appended to the previous
       * file.  This allows the generator to break large files into small chunks,
       * and allows the generated text to be streamed back to protoc so that large
       * files need not reside completely in memory at one time.  Note that as of
       * this writing protoc does not optimize for this -- it will read the entire
       * CodeGeneratorResponse before writing files to disk.
       * </pre>
       *
       * <code>optional string name = 1;</code>
       * @return The name.
       */
      java.lang.String getName();
      The file name, relative to the output directory.  The name must not
contain "." or ".." components and must be relative, not be absolute (so,
the file cannot lie outside the output directory).  "/" must be used as
the path separator, not "\".
If the name is omitted, the content will be appended to the previous
file.  This allows the generator to break large files into small chunks,
and allows the generated text to be streamed back to protoc so that large
files need not reside completely in memory at one time.  Note that as of
this writing protoc does not optimize for this -- it will read the entire
CodeGeneratorResponse before writing files to disk.

optional string name = 1;
Returns: The bytes for name./**
       * <pre>
       * The file name, relative to the output directory.  The name must not
       * contain "." or ".." components and must be relative, not be absolute (so,
       * the file cannot lie outside the output directory).  "/" must be used as
       * the path separator, not "&#92;".
       * If the name is omitted, the content will be appended to the previous
       * file.  This allows the generator to break large files into small chunks,
       * and allows the generated text to be streamed back to protoc so that large
       * files need not reside completely in memory at one time.  Note that as of
       * this writing protoc does not optimize for this -- it will read the entire
       * CodeGeneratorResponse before writing files to disk.
       * </pre>
       *
       * <code>optional string name = 1;</code>
       * @return The bytes for name.
       */
      com.google.protobuf.ByteString
          getNameBytes();

      If non-empty, indicates that the named file should already exist, and the
content here is to be inserted into that file at a defined insertion
point.  This feature allows a code generator to extend the output
produced by another code generator.  The original generator may provide
insertion points by placing special annotations in the file that look
like:
  @@protoc_insertion_point(NAME)
The annotation can have arbitrary text before and after it on the line,
which allows it to be placed in a comment.  NAME should be replaced with
an identifier naming the point -- this is what other generators will use
as the insertion_point.  Code inserted at this point will be placed
immediately above the line containing the insertion point (thus multiple
insertions to the same point will come out in the order they were added).
The double-@ is intended to make it unlikely that the generated code
could contain things that look like insertion points by accident.
For example, the C++ code generator places the following line in the
.pb.h files that it generates:
  // @@protoc_insertion_point(namespace_scope)
This line appears within the scope of the file's package namespace, but
outside of any particular class.  Another plugin can then specify the
insertion_point "namespace_scope" to generate additional classes or
other declarations that should be placed in this scope.
Note that if the line containing the insertion point begins with
whitespace, the same whitespace will be added to every line of the
inserted text.  This is useful for languages like Python, where
indentation matters.  In these languages, the insertion point comment
should be indented the same amount as any inserted code will need to be
in order to work correctly in that context.
The code generator that generates the initial file and the one which
inserts into it must both run as part of a single invocation of protoc.
Code generators are executed in the order in which they appear on the
command line.
If |insertion_point| is present, |name| must also be present.

optional string insertion_point = 2;
Returns: Whether the insertionPoint field is set./**
       * <pre>
       * If non-empty, indicates that the named file should already exist, and the
       * content here is to be inserted into that file at a defined insertion
       * point.  This feature allows a code generator to extend the output
       * produced by another code generator.  The original generator may provide
       * insertion points by placing special annotations in the file that look
       * like:
       *   &#64;&#64;protoc_insertion_point(NAME)
       * The annotation can have arbitrary text before and after it on the line,
       * which allows it to be placed in a comment.  NAME should be replaced with
       * an identifier naming the point -- this is what other generators will use
       * as the insertion_point.  Code inserted at this point will be placed
       * immediately above the line containing the insertion point (thus multiple
       * insertions to the same point will come out in the order they were added).
       * The double-&#64; is intended to make it unlikely that the generated code
       * could contain things that look like insertion points by accident.
       * For example, the C++ code generator places the following line in the
       * .pb.h files that it generates:
       *   // &#64;&#64;protoc_insertion_point(namespace_scope)
       * This line appears within the scope of the file's package namespace, but
       * outside of any particular class.  Another plugin can then specify the
       * insertion_point "namespace_scope" to generate additional classes or
       * other declarations that should be placed in this scope.
       * Note that if the line containing the insertion point begins with
       * whitespace, the same whitespace will be added to every line of the
       * inserted text.  This is useful for languages like Python, where
       * indentation matters.  In these languages, the insertion point comment
       * should be indented the same amount as any inserted code will need to be
       * in order to work correctly in that context.
       * The code generator that generates the initial file and the one which
       * inserts into it must both run as part of a single invocation of protoc.
       * Code generators are executed in the order in which they appear on the
       * command line.
       * If |insertion_point| is present, |name| must also be present.
       * </pre>
       *
       * <code>optional string insertion_point = 2;</code>
       * @return Whether the insertionPoint field is set.
       */
      boolean hasInsertionPoint();
      If non-empty, indicates that the named file should already exist, and the
content here is to be inserted into that file at a defined insertion
point.  This feature allows a code generator to extend the output
produced by another code generator.  The original generator may provide
insertion points by placing special annotations in the file that look
like:
  @@protoc_insertion_point(NAME)
The annotation can have arbitrary text before and after it on the line,
which allows it to be placed in a comment.  NAME should be replaced with
an identifier naming the point -- this is what other generators will use
as the insertion_point.  Code inserted at this point will be placed
immediately above the line containing the insertion point (thus multiple
insertions to the same point will come out in the order they were added).
The double-@ is intended to make it unlikely that the generated code
could contain things that look like insertion points by accident.
For example, the C++ code generator places the following line in the
.pb.h files that it generates:
  // @@protoc_insertion_point(namespace_scope)
This line appears within the scope of the file's package namespace, but
outside of any particular class.  Another plugin can then specify the
insertion_point "namespace_scope" to generate additional classes or
other declarations that should be placed in this scope.
Note that if the line containing the insertion point begins with
whitespace, the same whitespace will be added to every line of the
inserted text.  This is useful for languages like Python, where
indentation matters.  In these languages, the insertion point comment
should be indented the same amount as any inserted code will need to be
in order to work correctly in that context.
The code generator that generates the initial file and the one which
inserts into it must both run as part of a single invocation of protoc.
Code generators are executed in the order in which they appear on the
command line.
If |insertion_point| is present, |name| must also be present.

optional string insertion_point = 2;
Returns: The insertionPoint./**
       * <pre>
       * If non-empty, indicates that the named file should already exist, and the
       * content here is to be inserted into that file at a defined insertion
       * point.  This feature allows a code generator to extend the output
       * produced by another code generator.  The original generator may provide
       * insertion points by placing special annotations in the file that look
       * like:
       *   &#64;&#64;protoc_insertion_point(NAME)
       * The annotation can have arbitrary text before and after it on the line,
       * which allows it to be placed in a comment.  NAME should be replaced with
       * an identifier naming the point -- this is what other generators will use
       * as the insertion_point.  Code inserted at this point will be placed
       * immediately above the line containing the insertion point (thus multiple
       * insertions to the same point will come out in the order they were added).
       * The double-&#64; is intended to make it unlikely that the generated code
       * could contain things that look like insertion points by accident.
       * For example, the C++ code generator places the following line in the
       * .pb.h files that it generates:
       *   // &#64;&#64;protoc_insertion_point(namespace_scope)
       * This line appears within the scope of the file's package namespace, but
       * outside of any particular class.  Another plugin can then specify the
       * insertion_point "namespace_scope" to generate additional classes or
       * other declarations that should be placed in this scope.
       * Note that if the line containing the insertion point begins with
       * whitespace, the same whitespace will be added to every line of the
       * inserted text.  This is useful for languages like Python, where
       * indentation matters.  In these languages, the insertion point comment
       * should be indented the same amount as any inserted code will need to be
       * in order to work correctly in that context.
       * The code generator that generates the initial file and the one which
       * inserts into it must both run as part of a single invocation of protoc.
       * Code generators are executed in the order in which they appear on the
       * command line.
       * If |insertion_point| is present, |name| must also be present.
       * </pre>
       *
       * <code>optional string insertion_point = 2;</code>
       * @return The insertionPoint.
       */
      java.lang.String getInsertionPoint();
      If non-empty, indicates that the named file should already exist, and the
content here is to be inserted into that file at a defined insertion
point.  This feature allows a code generator to extend the output
produced by another code generator.  The original generator may provide
insertion points by placing special annotations in the file that look
like:
  @@protoc_insertion_point(NAME)
The annotation can have arbitrary text before and after it on the line,
which allows it to be placed in a comment.  NAME should be replaced with
an identifier naming the point -- this is what other generators will use
as the insertion_point.  Code inserted at this point will be placed
immediately above the line containing the insertion point (thus multiple
insertions to the same point will come out in the order they were added).
The double-@ is intended to make it unlikely that the generated code
could contain things that look like insertion points by accident.
For example, the C++ code generator places the following line in the
.pb.h files that it generates:
  // @@protoc_insertion_point(namespace_scope)
This line appears within the scope of the file's package namespace, but
outside of any particular class.  Another plugin can then specify the
insertion_point "namespace_scope" to generate additional classes or
other declarations that should be placed in this scope.
Note that if the line containing the insertion point begins with
whitespace, the same whitespace will be added to every line of the
inserted text.  This is useful for languages like Python, where
indentation matters.  In these languages, the insertion point comment
should be indented the same amount as any inserted code will need to be
in order to work correctly in that context.
The code generator that generates the initial file and the one which
inserts into it must both run as part of a single invocation of protoc.
Code generators are executed in the order in which they appear on the
command line.
If |insertion_point| is present, |name| must also be present.

optional string insertion_point = 2;
Returns: The bytes for insertionPoint./**
       * <pre>
       * If non-empty, indicates that the named file should already exist, and the
       * content here is to be inserted into that file at a defined insertion
       * point.  This feature allows a code generator to extend the output
       * produced by another code generator.  The original generator may provide
       * insertion points by placing special annotations in the file that look
       * like:
       *   &#64;&#64;protoc_insertion_point(NAME)
       * The annotation can have arbitrary text before and after it on the line,
       * which allows it to be placed in a comment.  NAME should be replaced with
       * an identifier naming the point -- this is what other generators will use
       * as the insertion_point.  Code inserted at this point will be placed
       * immediately above the line containing the insertion point (thus multiple
       * insertions to the same point will come out in the order they were added).
       * The double-&#64; is intended to make it unlikely that the generated code
       * could contain things that look like insertion points by accident.
       * For example, the C++ code generator places the following line in the
       * .pb.h files that it generates:
       *   // &#64;&#64;protoc_insertion_point(namespace_scope)
       * This line appears within the scope of the file's package namespace, but
       * outside of any particular class.  Another plugin can then specify the
       * insertion_point "namespace_scope" to generate additional classes or
       * other declarations that should be placed in this scope.
       * Note that if the line containing the insertion point begins with
       * whitespace, the same whitespace will be added to every line of the
       * inserted text.  This is useful for languages like Python, where
       * indentation matters.  In these languages, the insertion point comment
       * should be indented the same amount as any inserted code will need to be
       * in order to work correctly in that context.
       * The code generator that generates the initial file and the one which
       * inserts into it must both run as part of a single invocation of protoc.
       * Code generators are executed in the order in which they appear on the
       * command line.
       * If |insertion_point| is present, |name| must also be present.
       * </pre>
       *
       * <code>optional string insertion_point = 2;</code>
       * @return The bytes for insertionPoint.
       */
      com.google.protobuf.ByteString
          getInsertionPointBytes();

      The file contents.

optional string content = 15;
Returns: Whether the content field is set./**
       * <pre>
       * The file contents.
       * </pre>
       *
       * <code>optional string content = 15;</code>
       * @return Whether the content field is set.
       */
      boolean hasContent();
      The file contents.

optional string content = 15;
Returns: The content./**
       * <pre>
       * The file contents.
       * </pre>
       *
       * <code>optional string content = 15;</code>
       * @return The content.
       */
      java.lang.String getContent();
      The file contents.

optional string content = 15;
Returns: The bytes for content./**
       * <pre>
       * The file contents.
       * </pre>
       *
       * <code>optional string content = 15;</code>
       * @return The bytes for content.
       */
      com.google.protobuf.ByteString
          getContentBytes();
    }
    Represents a single generated file.
 Protobuf type google.protobuf.compiler.CodeGeneratorResponse.File /**
     * <pre>
     * Represents a single generated file.
     * </pre>
     *
     * Protobuf type {@code google.protobuf.compiler.CodeGeneratorResponse.File}
     */
    public  static final class File extends
        com.google.protobuf.GeneratedMessageV3 implements
        // @@protoc_insertion_point(message_implements:google.protobuf.compiler.CodeGeneratorResponse.File)
        FileOrBuilder {
    private static final long serialVersionUID = 0L;
      // Use File.newBuilder() to construct.
      private File(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
        super(builder);
      }
      private File() {
        name_ = "";
        insertionPoint_ = "";
        content_ = "";
      }

      @java.lang.Override
      @SuppressWarnings({"unused"})
      protected java.lang.Object newInstance(
          UnusedPrivateParameter unused) {
        return new File();
      }

      @java.lang.Override
      public final com.google.protobuf.UnknownFieldSet
      getUnknownFields() {
        return this.unknownFields;
      }
      private File(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        this();
        if (extensionRegistry == null) {
          throw new java.lang.NullPointerException();
        }
        int mutable_bitField0_ = 0;
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
            com.google.protobuf.UnknownFieldSet.newBuilder();
        try {
          boolean done = false;
          while (!done) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                done = true;
                break;
              case 10: {
                com.google.protobuf.ByteString bs = input.readBytes();
                bitField0_ |= 0x00000001;
                name_ = bs;
                break;
              }
              case 18: {
                com.google.protobuf.ByteString bs = input.readBytes();
                bitField0_ |= 0x00000002;
                insertionPoint_ = bs;
                break;
              }
              case 122: {
                com.google.protobuf.ByteString bs = input.readBytes();
                bitField0_ |= 0x00000004;
                content_ = bs;
                break;
              }
              default: {
                if (!parseUnknownField(
                    input, unknownFields, extensionRegistry, tag)) {
                  done = true;
                }
                break;
              }
            }
          }
        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
          throw e.setUnfinishedMessage(this);
        } catch (java.io.IOException e) {
          throw new com.google.protobuf.InvalidProtocolBufferException(
              e).setUnfinishedMessage(this);
        } finally {
          this.unknownFields = unknownFields.build();
          makeExtensionsImmutable();
        }
      }
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_descriptor;
      }

      @java.lang.Override
      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_fieldAccessorTable
            .ensureFieldAccessorsInitialized(
                com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.class, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder.class);
      }

      private int bitField0_;
      public static final int NAME_FIELD_NUMBER = 1;
      private volatile java.lang.Object name_;
      The file name, relative to the output directory.  The name must not
contain "." or ".." components and must be relative, not be absolute (so,
the file cannot lie outside the output directory).  "/" must be used as
the path separator, not "\".
If the name is omitted, the content will be appended to the previous
file.  This allows the generator to break large files into small chunks,
and allows the generated text to be streamed back to protoc so that large
files need not reside completely in memory at one time.  Note that as of
this writing protoc does not optimize for this -- it will read the entire
CodeGeneratorResponse before writing files to disk.

optional string name = 1;
Returns: Whether the name field is set./**
       * <pre>
       * The file name, relative to the output directory.  The name must not
       * contain "." or ".." components and must be relative, not be absolute (so,
       * the file cannot lie outside the output directory).  "/" must be used as
       * the path separator, not "&#92;".
       * If the name is omitted, the content will be appended to the previous
       * file.  This allows the generator to break large files into small chunks,
       * and allows the generated text to be streamed back to protoc so that large
       * files need not reside completely in memory at one time.  Note that as of
       * this writing protoc does not optimize for this -- it will read the entire
       * CodeGeneratorResponse before writing files to disk.
       * </pre>
       *
       * <code>optional string name = 1;</code>
       * @return Whether the name field is set.
       */
      public boolean hasName() {
        return ((bitField0_ & 0x00000001) != 0);
      }
      The file name, relative to the output directory.  The name must not
contain "." or ".." components and must be relative, not be absolute (so,
the file cannot lie outside the output directory).  "/" must be used as
the path separator, not "\".
If the name is omitted, the content will be appended to the previous
file.  This allows the generator to break large files into small chunks,
and allows the generated text to be streamed back to protoc so that large
files need not reside completely in memory at one time.  Note that as of
this writing protoc does not optimize for this -- it will read the entire
CodeGeneratorResponse before writing files to disk.

optional string name = 1;
Returns: The name./**
       * <pre>
       * The file name, relative to the output directory.  The name must not
       * contain "." or ".." components and must be relative, not be absolute (so,
       * the file cannot lie outside the output directory).  "/" must be used as
       * the path separator, not "&#92;".
       * If the name is omitted, the content will be appended to the previous
       * file.  This allows the generator to break large files into small chunks,
       * and allows the generated text to be streamed back to protoc so that large
       * files need not reside completely in memory at one time.  Note that as of
       * this writing protoc does not optimize for this -- it will read the entire
       * CodeGeneratorResponse before writing files to disk.
       * </pre>
       *
       * <code>optional string name = 1;</code>
       * @return The name.
       */
      public java.lang.String getName() {
        java.lang.Object ref = name_;
        if (ref instanceof java.lang.String) {
          return (java.lang.String) ref;
        } else {
          com.google.protobuf.ByteString bs = 
              (com.google.protobuf.ByteString) ref;
          java.lang.String s = bs.toStringUtf8();
          if (bs.isValidUtf8()) {
            name_ = s;
          }
          return s;
        }
      }
      The file name, relative to the output directory.  The name must not
contain "." or ".." components and must be relative, not be absolute (so,
the file cannot lie outside the output directory).  "/" must be used as
the path separator, not "\".
If the name is omitted, the content will be appended to the previous
file.  This allows the generator to break large files into small chunks,
and allows the generated text to be streamed back to protoc so that large
files need not reside completely in memory at one time.  Note that as of
this writing protoc does not optimize for this -- it will read the entire
CodeGeneratorResponse before writing files to disk.

optional string name = 1;
Returns: The bytes for name./**
       * <pre>
       * The file name, relative to the output directory.  The name must not
       * contain "." or ".." components and must be relative, not be absolute (so,
       * the file cannot lie outside the output directory).  "/" must be used as
       * the path separator, not "&#92;".
       * If the name is omitted, the content will be appended to the previous
       * file.  This allows the generator to break large files into small chunks,
       * and allows the generated text to be streamed back to protoc so that large
       * files need not reside completely in memory at one time.  Note that as of
       * this writing protoc does not optimize for this -- it will read the entire
       * CodeGeneratorResponse before writing files to disk.
       * </pre>
       *
       * <code>optional string name = 1;</code>
       * @return The bytes for name.
       */
      public com.google.protobuf.ByteString
          getNameBytes() {
        java.lang.Object ref = name_;
        if (ref instanceof java.lang.String) {
          com.google.protobuf.ByteString b = 
              com.google.protobuf.ByteString.copyFromUtf8(
                  (java.lang.String) ref);
          name_ = b;
          return b;
        } else {
          return (com.google.protobuf.ByteString) ref;
        }
      }

      public static final int INSERTION_POINT_FIELD_NUMBER = 2;
      private volatile java.lang.Object insertionPoint_;
      If non-empty, indicates that the named file should already exist, and the
content here is to be inserted into that file at a defined insertion
point.  This feature allows a code generator to extend the output
produced by another code generator.  The original generator may provide
insertion points by placing special annotations in the file that look
like:
  @@protoc_insertion_point(NAME)
The annotation can have arbitrary text before and after it on the line,
which allows it to be placed in a comment.  NAME should be replaced with
an identifier naming the point -- this is what other generators will use
as the insertion_point.  Code inserted at this point will be placed
immediately above the line containing the insertion point (thus multiple
insertions to the same point will come out in the order they were added).
The double-@ is intended to make it unlikely that the generated code
could contain things that look like insertion points by accident.
For example, the C++ code generator places the following line in the
.pb.h files that it generates:
  // @@protoc_insertion_point(namespace_scope)
This line appears within the scope of the file's package namespace, but
outside of any particular class.  Another plugin can then specify the
insertion_point "namespace_scope" to generate additional classes or
other declarations that should be placed in this scope.
Note that if the line containing the insertion point begins with
whitespace, the same whitespace will be added to every line of the
inserted text.  This is useful for languages like Python, where
indentation matters.  In these languages, the insertion point comment
should be indented the same amount as any inserted code will need to be
in order to work correctly in that context.
The code generator that generates the initial file and the one which
inserts into it must both run as part of a single invocation of protoc.
Code generators are executed in the order in which they appear on the
command line.
If |insertion_point| is present, |name| must also be present.

optional string insertion_point = 2;
Returns: Whether the insertionPoint field is set./**
       * <pre>
       * If non-empty, indicates that the named file should already exist, and the
       * content here is to be inserted into that file at a defined insertion
       * point.  This feature allows a code generator to extend the output
       * produced by another code generator.  The original generator may provide
       * insertion points by placing special annotations in the file that look
       * like:
       *   &#64;&#64;protoc_insertion_point(NAME)
       * The annotation can have arbitrary text before and after it on the line,
       * which allows it to be placed in a comment.  NAME should be replaced with
       * an identifier naming the point -- this is what other generators will use
       * as the insertion_point.  Code inserted at this point will be placed
       * immediately above the line containing the insertion point (thus multiple
       * insertions to the same point will come out in the order they were added).
       * The double-&#64; is intended to make it unlikely that the generated code
       * could contain things that look like insertion points by accident.
       * For example, the C++ code generator places the following line in the
       * .pb.h files that it generates:
       *   // &#64;&#64;protoc_insertion_point(namespace_scope)
       * This line appears within the scope of the file's package namespace, but
       * outside of any particular class.  Another plugin can then specify the
       * insertion_point "namespace_scope" to generate additional classes or
       * other declarations that should be placed in this scope.
       * Note that if the line containing the insertion point begins with
       * whitespace, the same whitespace will be added to every line of the
       * inserted text.  This is useful for languages like Python, where
       * indentation matters.  In these languages, the insertion point comment
       * should be indented the same amount as any inserted code will need to be
       * in order to work correctly in that context.
       * The code generator that generates the initial file and the one which
       * inserts into it must both run as part of a single invocation of protoc.
       * Code generators are executed in the order in which they appear on the
       * command line.
       * If |insertion_point| is present, |name| must also be present.
       * </pre>
       *
       * <code>optional string insertion_point = 2;</code>
       * @return Whether the insertionPoint field is set.
       */
      public boolean hasInsertionPoint() {
        return ((bitField0_ & 0x00000002) != 0);
      }
      If non-empty, indicates that the named file should already exist, and the
content here is to be inserted into that file at a defined insertion
point.  This feature allows a code generator to extend the output
produced by another code generator.  The original generator may provide
insertion points by placing special annotations in the file that look
like:
  @@protoc_insertion_point(NAME)
The annotation can have arbitrary text before and after it on the line,
which allows it to be placed in a comment.  NAME should be replaced with
an identifier naming the point -- this is what other generators will use
as the insertion_point.  Code inserted at this point will be placed
immediately above the line containing the insertion point (thus multiple
insertions to the same point will come out in the order they were added).
The double-@ is intended to make it unlikely that the generated code
could contain things that look like insertion points by accident.
For example, the C++ code generator places the following line in the
.pb.h files that it generates:
  // @@protoc_insertion_point(namespace_scope)
This line appears within the scope of the file's package namespace, but
outside of any particular class.  Another plugin can then specify the
insertion_point "namespace_scope" to generate additional classes or
other declarations that should be placed in this scope.
Note that if the line containing the insertion point begins with
whitespace, the same whitespace will be added to every line of the
inserted text.  This is useful for languages like Python, where
indentation matters.  In these languages, the insertion point comment
should be indented the same amount as any inserted code will need to be
in order to work correctly in that context.
The code generator that generates the initial file and the one which
inserts into it must both run as part of a single invocation of protoc.
Code generators are executed in the order in which they appear on the
command line.
If |insertion_point| is present, |name| must also be present.

optional string insertion_point = 2;
Returns: The insertionPoint./**
       * <pre>
       * If non-empty, indicates that the named file should already exist, and the
       * content here is to be inserted into that file at a defined insertion
       * point.  This feature allows a code generator to extend the output
       * produced by another code generator.  The original generator may provide
       * insertion points by placing special annotations in the file that look
       * like:
       *   &#64;&#64;protoc_insertion_point(NAME)
       * The annotation can have arbitrary text before and after it on the line,
       * which allows it to be placed in a comment.  NAME should be replaced with
       * an identifier naming the point -- this is what other generators will use
       * as the insertion_point.  Code inserted at this point will be placed
       * immediately above the line containing the insertion point (thus multiple
       * insertions to the same point will come out in the order they were added).
       * The double-&#64; is intended to make it unlikely that the generated code
       * could contain things that look like insertion points by accident.
       * For example, the C++ code generator places the following line in the
       * .pb.h files that it generates:
       *   // &#64;&#64;protoc_insertion_point(namespace_scope)
       * This line appears within the scope of the file's package namespace, but
       * outside of any particular class.  Another plugin can then specify the
       * insertion_point "namespace_scope" to generate additional classes or
       * other declarations that should be placed in this scope.
       * Note that if the line containing the insertion point begins with
       * whitespace, the same whitespace will be added to every line of the
       * inserted text.  This is useful for languages like Python, where
       * indentation matters.  In these languages, the insertion point comment
       * should be indented the same amount as any inserted code will need to be
       * in order to work correctly in that context.
       * The code generator that generates the initial file and the one which
       * inserts into it must both run as part of a single invocation of protoc.
       * Code generators are executed in the order in which they appear on the
       * command line.
       * If |insertion_point| is present, |name| must also be present.
       * </pre>
       *
       * <code>optional string insertion_point = 2;</code>
       * @return The insertionPoint.
       */
      public java.lang.String getInsertionPoint() {
        java.lang.Object ref = insertionPoint_;
        if (ref instanceof java.lang.String) {
          return (java.lang.String) ref;
        } else {
          com.google.protobuf.ByteString bs = 
              (com.google.protobuf.ByteString) ref;
          java.lang.String s = bs.toStringUtf8();
          if (bs.isValidUtf8()) {
            insertionPoint_ = s;
          }
          return s;
        }
      }
      If non-empty, indicates that the named file should already exist, and the
content here is to be inserted into that file at a defined insertion
point.  This feature allows a code generator to extend the output
produced by another code generator.  The original generator may provide
insertion points by placing special annotations in the file that look
like:
  @@protoc_insertion_point(NAME)
The annotation can have arbitrary text before and after it on the line,
which allows it to be placed in a comment.  NAME should be replaced with
an identifier naming the point -- this is what other generators will use
as the insertion_point.  Code inserted at this point will be placed
immediately above the line containing the insertion point (thus multiple
insertions to the same point will come out in the order they were added).
The double-@ is intended to make it unlikely that the generated code
could contain things that look like insertion points by accident.
For example, the C++ code generator places the following line in the
.pb.h files that it generates:
  // @@protoc_insertion_point(namespace_scope)
This line appears within the scope of the file's package namespace, but
outside of any particular class.  Another plugin can then specify the
insertion_point "namespace_scope" to generate additional classes or
other declarations that should be placed in this scope.
Note that if the line containing the insertion point begins with
whitespace, the same whitespace will be added to every line of the
inserted text.  This is useful for languages like Python, where
indentation matters.  In these languages, the insertion point comment
should be indented the same amount as any inserted code will need to be
in order to work correctly in that context.
The code generator that generates the initial file and the one which
inserts into it must both run as part of a single invocation of protoc.
Code generators are executed in the order in which they appear on the
command line.
If |insertion_point| is present, |name| must also be present.

optional string insertion_point = 2;
Returns: The bytes for insertionPoint./**
       * <pre>
       * If non-empty, indicates that the named file should already exist, and the
       * content here is to be inserted into that file at a defined insertion
       * point.  This feature allows a code generator to extend the output
       * produced by another code generator.  The original generator may provide
       * insertion points by placing special annotations in the file that look
       * like:
       *   &#64;&#64;protoc_insertion_point(NAME)
       * The annotation can have arbitrary text before and after it on the line,
       * which allows it to be placed in a comment.  NAME should be replaced with
       * an identifier naming the point -- this is what other generators will use
       * as the insertion_point.  Code inserted at this point will be placed
       * immediately above the line containing the insertion point (thus multiple
       * insertions to the same point will come out in the order they were added).
       * The double-&#64; is intended to make it unlikely that the generated code
       * could contain things that look like insertion points by accident.
       * For example, the C++ code generator places the following line in the
       * .pb.h files that it generates:
       *   // &#64;&#64;protoc_insertion_point(namespace_scope)
       * This line appears within the scope of the file's package namespace, but
       * outside of any particular class.  Another plugin can then specify the
       * insertion_point "namespace_scope" to generate additional classes or
       * other declarations that should be placed in this scope.
       * Note that if the line containing the insertion point begins with
       * whitespace, the same whitespace will be added to every line of the
       * inserted text.  This is useful for languages like Python, where
       * indentation matters.  In these languages, the insertion point comment
       * should be indented the same amount as any inserted code will need to be
       * in order to work correctly in that context.
       * The code generator that generates the initial file and the one which
       * inserts into it must both run as part of a single invocation of protoc.
       * Code generators are executed in the order in which they appear on the
       * command line.
       * If |insertion_point| is present, |name| must also be present.
       * </pre>
       *
       * <code>optional string insertion_point = 2;</code>
       * @return The bytes for insertionPoint.
       */
      public com.google.protobuf.ByteString
          getInsertionPointBytes() {
        java.lang.Object ref = insertionPoint_;
        if (ref instanceof java.lang.String) {
          com.google.protobuf.ByteString b = 
              com.google.protobuf.ByteString.copyFromUtf8(
                  (java.lang.String) ref);
          insertionPoint_ = b;
          return b;
        } else {
          return (com.google.protobuf.ByteString) ref;
        }
      }

      public static final int CONTENT_FIELD_NUMBER = 15;
      private volatile java.lang.Object content_;
      The file contents.

optional string content = 15;
Returns: Whether the content field is set./**
       * <pre>
       * The file contents.
       * </pre>
       *
       * <code>optional string content = 15;</code>
       * @return Whether the content field is set.
       */
      public boolean hasContent() {
        return ((bitField0_ & 0x00000004) != 0);
      }
      The file contents.

optional string content = 15;
Returns: The content./**
       * <pre>
       * The file contents.
       * </pre>
       *
       * <code>optional string content = 15;</code>
       * @return The content.
       */
      public java.lang.String getContent() {
        java.lang.Object ref = content_;
        if (ref instanceof java.lang.String) {
          return (java.lang.String) ref;
        } else {
          com.google.protobuf.ByteString bs = 
              (com.google.protobuf.ByteString) ref;
          java.lang.String s = bs.toStringUtf8();
          if (bs.isValidUtf8()) {
            content_ = s;
          }
          return s;
        }
      }
      The file contents.

optional string content = 15;
Returns: The bytes for content./**
       * <pre>
       * The file contents.
       * </pre>
       *
       * <code>optional string content = 15;</code>
       * @return The bytes for content.
       */
      public com.google.protobuf.ByteString
          getContentBytes() {
        java.lang.Object ref = content_;
        if (ref instanceof java.lang.String) {
          com.google.protobuf.ByteString b = 
              com.google.protobuf.ByteString.copyFromUtf8(
                  (java.lang.String) ref);
          content_ = b;
          return b;
        } else {
          return (com.google.protobuf.ByteString) ref;
        }
      }

      private byte memoizedIsInitialized = -1;
      @java.lang.Override
      public final boolean isInitialized() {
        byte isInitialized = memoizedIsInitialized;
        if (isInitialized == 1) return true;
        if (isInitialized == 0) return false;

        memoizedIsInitialized = 1;
        return true;
      }

      @java.lang.Override
      public void writeTo(com.google.protobuf.CodedOutputStream output)
                          throws java.io.IOException {
        if (((bitField0_ & 0x00000001) != 0)) {
          com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_);
        }
        if (((bitField0_ & 0x00000002) != 0)) {
          com.google.protobuf.GeneratedMessageV3.writeString(output, 2, insertionPoint_);
        }
        if (((bitField0_ & 0x00000004) != 0)) {
          com.google.protobuf.GeneratedMessageV3.writeString(output, 15, content_);
        }
        unknownFields.writeTo(output);
      }

      @java.lang.Override
      public int getSerializedSize() {
        int size = memoizedSize;
        if (size != -1) return size;

        size = 0;
        if (((bitField0_ & 0x00000001) != 0)) {
          size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_);
        }
        if (((bitField0_ & 0x00000002) != 0)) {
          size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, insertionPoint_);
        }
        if (((bitField0_ & 0x00000004) != 0)) {
          size += com.google.protobuf.GeneratedMessageV3.computeStringSize(15, content_);
        }
        size += unknownFields.getSerializedSize();
        memoizedSize = size;
        return size;
      }

      @java.lang.Override
      public boolean equals(final java.lang.Object obj) {
        if (obj == this) {
         return true;
        }
        if (!(obj instanceof com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File)) {
          return super.equals(obj);
        }
        com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File other = (com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File) obj;

        if (hasName() != other.hasName()) return false;
        if (hasName()) {
          if (!getName()
              .equals(other.getName())) return false;
        }
        if (hasInsertionPoint() != other.hasInsertionPoint()) return false;
        if (hasInsertionPoint()) {
          if (!getInsertionPoint()
              .equals(other.getInsertionPoint())) return false;
        }
        if (hasContent() != other.hasContent()) return false;
        if (hasContent()) {
          if (!getContent()
              .equals(other.getContent())) return false;
        }
        if (!unknownFields.equals(other.unknownFields)) return false;
        return true;
      }

      @java.lang.Override
      public int hashCode() {
        if (memoizedHashCode != 0) {
          return memoizedHashCode;
        }
        int hash = 41;
        hash = (19 * hash) + getDescriptor().hashCode();
        if (hasName()) {
          hash = (37 * hash) + NAME_FIELD_NUMBER;
          hash = (53 * hash) + getName().hashCode();
        }
        if (hasInsertionPoint()) {
          hash = (37 * hash) + INSERTION_POINT_FIELD_NUMBER;
          hash = (53 * hash) + getInsertionPoint().hashCode();
        }
        if (hasContent()) {
          hash = (37 * hash) + CONTENT_FIELD_NUMBER;
          hash = (53 * hash) + getContent().hashCode();
        }
        hash = (29 * hash) + unknownFields.hashCode();
        memoizedHashCode = hash;
        return hash;
      }

      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
          java.nio.ByteBuffer data)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return PARSER.parseFrom(data);
      }
      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
          java.nio.ByteBuffer data,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return PARSER.parseFrom(data, extensionRegistry);
      }
      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
          com.google.protobuf.ByteString data)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return PARSER.parseFrom(data);
      }
      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
          com.google.protobuf.ByteString data,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return PARSER.parseFrom(data, extensionRegistry);
      }
      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(byte[] data)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return PARSER.parseFrom(data);
      }
      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
          byte[] data,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return PARSER.parseFrom(data, extensionRegistry);
      }
      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(java.io.InputStream input)
          throws java.io.IOException {
        return com.google.protobuf.GeneratedMessageV3
            .parseWithIOException(PARSER, input);
      }
      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
          java.io.InputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        return com.google.protobuf.GeneratedMessageV3
            .parseWithIOException(PARSER, input, extensionRegistry);
      }
      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseDelimitedFrom(java.io.InputStream input)
          throws java.io.IOException {
        return com.google.protobuf.GeneratedMessageV3
            .parseDelimitedWithIOException(PARSER, input);
      }
      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseDelimitedFrom(
          java.io.InputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        return com.google.protobuf.GeneratedMessageV3
            .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
      }
      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
          com.google.protobuf.CodedInputStream input)
          throws java.io.IOException {
        return com.google.protobuf.GeneratedMessageV3
            .parseWithIOException(PARSER, input);
      }
      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        return com.google.protobuf.GeneratedMessageV3
            .parseWithIOException(PARSER, input, extensionRegistry);
      }

      @java.lang.Override
      public Builder newBuilderForType() { return newBuilder(); }
      public static Builder newBuilder() {
        return DEFAULT_INSTANCE.toBuilder();
      }
      public static Builder newBuilder(com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File prototype) {
        return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
      }
      @java.lang.Override
      public Builder toBuilder() {
        return this == DEFAULT_INSTANCE
            ? new Builder() : new Builder().mergeFrom(this);
      }

      @java.lang.Override
      protected Builder newBuilderForType(
          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
        Builder builder = new Builder(parent);
        return builder;
      }
      Represents a single generated file.
 Protobuf type google.protobuf.compiler.CodeGeneratorResponse.File /**
       * <pre>
       * Represents a single generated file.
       * </pre>
       *
       * Protobuf type {@code google.protobuf.compiler.CodeGeneratorResponse.File}
       */
      public static final class Builder extends
          com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
          // @@protoc_insertion_point(builder_implements:google.protobuf.compiler.CodeGeneratorResponse.File)
          com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.FileOrBuilder {
        public static final com.google.protobuf.Descriptors.Descriptor
            getDescriptor() {
          return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_descriptor;
        }

        @java.lang.Override
        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
            internalGetFieldAccessorTable() {
          return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_fieldAccessorTable
              .ensureFieldAccessorsInitialized(
                  com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.class, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder.class);
        }

        // Construct using com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.newBuilder()
        private Builder() {
          maybeForceBuilderInitialization();
        }

        private Builder(
            com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
          super(parent);
          maybeForceBuilderInitialization();
        }
        private void maybeForceBuilderInitialization() {
          if (com.google.protobuf.GeneratedMessageV3
                  .alwaysUseFieldBuilders) {
          }
        }
        @java.lang.Override
        public Builder clear() {
          super.clear();
          name_ = "";
          bitField0_ = (bitField0_ & ~0x00000001);
          insertionPoint_ = "";
          bitField0_ = (bitField0_ & ~0x00000002);
          content_ = "";
          bitField0_ = (bitField0_ & ~0x00000004);
          return this;
        }

        @java.lang.Override
        public com.google.protobuf.Descriptors.Descriptor
            getDescriptorForType() {
          return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_descriptor;
        }

        @java.lang.Override
        public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File getDefaultInstanceForType() {
          return com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.getDefaultInstance();
        }

        @java.lang.Override
        public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File build() {
          com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File result = buildPartial();
          if (!result.isInitialized()) {
            throw newUninitializedMessageException(result);
          }
          return result;
        }

        @java.lang.Override
        public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File buildPartial() {
          com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File result = new com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File(this);
          int from_bitField0_ = bitField0_;
          int to_bitField0_ = 0;
          if (((from_bitField0_ & 0x00000001) != 0)) {
            to_bitField0_ |= 0x00000001;
          }
          result.name_ = name_;
          if (((from_bitField0_ & 0x00000002) != 0)) {
            to_bitField0_ |= 0x00000002;
          }
          result.insertionPoint_ = insertionPoint_;
          if (((from_bitField0_ & 0x00000004) != 0)) {
            to_bitField0_ |= 0x00000004;
          }
          result.content_ = content_;
          result.bitField0_ = to_bitField0_;
          onBuilt();
          return result;
        }

        @java.lang.Override
        public Builder clone() {
          return super.clone();
        }
        @java.lang.Override
        public Builder setField(
            com.google.protobuf.Descriptors.FieldDescriptor field,
            java.lang.Object value) {
          return super.setField(field, value);
        }
        @java.lang.Override
        public Builder clearField(
            com.google.protobuf.Descriptors.FieldDescriptor field) {
          return super.clearField(field);
        }
        @java.lang.Override
        public Builder clearOneof(
            com.google.protobuf.Descriptors.OneofDescriptor oneof) {
          return super.clearOneof(oneof);
        }
        @java.lang.Override
        public Builder setRepeatedField(
            com.google.protobuf.Descriptors.FieldDescriptor field,
            int index, java.lang.Object value) {
          return super.setRepeatedField(field, index, value);
        }
        @java.lang.Override
        public Builder addRepeatedField(
            com.google.protobuf.Descriptors.FieldDescriptor field,
            java.lang.Object value) {
          return super.addRepeatedField(field, value);
        }
        @java.lang.Override
        public Builder mergeFrom(com.google.protobuf.Message other) {
          if (other instanceof com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File) {
            return mergeFrom((com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }

        public Builder mergeFrom(com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File other) {
          if (other == com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.getDefaultInstance()) return this;
          if (other.hasName()) {
            bitField0_ |= 0x00000001;
            name_ = other.name_;
            onChanged();
          }
          if (other.hasInsertionPoint()) {
            bitField0_ |= 0x00000002;
            insertionPoint_ = other.insertionPoint_;
            onChanged();
          }
          if (other.hasContent()) {
            bitField0_ |= 0x00000004;
            content_ = other.content_;
            onChanged();
          }
          this.mergeUnknownFields(other.unknownFields);
          onChanged();
          return this;
        }

        @java.lang.Override
        public final boolean isInitialized() {
          return true;
        }

        @java.lang.Override
        public Builder mergeFrom(
            com.google.protobuf.CodedInputStream input,
            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
            throws java.io.IOException {
          com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parsedMessage = null;
          try {
            parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
            parsedMessage = (com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File) e.getUnfinishedMessage();
            throw e.unwrapIOException();
          } finally {
            if (parsedMessage != null) {
              mergeFrom(parsedMessage);
            }
          }
          return this;
        }
        private int bitField0_;

        private java.lang.Object name_ = "";
        The file name, relative to the output directory.  The name must not
contain "." or ".." components and must be relative, not be absolute (so,
the file cannot lie outside the output directory).  "/" must be used as
the path separator, not "\".
If the name is omitted, the content will be appended to the previous
file.  This allows the generator to break large files into small chunks,
and allows the generated text to be streamed back to protoc so that large
files need not reside completely in memory at one time.  Note that as of
this writing protoc does not optimize for this -- it will read the entire
CodeGeneratorResponse before writing files to disk.

optional string name = 1;
Returns: Whether the name field is set./**
         * <pre>
         * The file name, relative to the output directory.  The name must not
         * contain "." or ".." components and must be relative, not be absolute (so,
         * the file cannot lie outside the output directory).  "/" must be used as
         * the path separator, not "&#92;".
         * If the name is omitted, the content will be appended to the previous
         * file.  This allows the generator to break large files into small chunks,
         * and allows the generated text to be streamed back to protoc so that large
         * files need not reside completely in memory at one time.  Note that as of
         * this writing protoc does not optimize for this -- it will read the entire
         * CodeGeneratorResponse before writing files to disk.
         * </pre>
         *
         * <code>optional string name = 1;</code>
         * @return Whether the name field is set.
         */
        public boolean hasName() {
          return ((bitField0_ & 0x00000001) != 0);
        }
        The file name, relative to the output directory.  The name must not
contain "." or ".." components and must be relative, not be absolute (so,
the file cannot lie outside the output directory).  "/" must be used as
the path separator, not "\".
If the name is omitted, the content will be appended to the previous
file.  This allows the generator to break large files into small chunks,
and allows the generated text to be streamed back to protoc so that large
files need not reside completely in memory at one time.  Note that as of
this writing protoc does not optimize for this -- it will read the entire
CodeGeneratorResponse before writing files to disk.

optional string name = 1;
Returns: The name./**
         * <pre>
         * The file name, relative to the output directory.  The name must not
         * contain "." or ".." components and must be relative, not be absolute (so,
         * the file cannot lie outside the output directory).  "/" must be used as
         * the path separator, not "&#92;".
         * If the name is omitted, the content will be appended to the previous
         * file.  This allows the generator to break large files into small chunks,
         * and allows the generated text to be streamed back to protoc so that large
         * files need not reside completely in memory at one time.  Note that as of
         * this writing protoc does not optimize for this -- it will read the entire
         * CodeGeneratorResponse before writing files to disk.
         * </pre>
         *
         * <code>optional string name = 1;</code>
         * @return The name.
         */
        public java.lang.String getName() {
          java.lang.Object ref = name_;
          if (!(ref instanceof java.lang.String)) {
            com.google.protobuf.ByteString bs =
                (com.google.protobuf.ByteString) ref;
            java.lang.String s = bs.toStringUtf8();
            if (bs.isValidUtf8()) {
              name_ = s;
            }
            return s;
          } else {
            return (java.lang.String) ref;
          }
        }
        The file name, relative to the output directory.  The name must not
contain "." or ".." components and must be relative, not be absolute (so,
the file cannot lie outside the output directory).  "/" must be used as
the path separator, not "\".
If the name is omitted, the content will be appended to the previous
file.  This allows the generator to break large files into small chunks,
and allows the generated text to be streamed back to protoc so that large
files need not reside completely in memory at one time.  Note that as of
this writing protoc does not optimize for this -- it will read the entire
CodeGeneratorResponse before writing files to disk.

optional string name = 1;
Returns: The bytes for name./**
         * <pre>
         * The file name, relative to the output directory.  The name must not
         * contain "." or ".." components and must be relative, not be absolute (so,
         * the file cannot lie outside the output directory).  "/" must be used as
         * the path separator, not "&#92;".
         * If the name is omitted, the content will be appended to the previous
         * file.  This allows the generator to break large files into small chunks,
         * and allows the generated text to be streamed back to protoc so that large
         * files need not reside completely in memory at one time.  Note that as of
         * this writing protoc does not optimize for this -- it will read the entire
         * CodeGeneratorResponse before writing files to disk.
         * </pre>
         *
         * <code>optional string name = 1;</code>
         * @return The bytes for name.
         */
        public com.google.protobuf.ByteString
            getNameBytes() {
          java.lang.Object ref = name_;
          if (ref instanceof String) {
            com.google.protobuf.ByteString b = 
                com.google.protobuf.ByteString.copyFromUtf8(
                    (java.lang.String) ref);
            name_ = b;
            return b;
          } else {
            return (com.google.protobuf.ByteString) ref;
          }
        }
        The file name, relative to the output directory.  The name must not
contain "." or ".." components and must be relative, not be absolute (so,
the file cannot lie outside the output directory).  "/" must be used as
the path separator, not "\".
If the name is omitted, the content will be appended to the previous
file.  This allows the generator to break large files into small chunks,
and allows the generated text to be streamed back to protoc so that large
files need not reside completely in memory at one time.  Note that as of
this writing protoc does not optimize for this -- it will read the entire
CodeGeneratorResponse before writing files to disk.

optional string name = 1;
Params: value – The name to set.
Returns: This builder for chaining./**
         * <pre>
         * The file name, relative to the output directory.  The name must not
         * contain "." or ".." components and must be relative, not be absolute (so,
         * the file cannot lie outside the output directory).  "/" must be used as
         * the path separator, not "&#92;".
         * If the name is omitted, the content will be appended to the previous
         * file.  This allows the generator to break large files into small chunks,
         * and allows the generated text to be streamed back to protoc so that large
         * files need not reside completely in memory at one time.  Note that as of
         * this writing protoc does not optimize for this -- it will read the entire
         * CodeGeneratorResponse before writing files to disk.
         * </pre>
         *
         * <code>optional string name = 1;</code>
         * @param value The name to set.
         * @return This builder for chaining.
         */
        public Builder setName(
            java.lang.String value) {
          if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000001;
          name_ = value;
          onChanged();
          return this;
        }
        The file name, relative to the output directory.  The name must not
contain "." or ".." components and must be relative, not be absolute (so,
the file cannot lie outside the output directory).  "/" must be used as
the path separator, not "\".
If the name is omitted, the content will be appended to the previous
file.  This allows the generator to break large files into small chunks,
and allows the generated text to be streamed back to protoc so that large
files need not reside completely in memory at one time.  Note that as of
this writing protoc does not optimize for this -- it will read the entire
CodeGeneratorResponse before writing files to disk.

optional string name = 1;
Returns: This builder for chaining./**
         * <pre>
         * The file name, relative to the output directory.  The name must not
         * contain "." or ".." components and must be relative, not be absolute (so,
         * the file cannot lie outside the output directory).  "/" must be used as
         * the path separator, not "&#92;".
         * If the name is omitted, the content will be appended to the previous
         * file.  This allows the generator to break large files into small chunks,
         * and allows the generated text to be streamed back to protoc so that large
         * files need not reside completely in memory at one time.  Note that as of
         * this writing protoc does not optimize for this -- it will read the entire
         * CodeGeneratorResponse before writing files to disk.
         * </pre>
         *
         * <code>optional string name = 1;</code>
         * @return This builder for chaining.
         */
        public Builder clearName() {
          bitField0_ = (bitField0_ & ~0x00000001);
          name_ = getDefaultInstance().getName();
          onChanged();
          return this;
        }
        The file name, relative to the output directory.  The name must not
contain "." or ".." components and must be relative, not be absolute (so,
the file cannot lie outside the output directory).  "/" must be used as
the path separator, not "\".
If the name is omitted, the content will be appended to the previous
file.  This allows the generator to break large files into small chunks,
and allows the generated text to be streamed back to protoc so that large
files need not reside completely in memory at one time.  Note that as of
this writing protoc does not optimize for this -- it will read the entire
CodeGeneratorResponse before writing files to disk.

optional string name = 1;
Params: value – The bytes for name to set.
Returns: This builder for chaining./**
         * <pre>
         * The file name, relative to the output directory.  The name must not
         * contain "." or ".." components and must be relative, not be absolute (so,
         * the file cannot lie outside the output directory).  "/" must be used as
         * the path separator, not "&#92;".
         * If the name is omitted, the content will be appended to the previous
         * file.  This allows the generator to break large files into small chunks,
         * and allows the generated text to be streamed back to protoc so that large
         * files need not reside completely in memory at one time.  Note that as of
         * this writing protoc does not optimize for this -- it will read the entire
         * CodeGeneratorResponse before writing files to disk.
         * </pre>
         *
         * <code>optional string name = 1;</code>
         * @param value The bytes for name to set.
         * @return This builder for chaining.
         */
        public Builder setNameBytes(
            com.google.protobuf.ByteString value) {
          if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000001;
          name_ = value;
          onChanged();
          return this;
        }

        private java.lang.Object insertionPoint_ = "";
        If non-empty, indicates that the named file should already exist, and the
content here is to be inserted into that file at a defined insertion
point.  This feature allows a code generator to extend the output
produced by another code generator.  The original generator may provide
insertion points by placing special annotations in the file that look
like:
  @@protoc_insertion_point(NAME)
The annotation can have arbitrary text before and after it on the line,
which allows it to be placed in a comment.  NAME should be replaced with
an identifier naming the point -- this is what other generators will use
as the insertion_point.  Code inserted at this point will be placed
immediately above the line containing the insertion point (thus multiple
insertions to the same point will come out in the order they were added).
The double-@ is intended to make it unlikely that the generated code
could contain things that look like insertion points by accident.
For example, the C++ code generator places the following line in the
.pb.h files that it generates:
  // @@protoc_insertion_point(namespace_scope)
This line appears within the scope of the file's package namespace, but
outside of any particular class.  Another plugin can then specify the
insertion_point "namespace_scope" to generate additional classes or
other declarations that should be placed in this scope.
Note that if the line containing the insertion point begins with
whitespace, the same whitespace will be added to every line of the
inserted text.  This is useful for languages like Python, where
indentation matters.  In these languages, the insertion point comment
should be indented the same amount as any inserted code will need to be
in order to work correctly in that context.
The code generator that generates the initial file and the one which
inserts into it must both run as part of a single invocation of protoc.
Code generators are executed in the order in which they appear on the
command line.
If |insertion_point| is present, |name| must also be present.

optional string insertion_point = 2;
Returns: Whether the insertionPoint field is set./**
         * <pre>
         * If non-empty, indicates that the named file should already exist, and the
         * content here is to be inserted into that file at a defined insertion
         * point.  This feature allows a code generator to extend the output
         * produced by another code generator.  The original generator may provide
         * insertion points by placing special annotations in the file that look
         * like:
         *   &#64;&#64;protoc_insertion_point(NAME)
         * The annotation can have arbitrary text before and after it on the line,
         * which allows it to be placed in a comment.  NAME should be replaced with
         * an identifier naming the point -- this is what other generators will use
         * as the insertion_point.  Code inserted at this point will be placed
         * immediately above the line containing the insertion point (thus multiple
         * insertions to the same point will come out in the order they were added).
         * The double-&#64; is intended to make it unlikely that the generated code
         * could contain things that look like insertion points by accident.
         * For example, the C++ code generator places the following line in the
         * .pb.h files that it generates:
         *   // &#64;&#64;protoc_insertion_point(namespace_scope)
         * This line appears within the scope of the file's package namespace, but
         * outside of any particular class.  Another plugin can then specify the
         * insertion_point "namespace_scope" to generate additional classes or
         * other declarations that should be placed in this scope.
         * Note that if the line containing the insertion point begins with
         * whitespace, the same whitespace will be added to every line of the
         * inserted text.  This is useful for languages like Python, where
         * indentation matters.  In these languages, the insertion point comment
         * should be indented the same amount as any inserted code will need to be
         * in order to work correctly in that context.
         * The code generator that generates the initial file and the one which
         * inserts into it must both run as part of a single invocation of protoc.
         * Code generators are executed in the order in which they appear on the
         * command line.
         * If |insertion_point| is present, |name| must also be present.
         * </pre>
         *
         * <code>optional string insertion_point = 2;</code>
         * @return Whether the insertionPoint field is set.
         */
        public boolean hasInsertionPoint() {
          return ((bitField0_ & 0x00000002) != 0);
        }
        If non-empty, indicates that the named file should already exist, and the
content here is to be inserted into that file at a defined insertion
point.  This feature allows a code generator to extend the output
produced by another code generator.  The original generator may provide
insertion points by placing special annotations in the file that look
like:
  @@protoc_insertion_point(NAME)
The annotation can have arbitrary text before and after it on the line,
which allows it to be placed in a comment.  NAME should be replaced with
an identifier naming the point -- this is what other generators will use
as the insertion_point.  Code inserted at this point will be placed
immediately above the line containing the insertion point (thus multiple
insertions to the same point will come out in the order they were added).
The double-@ is intended to make it unlikely that the generated code
could contain things that look like insertion points by accident.
For example, the C++ code generator places the following line in the
.pb.h files that it generates:
  // @@protoc_insertion_point(namespace_scope)
This line appears within the scope of the file's package namespace, but
outside of any particular class.  Another plugin can then specify the
insertion_point "namespace_scope" to generate additional classes or
other declarations that should be placed in this scope.
Note that if the line containing the insertion point begins with
whitespace, the same whitespace will be added to every line of the
inserted text.  This is useful for languages like Python, where
indentation matters.  In these languages, the insertion point comment
should be indented the same amount as any inserted code will need to be
in order to work correctly in that context.
The code generator that generates the initial file and the one which
inserts into it must both run as part of a single invocation of protoc.
Code generators are executed in the order in which they appear on the
command line.
If |insertion_point| is present, |name| must also be present.

optional string insertion_point = 2;
Returns: The insertionPoint./**
         * <pre>
         * If non-empty, indicates that the named file should already exist, and the
         * content here is to be inserted into that file at a defined insertion
         * point.  This feature allows a code generator to extend the output
         * produced by another code generator.  The original generator may provide
         * insertion points by placing special annotations in the file that look
         * like:
         *   &#64;&#64;protoc_insertion_point(NAME)
         * The annotation can have arbitrary text before and after it on the line,
         * which allows it to be placed in a comment.  NAME should be replaced with
         * an identifier naming the point -- this is what other generators will use
         * as the insertion_point.  Code inserted at this point will be placed
         * immediately above the line containing the insertion point (thus multiple
         * insertions to the same point will come out in the order they were added).
         * The double-&#64; is intended to make it unlikely that the generated code
         * could contain things that look like insertion points by accident.
         * For example, the C++ code generator places the following line in the
         * .pb.h files that it generates:
         *   // &#64;&#64;protoc_insertion_point(namespace_scope)
         * This line appears within the scope of the file's package namespace, but
         * outside of any particular class.  Another plugin can then specify the
         * insertion_point "namespace_scope" to generate additional classes or
         * other declarations that should be placed in this scope.
         * Note that if the line containing the insertion point begins with
         * whitespace, the same whitespace will be added to every line of the
         * inserted text.  This is useful for languages like Python, where
         * indentation matters.  In these languages, the insertion point comment
         * should be indented the same amount as any inserted code will need to be
         * in order to work correctly in that context.
         * The code generator that generates the initial file and the one which
         * inserts into it must both run as part of a single invocation of protoc.
         * Code generators are executed in the order in which they appear on the
         * command line.
         * If |insertion_point| is present, |name| must also be present.
         * </pre>
         *
         * <code>optional string insertion_point = 2;</code>
         * @return The insertionPoint.
         */
        public java.lang.String getInsertionPoint() {
          java.lang.Object ref = insertionPoint_;
          if (!(ref instanceof java.lang.String)) {
            com.google.protobuf.ByteString bs =
                (com.google.protobuf.ByteString) ref;
            java.lang.String s = bs.toStringUtf8();
            if (bs.isValidUtf8()) {
              insertionPoint_ = s;
            }
            return s;
          } else {
            return (java.lang.String) ref;
          }
        }
        If non-empty, indicates that the named file should already exist, and the
content here is to be inserted into that file at a defined insertion
point.  This feature allows a code generator to extend the output
produced by another code generator.  The original generator may provide
insertion points by placing special annotations in the file that look
like:
  @@protoc_insertion_point(NAME)
The annotation can have arbitrary text before and after it on the line,
which allows it to be placed in a comment.  NAME should be replaced with
an identifier naming the point -- this is what other generators will use
as the insertion_point.  Code inserted at this point will be placed
immediately above the line containing the insertion point (thus multiple
insertions to the same point will come out in the order they were added).
The double-@ is intended to make it unlikely that the generated code
could contain things that look like insertion points by accident.
For example, the C++ code generator places the following line in the
.pb.h files that it generates:
  // @@protoc_insertion_point(namespace_scope)
This line appears within the scope of the file's package namespace, but
outside of any particular class.  Another plugin can then specify the
insertion_point "namespace_scope" to generate additional classes or
other declarations that should be placed in this scope.
Note that if the line containing the insertion point begins with
whitespace, the same whitespace will be added to every line of the
inserted text.  This is useful for languages like Python, where
indentation matters.  In these languages, the insertion point comment
should be indented the same amount as any inserted code will need to be
in order to work correctly in that context.
The code generator that generates the initial file and the one which
inserts into it must both run as part of a single invocation of protoc.
Code generators are executed in the order in which they appear on the
command line.
If |insertion_point| is present, |name| must also be present.

optional string insertion_point = 2;
Returns: The bytes for insertionPoint./**
         * <pre>
         * If non-empty, indicates that the named file should already exist, and the
         * content here is to be inserted into that file at a defined insertion
         * point.  This feature allows a code generator to extend the output
         * produced by another code generator.  The original generator may provide
         * insertion points by placing special annotations in the file that look
         * like:
         *   &#64;&#64;protoc_insertion_point(NAME)
         * The annotation can have arbitrary text before and after it on the line,
         * which allows it to be placed in a comment.  NAME should be replaced with
         * an identifier naming the point -- this is what other generators will use
         * as the insertion_point.  Code inserted at this point will be placed
         * immediately above the line containing the insertion point (thus multiple
         * insertions to the same point will come out in the order they were added).
         * The double-&#64; is intended to make it unlikely that the generated code
         * could contain things that look like insertion points by accident.
         * For example, the C++ code generator places the following line in the
         * .pb.h files that it generates:
         *   // &#64;&#64;protoc_insertion_point(namespace_scope)
         * This line appears within the scope of the file's package namespace, but
         * outside of any particular class.  Another plugin can then specify the
         * insertion_point "namespace_scope" to generate additional classes or
         * other declarations that should be placed in this scope.
         * Note that if the line containing the insertion point begins with
         * whitespace, the same whitespace will be added to every line of the
         * inserted text.  This is useful for languages like Python, where
         * indentation matters.  In these languages, the insertion point comment
         * should be indented the same amount as any inserted code will need to be
         * in order to work correctly in that context.
         * The code generator that generates the initial file and the one which
         * inserts into it must both run as part of a single invocation of protoc.
         * Code generators are executed in the order in which they appear on the
         * command line.
         * If |insertion_point| is present, |name| must also be present.
         * </pre>
         *
         * <code>optional string insertion_point = 2;</code>
         * @return The bytes for insertionPoint.
         */
        public com.google.protobuf.ByteString
            getInsertionPointBytes() {
          java.lang.Object ref = insertionPoint_;
          if (ref instanceof String) {
            com.google.protobuf.ByteString b = 
                com.google.protobuf.ByteString.copyFromUtf8(
                    (java.lang.String) ref);
            insertionPoint_ = b;
            return b;
          } else {
            return (com.google.protobuf.ByteString) ref;
          }
        }
        If non-empty, indicates that the named file should already exist, and the
content here is to be inserted into that file at a defined insertion
point.  This feature allows a code generator to extend the output
produced by another code generator.  The original generator may provide
insertion points by placing special annotations in the file that look
like:
  @@protoc_insertion_point(NAME)
The annotation can have arbitrary text before and after it on the line,
which allows it to be placed in a comment.  NAME should be replaced with
an identifier naming the point -- this is what other generators will use
as the insertion_point.  Code inserted at this point will be placed
immediately above the line containing the insertion point (thus multiple
insertions to the same point will come out in the order they were added).
The double-@ is intended to make it unlikely that the generated code
could contain things that look like insertion points by accident.
For example, the C++ code generator places the following line in the
.pb.h files that it generates:
  // @@protoc_insertion_point(namespace_scope)
This line appears within the scope of the file's package namespace, but
outside of any particular class.  Another plugin can then specify the
insertion_point "namespace_scope" to generate additional classes or
other declarations that should be placed in this scope.
Note that if the line containing the insertion point begins with
whitespace, the same whitespace will be added to every line of the
inserted text.  This is useful for languages like Python, where
indentation matters.  In these languages, the insertion point comment
should be indented the same amount as any inserted code will need to be
in order to work correctly in that context.
The code generator that generates the initial file and the one which
inserts into it must both run as part of a single invocation of protoc.
Code generators are executed in the order in which they appear on the
command line.
If |insertion_point| is present, |name| must also be present.

optional string insertion_point = 2;
Params: value – The insertionPoint to set.
Returns: This builder for chaining./**
         * <pre>
         * If non-empty, indicates that the named file should already exist, and the
         * content here is to be inserted into that file at a defined insertion
         * point.  This feature allows a code generator to extend the output
         * produced by another code generator.  The original generator may provide
         * insertion points by placing special annotations in the file that look
         * like:
         *   &#64;&#64;protoc_insertion_point(NAME)
         * The annotation can have arbitrary text before and after it on the line,
         * which allows it to be placed in a comment.  NAME should be replaced with
         * an identifier naming the point -- this is what other generators will use
         * as the insertion_point.  Code inserted at this point will be placed
         * immediately above the line containing the insertion point (thus multiple
         * insertions to the same point will come out in the order they were added).
         * The double-&#64; is intended to make it unlikely that the generated code
         * could contain things that look like insertion points by accident.
         * For example, the C++ code generator places the following line in the
         * .pb.h files that it generates:
         *   // &#64;&#64;protoc_insertion_point(namespace_scope)
         * This line appears within the scope of the file's package namespace, but
         * outside of any particular class.  Another plugin can then specify the
         * insertion_point "namespace_scope" to generate additional classes or
         * other declarations that should be placed in this scope.
         * Note that if the line containing the insertion point begins with
         * whitespace, the same whitespace will be added to every line of the
         * inserted text.  This is useful for languages like Python, where
         * indentation matters.  In these languages, the insertion point comment
         * should be indented the same amount as any inserted code will need to be
         * in order to work correctly in that context.
         * The code generator that generates the initial file and the one which
         * inserts into it must both run as part of a single invocation of protoc.
         * Code generators are executed in the order in which they appear on the
         * command line.
         * If |insertion_point| is present, |name| must also be present.
         * </pre>
         *
         * <code>optional string insertion_point = 2;</code>
         * @param value The insertionPoint to set.
         * @return This builder for chaining.
         */
        public Builder setInsertionPoint(
            java.lang.String value) {
          if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000002;
          insertionPoint_ = value;
          onChanged();
          return this;
        }
        If non-empty, indicates that the named file should already exist, and the
content here is to be inserted into that file at a defined insertion
point.  This feature allows a code generator to extend the output
produced by another code generator.  The original generator may provide
insertion points by placing special annotations in the file that look
like:
  @@protoc_insertion_point(NAME)
The annotation can have arbitrary text before and after it on the line,
which allows it to be placed in a comment.  NAME should be replaced with
an identifier naming the point -- this is what other generators will use
as the insertion_point.  Code inserted at this point will be placed
immediately above the line containing the insertion point (thus multiple
insertions to the same point will come out in the order they were added).
The double-@ is intended to make it unlikely that the generated code
could contain things that look like insertion points by accident.
For example, the C++ code generator places the following line in the
.pb.h files that it generates:
  // @@protoc_insertion_point(namespace_scope)
This line appears within the scope of the file's package namespace, but
outside of any particular class.  Another plugin can then specify the
insertion_point "namespace_scope" to generate additional classes or
other declarations that should be placed in this scope.
Note that if the line containing the insertion point begins with
whitespace, the same whitespace will be added to every line of the
inserted text.  This is useful for languages like Python, where
indentation matters.  In these languages, the insertion point comment
should be indented the same amount as any inserted code will need to be
in order to work correctly in that context.
The code generator that generates the initial file and the one which
inserts into it must both run as part of a single invocation of protoc.
Code generators are executed in the order in which they appear on the
command line.
If |insertion_point| is present, |name| must also be present.

optional string insertion_point = 2;
Returns: This builder for chaining./**
         * <pre>
         * If non-empty, indicates that the named file should already exist, and the
         * content here is to be inserted into that file at a defined insertion
         * point.  This feature allows a code generator to extend the output
         * produced by another code generator.  The original generator may provide
         * insertion points by placing special annotations in the file that look
         * like:
         *   &#64;&#64;protoc_insertion_point(NAME)
         * The annotation can have arbitrary text before and after it on the line,
         * which allows it to be placed in a comment.  NAME should be replaced with
         * an identifier naming the point -- this is what other generators will use
         * as the insertion_point.  Code inserted at this point will be placed
         * immediately above the line containing the insertion point (thus multiple
         * insertions to the same point will come out in the order they were added).
         * The double-&#64; is intended to make it unlikely that the generated code
         * could contain things that look like insertion points by accident.
         * For example, the C++ code generator places the following line in the
         * .pb.h files that it generates:
         *   // &#64;&#64;protoc_insertion_point(namespace_scope)
         * This line appears within the scope of the file's package namespace, but
         * outside of any particular class.  Another plugin can then specify the
         * insertion_point "namespace_scope" to generate additional classes or
         * other declarations that should be placed in this scope.
         * Note that if the line containing the insertion point begins with
         * whitespace, the same whitespace will be added to every line of the
         * inserted text.  This is useful for languages like Python, where
         * indentation matters.  In these languages, the insertion point comment
         * should be indented the same amount as any inserted code will need to be
         * in order to work correctly in that context.
         * The code generator that generates the initial file and the one which
         * inserts into it must both run as part of a single invocation of protoc.
         * Code generators are executed in the order in which they appear on the
         * command line.
         * If |insertion_point| is present, |name| must also be present.
         * </pre>
         *
         * <code>optional string insertion_point = 2;</code>
         * @return This builder for chaining.
         */
        public Builder clearInsertionPoint() {
          bitField0_ = (bitField0_ & ~0x00000002);
          insertionPoint_ = getDefaultInstance().getInsertionPoint();
          onChanged();
          return this;
        }
        If non-empty, indicates that the named file should already exist, and the
content here is to be inserted into that file at a defined insertion
point.  This feature allows a code generator to extend the output
produced by another code generator.  The original generator may provide
insertion points by placing special annotations in the file that look
like:
  @@protoc_insertion_point(NAME)
The annotation can have arbitrary text before and after it on the line,
which allows it to be placed in a comment.  NAME should be replaced with
an identifier naming the point -- this is what other generators will use
as the insertion_point.  Code inserted at this point will be placed
immediately above the line containing the insertion point (thus multiple
insertions to the same point will come out in the order they were added).
The double-@ is intended to make it unlikely that the generated code
could contain things that look like insertion points by accident.
For example, the C++ code generator places the following line in the
.pb.h files that it generates:
  // @@protoc_insertion_point(namespace_scope)
This line appears within the scope of the file's package namespace, but
outside of any particular class.  Another plugin can then specify the
insertion_point "namespace_scope" to generate additional classes or
other declarations that should be placed in this scope.
Note that if the line containing the insertion point begins with
whitespace, the same whitespace will be added to every line of the
inserted text.  This is useful for languages like Python, where
indentation matters.  In these languages, the insertion point comment
should be indented the same amount as any inserted code will need to be
in order to work correctly in that context.
The code generator that generates the initial file and the one which
inserts into it must both run as part of a single invocation of protoc.
Code generators are executed in the order in which they appear on the
command line.
If |insertion_point| is present, |name| must also be present.

optional string insertion_point = 2;
Params: value – The bytes for insertionPoint to set.
Returns: This builder for chaining./**
         * <pre>
         * If non-empty, indicates that the named file should already exist, and the
         * content here is to be inserted into that file at a defined insertion
         * point.  This feature allows a code generator to extend the output
         * produced by another code generator.  The original generator may provide
         * insertion points by placing special annotations in the file that look
         * like:
         *   &#64;&#64;protoc_insertion_point(NAME)
         * The annotation can have arbitrary text before and after it on the line,
         * which allows it to be placed in a comment.  NAME should be replaced with
         * an identifier naming the point -- this is what other generators will use
         * as the insertion_point.  Code inserted at this point will be placed
         * immediately above the line containing the insertion point (thus multiple
         * insertions to the same point will come out in the order they were added).
         * The double-&#64; is intended to make it unlikely that the generated code
         * could contain things that look like insertion points by accident.
         * For example, the C++ code generator places the following line in the
         * .pb.h files that it generates:
         *   // &#64;&#64;protoc_insertion_point(namespace_scope)
         * This line appears within the scope of the file's package namespace, but
         * outside of any particular class.  Another plugin can then specify the
         * insertion_point "namespace_scope" to generate additional classes or
         * other declarations that should be placed in this scope.
         * Note that if the line containing the insertion point begins with
         * whitespace, the same whitespace will be added to every line of the
         * inserted text.  This is useful for languages like Python, where
         * indentation matters.  In these languages, the insertion point comment
         * should be indented the same amount as any inserted code will need to be
         * in order to work correctly in that context.
         * The code generator that generates the initial file and the one which
         * inserts into it must both run as part of a single invocation of protoc.
         * Code generators are executed in the order in which they appear on the
         * command line.
         * If |insertion_point| is present, |name| must also be present.
         * </pre>
         *
         * <code>optional string insertion_point = 2;</code>
         * @param value The bytes for insertionPoint to set.
         * @return This builder for chaining.
         */
        public Builder setInsertionPointBytes(
            com.google.protobuf.ByteString value) {
          if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000002;
          insertionPoint_ = value;
          onChanged();
          return this;
        }

        private java.lang.Object content_ = "";
        The file contents.

optional string content = 15;
Returns: Whether the content field is set./**
         * <pre>
         * The file contents.
         * </pre>
         *
         * <code>optional string content = 15;</code>
         * @return Whether the content field is set.
         */
        public boolean hasContent() {
          return ((bitField0_ & 0x00000004) != 0);
        }
        The file contents.

optional string content = 15;
Returns: The content./**
         * <pre>
         * The file contents.
         * </pre>
         *
         * <code>optional string content = 15;</code>
         * @return The content.
         */
        public java.lang.String getContent() {
          java.lang.Object ref = content_;
          if (!(ref instanceof java.lang.String)) {
            com.google.protobuf.ByteString bs =
                (com.google.protobuf.ByteString) ref;
            java.lang.String s = bs.toStringUtf8();
            if (bs.isValidUtf8()) {
              content_ = s;
            }
            return s;
          } else {
            return (java.lang.String) ref;
          }
        }
        The file contents.

optional string content = 15;
Returns: The bytes for content./**
         * <pre>
         * The file contents.
         * </pre>
         *
         * <code>optional string content = 15;</code>
         * @return The bytes for content.
         */
        public com.google.protobuf.ByteString
            getContentBytes() {
          java.lang.Object ref = content_;
          if (ref instanceof String) {
            com.google.protobuf.ByteString b = 
                com.google.protobuf.ByteString.copyFromUtf8(
                    (java.lang.String) ref);
            content_ = b;
            return b;
          } else {
            return (com.google.protobuf.ByteString) ref;
          }
        }
        The file contents.

optional string content = 15;
Params: value – The content to set.
Returns: This builder for chaining./**
         * <pre>
         * The file contents.
         * </pre>
         *
         * <code>optional string content = 15;</code>
         * @param value The content to set.
         * @return This builder for chaining.
         */
        public Builder setContent(
            java.lang.String value) {
          if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000004;
          content_ = value;
          onChanged();
          return this;
        }
        The file contents.

optional string content = 15;
Returns: This builder for chaining./**
         * <pre>
         * The file contents.
         * </pre>
         *
         * <code>optional string content = 15;</code>
         * @return This builder for chaining.
         */
        public Builder clearContent() {
          bitField0_ = (bitField0_ & ~0x00000004);
          content_ = getDefaultInstance().getContent();
          onChanged();
          return this;
        }
        The file contents.

optional string content = 15;
Params: value – The bytes for content to set.
Returns: This builder for chaining./**
         * <pre>
         * The file contents.
         * </pre>
         *
         * <code>optional string content = 15;</code>
         * @param value The bytes for content to set.
         * @return This builder for chaining.
         */
        public Builder setContentBytes(
            com.google.protobuf.ByteString value) {
          if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000004;
          content_ = value;
          onChanged();
          return this;
        }
        @java.lang.Override
        public final Builder setUnknownFields(
            final com.google.protobuf.UnknownFieldSet unknownFields) {
          return super.setUnknownFields(unknownFields);
        }

        @java.lang.Override
        public final Builder mergeUnknownFields(
            final com.google.protobuf.UnknownFieldSet unknownFields) {
          return super.mergeUnknownFields(unknownFields);
        }


        // @@protoc_insertion_point(builder_scope:google.protobuf.compiler.CodeGeneratorResponse.File)
      }

      // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse.File)
      private static final com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File DEFAULT_INSTANCE;
      static {
        DEFAULT_INSTANCE = new com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File();
      }

      public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File getDefaultInstance() {
        return DEFAULT_INSTANCE;
      }

      @java.lang.Deprecated public static final com.google.protobuf.Parser<File>
          PARSER = new com.google.protobuf.AbstractParser<File>() {
        @java.lang.Override
        public File parsePartialFrom(
            com.google.protobuf.CodedInputStream input,
            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
            throws com.google.protobuf.InvalidProtocolBufferException {
          return new File(input, extensionRegistry);
        }
      };

      public static com.google.protobuf.Parser<File> parser() {
        return PARSER;
      }

      @java.lang.Override
      public com.google.protobuf.Parser<File> getParserForType() {
        return PARSER;
      }

      @java.lang.Override
      public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File getDefaultInstanceForType() {
        return DEFAULT_INSTANCE;
      }

    }

    private int bitField0_;
    public static final int ERROR_FIELD_NUMBER = 1;
    private volatile java.lang.Object error_;
    Error message.  If non-empty, code generation failed.  The plugin process
should exit with status code zero even if it reports an error in this way.
This should be used to indicate errors in .proto files which prevent the
code generator from generating correct code.  Errors which indicate a
problem in protoc itself -- such as the input CodeGeneratorRequest being
unparseable -- should be reported by writing a message to stderr and
exiting with a non-zero status code.

optional string error = 1;
Returns: Whether the error field is set./**
     * <pre>
     * Error message.  If non-empty, code generation failed.  The plugin process
     * should exit with status code zero even if it reports an error in this way.
     * This should be used to indicate errors in .proto files which prevent the
     * code generator from generating correct code.  Errors which indicate a
     * problem in protoc itself -- such as the input CodeGeneratorRequest being
     * unparseable -- should be reported by writing a message to stderr and
     * exiting with a non-zero status code.
     * </pre>
     *
     * <code>optional string error = 1;</code>
     * @return Whether the error field is set.
     */
    public boolean hasError() {
      return ((bitField0_ & 0x00000001) != 0);
    }
    Error message.  If non-empty, code generation failed.  The plugin process
should exit with status code zero even if it reports an error in this way.
This should be used to indicate errors in .proto files which prevent the
code generator from generating correct code.  Errors which indicate a
problem in protoc itself -- such as the input CodeGeneratorRequest being
unparseable -- should be reported by writing a message to stderr and
exiting with a non-zero status code.

optional string error = 1;
Returns: The error./**
     * <pre>
     * Error message.  If non-empty, code generation failed.  The plugin process
     * should exit with status code zero even if it reports an error in this way.
     * This should be used to indicate errors in .proto files which prevent the
     * code generator from generating correct code.  Errors which indicate a
     * problem in protoc itself -- such as the input CodeGeneratorRequest being
     * unparseable -- should be reported by writing a message to stderr and
     * exiting with a non-zero status code.
     * </pre>
     *
     * <code>optional string error = 1;</code>
     * @return The error.
     */
    public java.lang.String getError() {
      java.lang.Object ref = error_;
      if (ref instanceof java.lang.String) {
        return (java.lang.String) ref;
      } else {
        com.google.protobuf.ByteString bs = 
            (com.google.protobuf.ByteString) ref;
        java.lang.String s = bs.toStringUtf8();
        if (bs.isValidUtf8()) {
          error_ = s;
        }
        return s;
      }
    }
    Error message.  If non-empty, code generation failed.  The plugin process
should exit with status code zero even if it reports an error in this way.
This should be used to indicate errors in .proto files which prevent the
code generator from generating correct code.  Errors which indicate a
problem in protoc itself -- such as the input CodeGeneratorRequest being
unparseable -- should be reported by writing a message to stderr and
exiting with a non-zero status code.

optional string error = 1;
Returns: The bytes for error./**
     * <pre>
     * Error message.  If non-empty, code generation failed.  The plugin process
     * should exit with status code zero even if it reports an error in this way.
     * This should be used to indicate errors in .proto files which prevent the
     * code generator from generating correct code.  Errors which indicate a
     * problem in protoc itself -- such as the input CodeGeneratorRequest being
     * unparseable -- should be reported by writing a message to stderr and
     * exiting with a non-zero status code.
     * </pre>
     *
     * <code>optional string error = 1;</code>
     * @return The bytes for error.
     */
    public com.google.protobuf.ByteString
        getErrorBytes() {
      java.lang.Object ref = error_;
      if (ref instanceof java.lang.String) {
        com.google.protobuf.ByteString b = 
            com.google.protobuf.ByteString.copyFromUtf8(
                (java.lang.String) ref);
        error_ = b;
        return b;
      } else {
        return (com.google.protobuf.ByteString) ref;
      }
    }

    public static final int FILE_FIELD_NUMBER = 15;
    private java.util.List<com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File> file_;
    repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
     * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
     */
    public java.util.List<com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File> getFileList() {
      return file_;
    }
    repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
     * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
     */
    public java.util.List<? extends com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.FileOrBuilder> 
        getFileOrBuilderList() {
      return file_;
    }
    repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
     * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
     */
    public int getFileCount() {
      return file_.size();
    }
    repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
     * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
     */
    public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File getFile(int index) {
      return file_.get(index);
    }
    repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
     * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
     */
    public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.FileOrBuilder getFileOrBuilder(
        int index) {
      return file_.get(index);
    }

    private byte memoizedIsInitialized = -1;
    @java.lang.Override
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized == 1) return true;
      if (isInitialized == 0) return false;

      memoizedIsInitialized = 1;
      return true;
    }

    @java.lang.Override
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      if (((bitField0_ & 0x00000001) != 0)) {
        com.google.protobuf.GeneratedMessageV3.writeString(output, 1, error_);
      }
      for (int i = 0; i < file_.size(); i++) {
        output.writeMessage(15, file_.get(i));
      }
      unknownFields.writeTo(output);
    }

    @java.lang.Override
    public int getSerializedSize() {
      int size = memoizedSize;
      if (size != -1) return size;

      size = 0;
      if (((bitField0_ & 0x00000001) != 0)) {
        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, error_);
      }
      for (int i = 0; i < file_.size(); i++) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(15, file_.get(i));
      }
      size += unknownFields.getSerializedSize();
      memoizedSize = size;
      return size;
    }

    @java.lang.Override
    public boolean equals(final java.lang.Object obj) {
      if (obj == this) {
       return true;
      }
      if (!(obj instanceof com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse)) {
        return super.equals(obj);
      }
      com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse other = (com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse) obj;

      if (hasError() != other.hasError()) return false;
      if (hasError()) {
        if (!getError()
            .equals(other.getError())) return false;
      }
      if (!getFileList()
          .equals(other.getFileList())) return false;
      if (!unknownFields.equals(other.unknownFields)) return false;
      return true;
    }

    @java.lang.Override
    public int hashCode() {
      if (memoizedHashCode != 0) {
        return memoizedHashCode;
      }
      int hash = 41;
      hash = (19 * hash) + getDescriptor().hashCode();
      if (hasError()) {
        hash = (37 * hash) + ERROR_FIELD_NUMBER;
        hash = (53 * hash) + getError().hashCode();
      }
      if (getFileCount() > 0) {
        hash = (37 * hash) + FILE_FIELD_NUMBER;
        hash = (53 * hash) + getFileList().hashCode();
      }
      hash = (29 * hash) + unknownFields.hashCode();
      memoizedHashCode = hash;
      return hash;
    }

    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
        java.nio.ByteBuffer data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
        java.nio.ByteBuffer data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return PARSER.parseFrom(data, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseWithIOException(PARSER, input);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseWithIOException(PARSER, input, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseDelimitedWithIOException(PARSER, input);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseDelimitedFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseWithIOException(PARSER, input);
    }
    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return com.google.protobuf.GeneratedMessageV3
          .parseWithIOException(PARSER, input, extensionRegistry);
    }

    @java.lang.Override
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder() {
      return DEFAULT_INSTANCE.toBuilder();
    }
    public static Builder newBuilder(com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse prototype) {
      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
    }
    @java.lang.Override
    public Builder toBuilder() {
      return this == DEFAULT_INSTANCE
          ? new Builder() : new Builder().mergeFrom(this);
    }

    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    The plugin writes an encoded CodeGeneratorResponse to stdout.
 Protobuf type google.protobuf.compiler.CodeGeneratorResponse /**
     * <pre>
     * The plugin writes an encoded CodeGeneratorResponse to stdout.
     * </pre>
     *
     * Protobuf type {@code google.protobuf.compiler.CodeGeneratorResponse}
     */
    public static final class Builder extends
        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
        // @@protoc_insertion_point(builder_implements:google.protobuf.compiler.CodeGeneratorResponse)
        com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponseOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_descriptor;
      }

      @java.lang.Override
      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_fieldAccessorTable
            .ensureFieldAccessorsInitialized(
                com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.class, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.Builder.class);
      }

      // Construct using com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }

      private Builder(
          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessageV3
                .alwaysUseFieldBuilders) {
          getFileFieldBuilder();
        }
      }
      @java.lang.Override
      public Builder clear() {
        super.clear();
        error_ = "";
        bitField0_ = (bitField0_ & ~0x00000001);
        if (fileBuilder_ == null) {
          file_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000002);
        } else {
          fileBuilder_.clear();
        }
        return this;
      }

      @java.lang.Override
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return com.google.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_descriptor;
      }

      @java.lang.Override
      public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse getDefaultInstanceForType() {
        return com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.getDefaultInstance();
      }

      @java.lang.Override
      public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse build() {
        com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }

      @java.lang.Override
      public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse buildPartial() {
        com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse result = new com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) != 0)) {
          to_bitField0_ |= 0x00000001;
        }
        result.error_ = error_;
        if (fileBuilder_ == null) {
          if (((bitField0_ & 0x00000002) != 0)) {
            file_ = java.util.Collections.unmodifiableList(file_);
            bitField0_ = (bitField0_ & ~0x00000002);
          }
          result.file_ = file_;
        } else {
          result.file_ = fileBuilder_.build();
        }
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }

      @java.lang.Override
      public Builder clone() {
        return super.clone();
      }
      @java.lang.Override
      public Builder setField(
          com.google.protobuf.Descriptors.FieldDescriptor field,
          java.lang.Object value) {
        return super.setField(field, value);
      }
      @java.lang.Override
      public Builder clearField(
          com.google.protobuf.Descriptors.FieldDescriptor field) {
        return super.clearField(field);
      }
      @java.lang.Override
      public Builder clearOneof(
          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
        return super.clearOneof(oneof);
      }
      @java.lang.Override
      public Builder setRepeatedField(
          com.google.protobuf.Descriptors.FieldDescriptor field,
          int index, java.lang.Object value) {
        return super.setRepeatedField(field, index, value);
      }
      @java.lang.Override
      public Builder addRepeatedField(
          com.google.protobuf.Descriptors.FieldDescriptor field,
          java.lang.Object value) {
        return super.addRepeatedField(field, value);
      }
      @java.lang.Override
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse) {
          return mergeFrom((com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }

      public Builder mergeFrom(com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse other) {
        if (other == com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.getDefaultInstance()) return this;
        if (other.hasError()) {
          bitField0_ |= 0x00000001;
          error_ = other.error_;
          onChanged();
        }
        if (fileBuilder_ == null) {
          if (!other.file_.isEmpty()) {
            if (file_.isEmpty()) {
              file_ = other.file_;
              bitField0_ = (bitField0_ & ~0x00000002);
            } else {
              ensureFileIsMutable();
              file_.addAll(other.file_);
            }
            onChanged();
          }
        } else {
          if (!other.file_.isEmpty()) {
            if (fileBuilder_.isEmpty()) {
              fileBuilder_.dispose();
              fileBuilder_ = null;
              file_ = other.file_;
              bitField0_ = (bitField0_ & ~0x00000002);
              fileBuilder_ = 
                com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
                   getFileFieldBuilder() : null;
            } else {
              fileBuilder_.addAllMessages(other.file_);
            }
          }
        }
        this.mergeUnknownFields(other.unknownFields);
        onChanged();
        return this;
      }

      @java.lang.Override
      public final boolean isInitialized() {
        return true;
      }

      @java.lang.Override
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse parsedMessage = null;
        try {
          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
          parsedMessage = (com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse) e.getUnfinishedMessage();
          throw e.unwrapIOException();
        } finally {
          if (parsedMessage != null) {
            mergeFrom(parsedMessage);
          }
        }
        return this;
      }
      private int bitField0_;

      private java.lang.Object error_ = "";
      Error message.  If non-empty, code generation failed.  The plugin process
should exit with status code zero even if it reports an error in this way.
This should be used to indicate errors in .proto files which prevent the
code generator from generating correct code.  Errors which indicate a
problem in protoc itself -- such as the input CodeGeneratorRequest being
unparseable -- should be reported by writing a message to stderr and
exiting with a non-zero status code.

optional string error = 1;
Returns: Whether the error field is set./**
       * <pre>
       * Error message.  If non-empty, code generation failed.  The plugin process
       * should exit with status code zero even if it reports an error in this way.
       * This should be used to indicate errors in .proto files which prevent the
       * code generator from generating correct code.  Errors which indicate a
       * problem in protoc itself -- such as the input CodeGeneratorRequest being
       * unparseable -- should be reported by writing a message to stderr and
       * exiting with a non-zero status code.
       * </pre>
       *
       * <code>optional string error = 1;</code>
       * @return Whether the error field is set.
       */
      public boolean hasError() {
        return ((bitField0_ & 0x00000001) != 0);
      }
      Error message.  If non-empty, code generation failed.  The plugin process
should exit with status code zero even if it reports an error in this way.
This should be used to indicate errors in .proto files which prevent the
code generator from generating correct code.  Errors which indicate a
problem in protoc itself -- such as the input CodeGeneratorRequest being
unparseable -- should be reported by writing a message to stderr and
exiting with a non-zero status code.

optional string error = 1;
Returns: The error./**
       * <pre>
       * Error message.  If non-empty, code generation failed.  The plugin process
       * should exit with status code zero even if it reports an error in this way.
       * This should be used to indicate errors in .proto files which prevent the
       * code generator from generating correct code.  Errors which indicate a
       * problem in protoc itself -- such as the input CodeGeneratorRequest being
       * unparseable -- should be reported by writing a message to stderr and
       * exiting with a non-zero status code.
       * </pre>
       *
       * <code>optional string error = 1;</code>
       * @return The error.
       */
      public java.lang.String getError() {
        java.lang.Object ref = error_;
        if (!(ref instanceof java.lang.String)) {
          com.google.protobuf.ByteString bs =
              (com.google.protobuf.ByteString) ref;
          java.lang.String s = bs.toStringUtf8();
          if (bs.isValidUtf8()) {
            error_ = s;
          }
          return s;
        } else {
          return (java.lang.String) ref;
        }
      }
      Error message.  If non-empty, code generation failed.  The plugin process
should exit with status code zero even if it reports an error in this way.
This should be used to indicate errors in .proto files which prevent the
code generator from generating correct code.  Errors which indicate a
problem in protoc itself -- such as the input CodeGeneratorRequest being
unparseable -- should be reported by writing a message to stderr and
exiting with a non-zero status code.

optional string error = 1;
Returns: The bytes for error./**
       * <pre>
       * Error message.  If non-empty, code generation failed.  The plugin process
       * should exit with status code zero even if it reports an error in this way.
       * This should be used to indicate errors in .proto files which prevent the
       * code generator from generating correct code.  Errors which indicate a
       * problem in protoc itself -- such as the input CodeGeneratorRequest being
       * unparseable -- should be reported by writing a message to stderr and
       * exiting with a non-zero status code.
       * </pre>
       *
       * <code>optional string error = 1;</code>
       * @return The bytes for error.
       */
      public com.google.protobuf.ByteString
          getErrorBytes() {
        java.lang.Object ref = error_;
        if (ref instanceof String) {
          com.google.protobuf.ByteString b = 
              com.google.protobuf.ByteString.copyFromUtf8(
                  (java.lang.String) ref);
          error_ = b;
          return b;
        } else {
          return (com.google.protobuf.ByteString) ref;
        }
      }
      Error message.  If non-empty, code generation failed.  The plugin process
should exit with status code zero even if it reports an error in this way.
This should be used to indicate errors in .proto files which prevent the
code generator from generating correct code.  Errors which indicate a
problem in protoc itself -- such as the input CodeGeneratorRequest being
unparseable -- should be reported by writing a message to stderr and
exiting with a non-zero status code.

optional string error = 1;
Params: value – The error to set.
Returns: This builder for chaining./**
       * <pre>
       * Error message.  If non-empty, code generation failed.  The plugin process
       * should exit with status code zero even if it reports an error in this way.
       * This should be used to indicate errors in .proto files which prevent the
       * code generator from generating correct code.  Errors which indicate a
       * problem in protoc itself -- such as the input CodeGeneratorRequest being
       * unparseable -- should be reported by writing a message to stderr and
       * exiting with a non-zero status code.
       * </pre>
       *
       * <code>optional string error = 1;</code>
       * @param value The error to set.
       * @return This builder for chaining.
       */
      public Builder setError(
          java.lang.String value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000001;
        error_ = value;
        onChanged();
        return this;
      }
      Error message.  If non-empty, code generation failed.  The plugin process
should exit with status code zero even if it reports an error in this way.
This should be used to indicate errors in .proto files which prevent the
code generator from generating correct code.  Errors which indicate a
problem in protoc itself -- such as the input CodeGeneratorRequest being
unparseable -- should be reported by writing a message to stderr and
exiting with a non-zero status code.

optional string error = 1;
Returns: This builder for chaining./**
       * <pre>
       * Error message.  If non-empty, code generation failed.  The plugin process
       * should exit with status code zero even if it reports an error in this way.
       * This should be used to indicate errors in .proto files which prevent the
       * code generator from generating correct code.  Errors which indicate a
       * problem in protoc itself -- such as the input CodeGeneratorRequest being
       * unparseable -- should be reported by writing a message to stderr and
       * exiting with a non-zero status code.
       * </pre>
       *
       * <code>optional string error = 1;</code>
       * @return This builder for chaining.
       */
      public Builder clearError() {
        bitField0_ = (bitField0_ & ~0x00000001);
        error_ = getDefaultInstance().getError();
        onChanged();
        return this;
      }
      Error message.  If non-empty, code generation failed.  The plugin process
should exit with status code zero even if it reports an error in this way.
This should be used to indicate errors in .proto files which prevent the
code generator from generating correct code.  Errors which indicate a
problem in protoc itself -- such as the input CodeGeneratorRequest being
unparseable -- should be reported by writing a message to stderr and
exiting with a non-zero status code.

optional string error = 1;
Params: value – The bytes for error to set.
Returns: This builder for chaining./**
       * <pre>
       * Error message.  If non-empty, code generation failed.  The plugin process
       * should exit with status code zero even if it reports an error in this way.
       * This should be used to indicate errors in .proto files which prevent the
       * code generator from generating correct code.  Errors which indicate a
       * problem in protoc itself -- such as the input CodeGeneratorRequest being
       * unparseable -- should be reported by writing a message to stderr and
       * exiting with a non-zero status code.
       * </pre>
       *
       * <code>optional string error = 1;</code>
       * @param value The bytes for error to set.
       * @return This builder for chaining.
       */
      public Builder setErrorBytes(
          com.google.protobuf.ByteString value) {
        if (value == null) {
    throw new NullPointerException();
  }
  bitField0_ |= 0x00000001;
        error_ = value;
        onChanged();
        return this;
      }

      private java.util.List<com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File> file_ =
        java.util.Collections.emptyList();
      private void ensureFileIsMutable() {
        if (!((bitField0_ & 0x00000002) != 0)) {
          file_ = new java.util.ArrayList<com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File>(file_);
          bitField0_ |= 0x00000002;
         }
      }

      private com.google.protobuf.RepeatedFieldBuilderV3<
          com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.FileOrBuilder> fileBuilder_;

      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public java.util.List<com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File> getFileList() {
        if (fileBuilder_ == null) {
          return java.util.Collections.unmodifiableList(file_);
        } else {
          return fileBuilder_.getMessageList();
        }
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public int getFileCount() {
        if (fileBuilder_ == null) {
          return file_.size();
        } else {
          return fileBuilder_.getCount();
        }
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File getFile(int index) {
        if (fileBuilder_ == null) {
          return file_.get(index);
        } else {
          return fileBuilder_.getMessage(index);
        }
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public Builder setFile(
          int index, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File value) {
        if (fileBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureFileIsMutable();
          file_.set(index, value);
          onChanged();
        } else {
          fileBuilder_.setMessage(index, value);
        }
        return this;
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public Builder setFile(
          int index, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder builderForValue) {
        if (fileBuilder_ == null) {
          ensureFileIsMutable();
          file_.set(index, builderForValue.build());
          onChanged();
        } else {
          fileBuilder_.setMessage(index, builderForValue.build());
        }
        return this;
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public Builder addFile(com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File value) {
        if (fileBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureFileIsMutable();
          file_.add(value);
          onChanged();
        } else {
          fileBuilder_.addMessage(value);
        }
        return this;
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public Builder addFile(
          int index, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File value) {
        if (fileBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureFileIsMutable();
          file_.add(index, value);
          onChanged();
        } else {
          fileBuilder_.addMessage(index, value);
        }
        return this;
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public Builder addFile(
          com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder builderForValue) {
        if (fileBuilder_ == null) {
          ensureFileIsMutable();
          file_.add(builderForValue.build());
          onChanged();
        } else {
          fileBuilder_.addMessage(builderForValue.build());
        }
        return this;
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public Builder addFile(
          int index, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder builderForValue) {
        if (fileBuilder_ == null) {
          ensureFileIsMutable();
          file_.add(index, builderForValue.build());
          onChanged();
        } else {
          fileBuilder_.addMessage(index, builderForValue.build());
        }
        return this;
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public Builder addAllFile(
          java.lang.Iterable<? extends com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File> values) {
        if (fileBuilder_ == null) {
          ensureFileIsMutable();
          com.google.protobuf.AbstractMessageLite.Builder.addAll(
              values, file_);
          onChanged();
        } else {
          fileBuilder_.addAllMessages(values);
        }
        return this;
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public Builder clearFile() {
        if (fileBuilder_ == null) {
          file_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000002);
          onChanged();
        } else {
          fileBuilder_.clear();
        }
        return this;
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public Builder removeFile(int index) {
        if (fileBuilder_ == null) {
          ensureFileIsMutable();
          file_.remove(index);
          onChanged();
        } else {
          fileBuilder_.remove(index);
        }
        return this;
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder getFileBuilder(
          int index) {
        return getFileFieldBuilder().getBuilder(index);
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.FileOrBuilder getFileOrBuilder(
          int index) {
        if (fileBuilder_ == null) {
          return file_.get(index);  } else {
          return fileBuilder_.getMessageOrBuilder(index);
        }
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public java.util.List<? extends com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.FileOrBuilder> 
           getFileOrBuilderList() {
        if (fileBuilder_ != null) {
          return fileBuilder_.getMessageOrBuilderList();
        } else {
          return java.util.Collections.unmodifiableList(file_);
        }
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder addFileBuilder() {
        return getFileFieldBuilder().addBuilder(
            com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.getDefaultInstance());
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder addFileBuilder(
          int index) {
        return getFileFieldBuilder().addBuilder(
            index, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.getDefaultInstance());
      }
      repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
/**
       * <code>repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;</code>
       */
      public java.util.List<com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder> 
           getFileBuilderList() {
        return getFileFieldBuilder().getBuilderList();
      }
      private com.google.protobuf.RepeatedFieldBuilderV3<
          com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.FileOrBuilder> 
          getFileFieldBuilder() {
        if (fileBuilder_ == null) {
          fileBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
              com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder, com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse.FileOrBuilder>(
                  file_,
                  ((bitField0_ & 0x00000002) != 0),
                  getParentForChildren(),
                  isClean());
          file_ = null;
        }
        return fileBuilder_;
      }
      @java.lang.Override
      public final Builder setUnknownFields(
          final com.google.protobuf.UnknownFieldSet unknownFields) {
        return super.setUnknownFields(unknownFields);
      }

      @java.lang.Override
      public final Builder mergeUnknownFields(
          final com.google.protobuf.UnknownFieldSet unknownFields) {
        return super.mergeUnknownFields(unknownFields);
      }


      // @@protoc_insertion_point(builder_scope:google.protobuf.compiler.CodeGeneratorResponse)
    }

    // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse)
    private static final com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse DEFAULT_INSTANCE;
    static {
      DEFAULT_INSTANCE = new com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse();
    }

    public static com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse getDefaultInstance() {
      return DEFAULT_INSTANCE;
    }

    @java.lang.Deprecated public static final com.google.protobuf.Parser<CodeGeneratorResponse>
        PARSER = new com.google.protobuf.AbstractParser<CodeGeneratorResponse>() {
      @java.lang.Override
      public CodeGeneratorResponse parsePartialFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return new CodeGeneratorResponse(input, extensionRegistry);
      }
    };

    public static com.google.protobuf.Parser<CodeGeneratorResponse> parser() {
      return PARSER;
    }

    @java.lang.Override
    public com.google.protobuf.Parser<CodeGeneratorResponse> getParserForType() {
      return PARSER;
    }

    @java.lang.Override
    public com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse getDefaultInstanceForType() {
      return DEFAULT_INSTANCE;
    }

  }

  private static final com.google.protobuf.Descriptors.Descriptor
    internal_static_google_protobuf_compiler_Version_descriptor;
  private static final 
    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
      internal_static_google_protobuf_compiler_Version_fieldAccessorTable;
  private static final com.google.protobuf.Descriptors.Descriptor
    internal_static_google_protobuf_compiler_CodeGeneratorRequest_descriptor;
  private static final 
    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
      internal_static_google_protobuf_compiler_CodeGeneratorRequest_fieldAccessorTable;
  private static final com.google.protobuf.Descriptors.Descriptor
    internal_static_google_protobuf_compiler_CodeGeneratorResponse_descriptor;
  private static final 
    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
      internal_static_google_protobuf_compiler_CodeGeneratorResponse_fieldAccessorTable;
  private static final com.google.protobuf.Descriptors.Descriptor
    internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_descriptor;
  private static final 
    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
      internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_fieldAccessorTable;

  public static com.google.protobuf.Descriptors.FileDescriptor
      getDescriptor() {
    return descriptor;
  }
  private static  com.google.protobuf.Descriptors.FileDescriptor
      descriptor;
  static {
    java.lang.String[] descriptorData = {
      "\n%google/protobuf/compiler/plugin.proto\022" +
      "\030google.protobuf.compiler\032 google/protob" +
      "uf/descriptor.proto\"F\n\007Version\022\r\n\005major\030" +
      "\001 \001(\005\022\r\n\005minor\030\002 \001(\005\022\r\n\005patch\030\003 \001(\005\022\016\n\006s" +
      "uffix\030\004 \001(\t\"\272\001\n\024CodeGeneratorRequest\022\030\n\020" +
      "file_to_generate\030\001 \003(\t\022\021\n\tparameter\030\002 \001(" +
      "\t\0228\n\nproto_file\030\017 \003(\0132$.google.protobuf." +
      "FileDescriptorProto\022;\n\020compiler_version\030" +
      "\003 \001(\0132!.google.protobuf.compiler.Version" +
      "\"\252\001\n\025CodeGeneratorResponse\022\r\n\005error\030\001 \001(" +
      "\t\022B\n\004file\030\017 \003(\01324.google.protobuf.compil" +
      "er.CodeGeneratorResponse.File\032>\n\004File\022\014\n" +
      "\004name\030\001 \001(\t\022\027\n\017insertion_point\030\002 \001(\t\022\017\n\007" +
      "content\030\017 \001(\tBg\n\034com.google.protobuf.com" +
      "pilerB\014PluginProtosZ9github.com/golang/p" +
      "rotobuf/protoc-gen-go/plugin;plugin_go"
    };
    descriptor = com.google.protobuf.Descriptors.FileDescriptor
      .internalBuildGeneratedFileFrom(descriptorData,
        new com.google.protobuf.Descriptors.FileDescriptor[] {
          com.google.protobuf.DescriptorProtos.getDescriptor(),
        });
    internal_static_google_protobuf_compiler_Version_descriptor =
      getDescriptor().getMessageTypes().get(0);
    internal_static_google_protobuf_compiler_Version_fieldAccessorTable = new
      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
        internal_static_google_protobuf_compiler_Version_descriptor,
        new java.lang.String[] { "Major", "Minor", "Patch", "Suffix", });
    internal_static_google_protobuf_compiler_CodeGeneratorRequest_descriptor =
      getDescriptor().getMessageTypes().get(1);
    internal_static_google_protobuf_compiler_CodeGeneratorRequest_fieldAccessorTable = new
      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
        internal_static_google_protobuf_compiler_CodeGeneratorRequest_descriptor,
        new java.lang.String[] { "FileToGenerate", "Parameter", "ProtoFile", "CompilerVersion", });
    internal_static_google_protobuf_compiler_CodeGeneratorResponse_descriptor =
      getDescriptor().getMessageTypes().get(2);
    internal_static_google_protobuf_compiler_CodeGeneratorResponse_fieldAccessorTable = new
      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
        internal_static_google_protobuf_compiler_CodeGeneratorResponse_descriptor,
        new java.lang.String[] { "Error", "File", });
    internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_descriptor =
      internal_static_google_protobuf_compiler_CodeGeneratorResponse_descriptor.getNestedTypes().get(0);
    internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_fieldAccessorTable = new
      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
        internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_descriptor,
        new java.lang.String[] { "Name", "InsertionPoint", "Content", });
    com.google.protobuf.DescriptorProtos.getDescriptor();
  }

  // @@protoc_insertion_point(outer_class_scope)
}
Params:	value – The major to set.
Returns:	This builder for chaining.
Params:	value – The minor to set.
Returns:	This builder for chaining.
Params:	value – The patch to set.
Returns:	This builder for chaining.
Params:	value – The suffix to set.
Returns:	This builder for chaining.
Params:	value – The bytes for suffix to set.
Returns:	This builder for chaining.
Params:	index – The index of the element to return.
Returns:	The fileToGenerate at the given index.
Params:	index – The index of the value to return.
Returns:	The bytes of the fileToGenerate at the given index.
Params:	index – The index to set the value at. value – The fileToGenerate to set.
Returns:	This builder for chaining.
Params:	value – The fileToGenerate to add.
Returns:	This builder for chaining.
Params:	values – The fileToGenerate to add.
Returns:	This builder for chaining.
Params:	value – The bytes of the fileToGenerate to add.
Returns:	This builder for chaining.
Params:	value – The parameter to set.
Returns:	This builder for chaining.
Params:	value – The bytes for parameter to set.
Returns:	This builder for chaining.
Params:	value – The name to set.
Returns:	This builder for chaining.
Params:	value – The bytes for name to set.
Returns:	This builder for chaining.
Params:	value – The insertionPoint to set.
Returns:	This builder for chaining.
Params:	value – The bytes for insertionPoint to set.
Returns:	This builder for chaining.
Params:	value – The content to set.
Returns:	This builder for chaining.
Params:	value – The bytes for content to set.
Returns:	This builder for chaining.
Params:	value – The error to set.
Returns:	This builder for chaining.
/

com.google.protobuf/ protobuf-java/ 3.10.0/ com/google/protobuf/compiler/PluginProtos.java
