Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
* 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;
*/
public Builder setSuffixBytes(
io.prestosql.orc.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
bitField0_ |= 0x00000008;
suffix_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final io.prestosql.orc.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFields(unknownFields);
}
public final Builder mergeUnknownFields(
final io.prestosql.orc.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 io.prestosql.orc.protobuf.compiler.PluginProtos.Version DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new io.prestosql.orc.protobuf.compiler.PluginProtos.Version();
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.Version getDefaultInstance() {
return DEFAULT_INSTANCE;
}
@java.lang.Deprecated public static final io.prestosql.orc.protobuf.Parser
PARSER = new io.prestosql.orc.protobuf.AbstractParser() {
public Version parsePartialFrom(
io.prestosql.orc.protobuf.CodedInputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return new Version(input, extensionRegistry);
}
};
public static io.prestosql.orc.protobuf.Parser parser() {
return PARSER;
}
@java.lang.Override
public io.prestosql.orc.protobuf.Parser getParserForType() {
return PARSER;
}
public io.prestosql.orc.protobuf.compiler.PluginProtos.Version getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface CodeGeneratorRequestOrBuilder extends
// @@protoc_insertion_point(interface_extends:google.protobuf.compiler.CodeGeneratorRequest)
io.prestosql.orc.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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
* An encoded CodeGeneratorRequest is written to the plugin's stdin.
*
*
* Protobuf type {@code google.protobuf.compiler.CodeGeneratorRequest}
*/
public static final class CodeGeneratorRequest extends
io.prestosql.orc.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:google.protobuf.compiler.CodeGeneratorRequest)
CodeGeneratorRequestOrBuilder {
// Use CodeGeneratorRequest.newBuilder() to construct.
private CodeGeneratorRequest(io.prestosql.orc.protobuf.GeneratedMessageV3.Builder builder) {
super(builder);
}
private CodeGeneratorRequest() {
fileToGenerate_ = io.prestosql.orc.protobuf.LazyStringArrayList.EMPTY;
parameter_ = "";
protoFile_ = java.util.Collections.emptyList();
}
@java.lang.Override
public final io.prestosql.orc.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private CodeGeneratorRequest(
io.prestosql.orc.protobuf.CodedInputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
io.prestosql.orc.protobuf.UnknownFieldSet.Builder unknownFields =
io.prestosql.orc.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownField(input, unknownFields,
extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
io.prestosql.orc.protobuf.ByteString bs = input.readBytes();
if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
fileToGenerate_ = new io.prestosql.orc.protobuf.LazyStringArrayList();
mutable_bitField0_ |= 0x00000001;
}
fileToGenerate_.add(bs);
break;
}
case 18: {
io.prestosql.orc.protobuf.ByteString bs = input.readBytes();
bitField0_ |= 0x00000001;
parameter_ = bs;
break;
}
case 26: {
io.prestosql.orc.protobuf.compiler.PluginProtos.Version.Builder subBuilder = null;
if (((bitField0_ & 0x00000002) == 0x00000002)) {
subBuilder = compilerVersion_.toBuilder();
}
compilerVersion_ = input.readMessage(io.prestosql.orc.protobuf.compiler.PluginProtos.Version.PARSER, extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(compilerVersion_);
compilerVersion_ = subBuilder.buildPartial();
}
bitField0_ |= 0x00000002;
break;
}
case 122: {
if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
protoFile_ = new java.util.ArrayList();
mutable_bitField0_ |= 0x00000004;
}
protoFile_.add(
input.readMessage(io.prestosql.orc.protobuf.DescriptorProtos.FileDescriptorProto.PARSER, extensionRegistry));
break;
}
}
}
} catch (io.prestosql.orc.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new io.prestosql.orc.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
fileToGenerate_ = fileToGenerate_.getUnmodifiableView();
}
if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
protoFile_ = java.util.Collections.unmodifiableList(protoFile_);
}
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final io.prestosql.orc.protobuf.Descriptors.Descriptor
getDescriptor() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorRequest_descriptor;
}
protected io.prestosql.orc.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorRequest_fieldAccessorTable
.ensureFieldAccessorsInitialized(
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest.class, io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest.Builder.class);
}
private int bitField0_;
public static final int FILE_TO_GENERATE_FIELD_NUMBER = 1;
private io.prestosql.orc.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.
*
* 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;
*/
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.
*
* 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;
*/
public io.prestosql.orc.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.
*
* The generator parameter passed on the command-line.
*
*
* optional string parameter = 2;
*/
public io.prestosql.orc.protobuf.ByteString
getParameterBytes() {
java.lang.Object ref = parameter_;
if (ref instanceof java.lang.String) {
io.prestosql.orc.protobuf.ByteString b =
io.prestosql.orc.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
parameter_ = b;
return b;
} else {
return (io.prestosql.orc.protobuf.ByteString) ref;
}
}
public static final int PROTO_FILE_FIELD_NUMBER = 15;
private java.util.List 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.
*
* 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.
*
* 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.
*
*
* repeated .google.protobuf.FileDescriptorProto proto_file = 15;
*/
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.
*
* 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.
*
*
* repeated .google.protobuf.FileDescriptorProto proto_file = 15;
*/
public io.prestosql.orc.protobuf.DescriptorProtos.FileDescriptorProtoOrBuilder getProtoFileOrBuilder(
int index) {
return protoFile_.get(index);
}
public static final int COMPILER_VERSION_FIELD_NUMBER = 3;
private io.prestosql.orc.protobuf.compiler.PluginProtos.Version compilerVersion_;
/**
*
*
* optional .google.protobuf.compiler.Version compiler_version = 3;
*/
public io.prestosql.orc.protobuf.compiler.PluginProtos.VersionOrBuilder getCompilerVersionOrBuilder() {
return compilerVersion_ == null ? io.prestosql.orc.protobuf.compiler.PluginProtos.Version.getDefaultInstance() : compilerVersion_;
}
private byte memoizedIsInitialized = -1;
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;
}
public void writeTo(io.prestosql.orc.protobuf.CodedOutputStream output)
throws java.io.IOException {
for (int i = 0; i < fileToGenerate_.size(); i++) {
io.prestosql.orc.protobuf.GeneratedMessageV3.writeString(output, 1, fileToGenerate_.getRaw(i));
}
if (((bitField0_ & 0x00000001) == 0x00000001)) {
io.prestosql.orc.protobuf.GeneratedMessageV3.writeString(output, 2, parameter_);
}
if (((bitField0_ & 0x00000002) == 0x00000002)) {
output.writeMessage(3, getCompilerVersion());
}
for (int i = 0; i < protoFile_.size(); i++) {
output.writeMessage(15, protoFile_.get(i));
}
unknownFields.writeTo(output);
}
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) == 0x00000001)) {
size += io.prestosql.orc.protobuf.GeneratedMessageV3.computeStringSize(2, parameter_);
}
if (((bitField0_ & 0x00000002) == 0x00000002)) {
size += io.prestosql.orc.protobuf.CodedOutputStream
.computeMessageSize(3, getCompilerVersion());
}
for (int i = 0; i < protoFile_.size(); i++) {
size += io.prestosql.orc.protobuf.CodedOutputStream
.computeMessageSize(15, protoFile_.get(i));
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest)) {
return super.equals(obj);
}
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest other = (io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest) obj;
boolean result = true;
result = result && getFileToGenerateList()
.equals(other.getFileToGenerateList());
result = result && (hasParameter() == other.hasParameter());
if (hasParameter()) {
result = result && getParameter()
.equals(other.getParameter());
}
result = result && getProtoFileList()
.equals(other.getProtoFileList());
result = result && (hasCompilerVersion() == other.hasCompilerVersion());
if (hasCompilerVersion()) {
result = result && getCompilerVersion()
.equals(other.getCompilerVersion());
}
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@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 io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
io.prestosql.orc.protobuf.ByteString data)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
io.prestosql.orc.protobuf.ByteString data,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(byte[] data)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
byte[] data,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(java.io.InputStream input)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
java.io.InputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseDelimitedFrom(
java.io.InputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
io.prestosql.orc.protobuf.CodedInputStream input)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest parseFrom(
io.prestosql.orc.protobuf.CodedInputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
io.prestosql.orc.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
*
* An encoded CodeGeneratorRequest is written to the plugin's stdin.
*
*
* Protobuf type {@code google.protobuf.compiler.CodeGeneratorRequest}
*/
public static final class Builder extends
io.prestosql.orc.protobuf.GeneratedMessageV3.Builder implements
// @@protoc_insertion_point(builder_implements:google.protobuf.compiler.CodeGeneratorRequest)
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequestOrBuilder {
public static final io.prestosql.orc.protobuf.Descriptors.Descriptor
getDescriptor() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorRequest_descriptor;
}
protected io.prestosql.orc.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorRequest_fieldAccessorTable
.ensureFieldAccessorsInitialized(
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest.class, io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest.Builder.class);
}
// Construct using io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
io.prestosql.orc.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (io.prestosql.orc.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
getProtoFileFieldBuilder();
getCompilerVersionFieldBuilder();
}
}
public Builder clear() {
super.clear();
fileToGenerate_ = io.prestosql.orc.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;
}
public io.prestosql.orc.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorRequest_descriptor;
}
public io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest getDefaultInstanceForType() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest.getDefaultInstance();
}
public io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest build() {
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest buildPartial() {
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest result = new io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest(this);
int from_bitField0_ = bitField0_;
int to_bitField0_ = 0;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
fileToGenerate_ = fileToGenerate_.getUnmodifiableView();
bitField0_ = (bitField0_ & ~0x00000001);
}
result.fileToGenerate_ = fileToGenerate_;
if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
to_bitField0_ |= 0x00000001;
}
result.parameter_ = parameter_;
if (protoFileBuilder_ == null) {
if (((bitField0_ & 0x00000004) == 0x00000004)) {
protoFile_ = java.util.Collections.unmodifiableList(protoFile_);
bitField0_ = (bitField0_ & ~0x00000004);
}
result.protoFile_ = protoFile_;
} else {
result.protoFile_ = protoFileBuilder_.build();
}
if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
to_bitField0_ |= 0x00000002;
}
if (compilerVersionBuilder_ == null) {
result.compilerVersion_ = compilerVersion_;
} else {
result.compilerVersion_ = compilerVersionBuilder_.build();
}
result.bitField0_ = to_bitField0_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
io.prestosql.orc.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
io.prestosql.orc.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
io.prestosql.orc.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
io.prestosql.orc.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
io.prestosql.orc.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(io.prestosql.orc.protobuf.Message other) {
if (other instanceof io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest) {
return mergeFrom((io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest other) {
if (other == io.prestosql.orc.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_ =
io.prestosql.orc.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
getProtoFileFieldBuilder() : null;
} else {
protoFileBuilder_.addAllMessages(other.protoFile_);
}
}
}
if (other.hasCompilerVersion()) {
mergeCompilerVersion(other.getCompilerVersion());
}
this.mergeUnknownFields(other.unknownFields);
onChanged();
return this;
}
public final boolean isInitialized() {
for (int i = 0; i < getProtoFileCount(); i++) {
if (!getProtoFile(i).isInitialized()) {
return false;
}
}
return true;
}
public Builder mergeFrom(
io.prestosql.orc.protobuf.CodedInputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (io.prestosql.orc.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
private int bitField0_;
private io.prestosql.orc.protobuf.LazyStringList fileToGenerate_ = io.prestosql.orc.protobuf.LazyStringArrayList.EMPTY;
private void ensureFileToGenerateIsMutable() {
if (!((bitField0_ & 0x00000001) == 0x00000001)) {
fileToGenerate_ = new io.prestosql.orc.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.
*
* 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;
*/
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.
*
* 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.
*
* 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;
*/
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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
*
* repeated .google.protobuf.FileDescriptorProto proto_file = 15;
*/
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.
*
* 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.
*
*
* repeated .google.protobuf.FileDescriptorProto proto_file = 15;
*/
public Builder setProtoFile(
int index, io.prestosql.orc.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.
*
* 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.
*
*
* repeated .google.protobuf.FileDescriptorProto proto_file = 15;
*/
public Builder addProtoFile(io.prestosql.orc.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.
*
*
* repeated .google.protobuf.FileDescriptorProto proto_file = 15;
*/
public Builder addProtoFile(
int index, io.prestosql.orc.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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
*
* repeated .google.protobuf.FileDescriptorProto proto_file = 15;
*/
public io.prestosql.orc.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.
*
*
* repeated .google.protobuf.FileDescriptorProto proto_file = 15;
*/
public io.prestosql.orc.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.
*
* 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.
*
* 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.
*
* 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.
*
*
* optional .google.protobuf.compiler.Version compiler_version = 3;
*/
private io.prestosql.orc.protobuf.SingleFieldBuilderV3<
io.prestosql.orc.protobuf.compiler.PluginProtos.Version, io.prestosql.orc.protobuf.compiler.PluginProtos.Version.Builder, io.prestosql.orc.protobuf.compiler.PluginProtos.VersionOrBuilder>
getCompilerVersionFieldBuilder() {
if (compilerVersionBuilder_ == null) {
compilerVersionBuilder_ = new io.prestosql.orc.protobuf.SingleFieldBuilderV3<
io.prestosql.orc.protobuf.compiler.PluginProtos.Version, io.prestosql.orc.protobuf.compiler.PluginProtos.Version.Builder, io.prestosql.orc.protobuf.compiler.PluginProtos.VersionOrBuilder>(
getCompilerVersion(),
getParentForChildren(),
isClean());
compilerVersion_ = null;
}
return compilerVersionBuilder_;
}
public final Builder setUnknownFields(
final io.prestosql.orc.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFields(unknownFields);
}
public final Builder mergeUnknownFields(
final io.prestosql.orc.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 io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest();
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest getDefaultInstance() {
return DEFAULT_INSTANCE;
}
@java.lang.Deprecated public static final io.prestosql.orc.protobuf.Parser
PARSER = new io.prestosql.orc.protobuf.AbstractParser() {
public CodeGeneratorRequest parsePartialFrom(
io.prestosql.orc.protobuf.CodedInputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return new CodeGeneratorRequest(input, extensionRegistry);
}
};
public static io.prestosql.orc.protobuf.Parser parser() {
return PARSER;
}
@java.lang.Override
public io.prestosql.orc.protobuf.Parser getParserForType() {
return PARSER;
}
public io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorRequest getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
public interface CodeGeneratorResponseOrBuilder extends
// @@protoc_insertion_point(interface_extends:google.protobuf.compiler.CodeGeneratorResponse)
io.prestosql.orc.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.
*
* 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.
*
* 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.
*
* The plugin writes an encoded CodeGeneratorResponse to stdout.
*
*
* Protobuf type {@code google.protobuf.compiler.CodeGeneratorResponse}
*/
public static final class CodeGeneratorResponse extends
io.prestosql.orc.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:google.protobuf.compiler.CodeGeneratorResponse)
CodeGeneratorResponseOrBuilder {
// Use CodeGeneratorResponse.newBuilder() to construct.
private CodeGeneratorResponse(io.prestosql.orc.protobuf.GeneratedMessageV3.Builder builder) {
super(builder);
}
private CodeGeneratorResponse() {
error_ = "";
file_ = java.util.Collections.emptyList();
}
@java.lang.Override
public final io.prestosql.orc.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private CodeGeneratorResponse(
io.prestosql.orc.protobuf.CodedInputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
io.prestosql.orc.protobuf.UnknownFieldSet.Builder unknownFields =
io.prestosql.orc.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownField(input, unknownFields,
extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
io.prestosql.orc.protobuf.ByteString bs = input.readBytes();
bitField0_ |= 0x00000001;
error_ = bs;
break;
}
case 122: {
if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
file_ = new java.util.ArrayList();
mutable_bitField0_ |= 0x00000002;
}
file_.add(
input.readMessage(io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.PARSER, extensionRegistry));
break;
}
}
}
} catch (io.prestosql.orc.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new io.prestosql.orc.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
file_ = java.util.Collections.unmodifiableList(file_);
}
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final io.prestosql.orc.protobuf.Descriptors.Descriptor
getDescriptor() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_descriptor;
}
protected io.prestosql.orc.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_fieldAccessorTable
.ensureFieldAccessorsInitialized(
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.class, io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.Builder.class);
}
public interface FileOrBuilder extends
// @@protoc_insertion_point(interface_extends:google.protobuf.compiler.CodeGeneratorResponse.File)
io.prestosql.orc.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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
*
* Protobuf type {@code google.protobuf.compiler.CodeGeneratorResponse.File}
*/
public static final class File extends
io.prestosql.orc.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:google.protobuf.compiler.CodeGeneratorResponse.File)
FileOrBuilder {
// Use File.newBuilder() to construct.
private File(io.prestosql.orc.protobuf.GeneratedMessageV3.Builder builder) {
super(builder);
}
private File() {
name_ = "";
insertionPoint_ = "";
content_ = "";
}
@java.lang.Override
public final io.prestosql.orc.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private File(
io.prestosql.orc.protobuf.CodedInputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
this();
int mutable_bitField0_ = 0;
io.prestosql.orc.protobuf.UnknownFieldSet.Builder unknownFields =
io.prestosql.orc.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownField(input, unknownFields,
extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
io.prestosql.orc.protobuf.ByteString bs = input.readBytes();
bitField0_ |= 0x00000001;
name_ = bs;
break;
}
case 18: {
io.prestosql.orc.protobuf.ByteString bs = input.readBytes();
bitField0_ |= 0x00000002;
insertionPoint_ = bs;
break;
}
case 122: {
io.prestosql.orc.protobuf.ByteString bs = input.readBytes();
bitField0_ |= 0x00000004;
content_ = bs;
break;
}
}
}
} catch (io.prestosql.orc.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new io.prestosql.orc.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final io.prestosql.orc.protobuf.Descriptors.Descriptor
getDescriptor() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_descriptor;
}
protected io.prestosql.orc.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_fieldAccessorTable
.ensureFieldAccessorsInitialized(
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.class, io.prestosql.orc.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.
*
* 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;
*/
public java.lang.String getName() {
java.lang.Object ref = name_;
if (ref instanceof java.lang.String) {
return (java.lang.String) ref;
} else {
io.prestosql.orc.protobuf.ByteString bs =
(io.prestosql.orc.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;
*/
public io.prestosql.orc.protobuf.ByteString
getNameBytes() {
java.lang.Object ref = name_;
if (ref instanceof java.lang.String) {
io.prestosql.orc.protobuf.ByteString b =
io.prestosql.orc.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
name_ = b;
return b;
} else {
return (io.prestosql.orc.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.
*
* 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.
*
* 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;
*/
public io.prestosql.orc.protobuf.ByteString
getInsertionPointBytes() {
java.lang.Object ref = insertionPoint_;
if (ref instanceof java.lang.String) {
io.prestosql.orc.protobuf.ByteString b =
io.prestosql.orc.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
insertionPoint_ = b;
return b;
} else {
return (io.prestosql.orc.protobuf.ByteString) ref;
}
}
public static final int CONTENT_FIELD_NUMBER = 15;
private volatile java.lang.Object content_;
/**
*
*
* optional string content = 15;
*/
public io.prestosql.orc.protobuf.ByteString
getContentBytes() {
java.lang.Object ref = content_;
if (ref instanceof java.lang.String) {
io.prestosql.orc.protobuf.ByteString b =
io.prestosql.orc.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
content_ = b;
return b;
} else {
return (io.prestosql.orc.protobuf.ByteString) ref;
}
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(io.prestosql.orc.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (((bitField0_ & 0x00000001) == 0x00000001)) {
io.prestosql.orc.protobuf.GeneratedMessageV3.writeString(output, 1, name_);
}
if (((bitField0_ & 0x00000002) == 0x00000002)) {
io.prestosql.orc.protobuf.GeneratedMessageV3.writeString(output, 2, insertionPoint_);
}
if (((bitField0_ & 0x00000004) == 0x00000004)) {
io.prestosql.orc.protobuf.GeneratedMessageV3.writeString(output, 15, content_);
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
size += io.prestosql.orc.protobuf.GeneratedMessageV3.computeStringSize(1, name_);
}
if (((bitField0_ & 0x00000002) == 0x00000002)) {
size += io.prestosql.orc.protobuf.GeneratedMessageV3.computeStringSize(2, insertionPoint_);
}
if (((bitField0_ & 0x00000004) == 0x00000004)) {
size += io.prestosql.orc.protobuf.GeneratedMessageV3.computeStringSize(15, content_);
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File)) {
return super.equals(obj);
}
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File other = (io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File) obj;
boolean result = true;
result = result && (hasName() == other.hasName());
if (hasName()) {
result = result && getName()
.equals(other.getName());
}
result = result && (hasInsertionPoint() == other.hasInsertionPoint());
if (hasInsertionPoint()) {
result = result && getInsertionPoint()
.equals(other.getInsertionPoint());
}
result = result && (hasContent() == other.hasContent());
if (hasContent()) {
result = result && getContent()
.equals(other.getContent());
}
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@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 io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
io.prestosql.orc.protobuf.ByteString data)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
io.prestosql.orc.protobuf.ByteString data,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(byte[] data)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
byte[] data,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(java.io.InputStream input)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
java.io.InputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseDelimitedFrom(
java.io.InputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
io.prestosql.orc.protobuf.CodedInputStream input)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parseFrom(
io.prestosql.orc.protobuf.CodedInputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
io.prestosql.orc.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
*
* Represents a single generated file.
*
*
* Protobuf type {@code google.protobuf.compiler.CodeGeneratorResponse.File}
*/
public static final class Builder extends
io.prestosql.orc.protobuf.GeneratedMessageV3.Builder implements
// @@protoc_insertion_point(builder_implements:google.protobuf.compiler.CodeGeneratorResponse.File)
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.FileOrBuilder {
public static final io.prestosql.orc.protobuf.Descriptors.Descriptor
getDescriptor() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_descriptor;
}
protected io.prestosql.orc.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_fieldAccessorTable
.ensureFieldAccessorsInitialized(
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.class, io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.Builder.class);
}
// Construct using io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
io.prestosql.orc.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (io.prestosql.orc.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
public Builder clear() {
super.clear();
name_ = "";
bitField0_ = (bitField0_ & ~0x00000001);
insertionPoint_ = "";
bitField0_ = (bitField0_ & ~0x00000002);
content_ = "";
bitField0_ = (bitField0_ & ~0x00000004);
return this;
}
public io.prestosql.orc.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_File_descriptor;
}
public io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File getDefaultInstanceForType() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File.getDefaultInstance();
}
public io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File build() {
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File buildPartial() {
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File result = new io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File(this);
int from_bitField0_ = bitField0_;
int to_bitField0_ = 0;
if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
to_bitField0_ |= 0x00000001;
}
result.name_ = name_;
if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
to_bitField0_ |= 0x00000002;
}
result.insertionPoint_ = insertionPoint_;
if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
to_bitField0_ |= 0x00000004;
}
result.content_ = content_;
result.bitField0_ = to_bitField0_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
io.prestosql.orc.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
io.prestosql.orc.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
io.prestosql.orc.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
io.prestosql.orc.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
io.prestosql.orc.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(io.prestosql.orc.protobuf.Message other) {
if (other instanceof io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File) {
return mergeFrom((io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File other) {
if (other == io.prestosql.orc.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;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
io.prestosql.orc.protobuf.CodedInputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (io.prestosql.orc.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (io.prestosql.orc.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.
*
* 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;
*/
public java.lang.String getName() {
java.lang.Object ref = name_;
if (!(ref instanceof java.lang.String)) {
io.prestosql.orc.protobuf.ByteString bs =
(io.prestosql.orc.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.
*
* 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;
*/
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.
*
* 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;
*/
public Builder setNameBytes(
io.prestosql.orc.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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
* 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 content = 15;
*/
public Builder setContentBytes(
io.prestosql.orc.protobuf.ByteString value) {
if (value == null) {
throw new NullPointerException();
}
bitField0_ |= 0x00000004;
content_ = value;
onChanged();
return this;
}
public final Builder setUnknownFields(
final io.prestosql.orc.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFields(unknownFields);
}
public final Builder mergeUnknownFields(
final io.prestosql.orc.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 io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File();
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File getDefaultInstance() {
return DEFAULT_INSTANCE;
}
@java.lang.Deprecated public static final io.prestosql.orc.protobuf.Parser
PARSER = new io.prestosql.orc.protobuf.AbstractParser() {
public File parsePartialFrom(
io.prestosql.orc.protobuf.CodedInputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return new File(input, extensionRegistry);
}
};
public static io.prestosql.orc.protobuf.Parser parser() {
return PARSER;
}
@java.lang.Override
public io.prestosql.orc.protobuf.Parser getParserForType() {
return PARSER;
}
public io.prestosql.orc.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.
*
* 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.
*
* 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;
*/
public io.prestosql.orc.protobuf.ByteString
getErrorBytes() {
java.lang.Object ref = error_;
if (ref instanceof java.lang.String) {
io.prestosql.orc.protobuf.ByteString b =
io.prestosql.orc.protobuf.ByteString.copyFromUtf8(
(java.lang.String) ref);
error_ = b;
return b;
} else {
return (io.prestosql.orc.protobuf.ByteString) ref;
}
}
public static final int FILE_FIELD_NUMBER = 15;
private java.util.List file_;
/**
* repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
*/
public java.util.List getFileList() {
return file_;
}
/**
* repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
*/
public java.util.List
getFileOrBuilderList() {
return file_;
}
/**
* repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
*/
public int getFileCount() {
return file_.size();
}
/**
* repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
*/
public io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.File getFile(int index) {
return file_.get(index);
}
/**
* repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
*/
public io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.FileOrBuilder getFileOrBuilder(
int index) {
return file_.get(index);
}
private byte memoizedIsInitialized = -1;
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(io.prestosql.orc.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (((bitField0_ & 0x00000001) == 0x00000001)) {
io.prestosql.orc.protobuf.GeneratedMessageV3.writeString(output, 1, error_);
}
for (int i = 0; i < file_.size(); i++) {
output.writeMessage(15, file_.get(i));
}
unknownFields.writeTo(output);
}
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
size += io.prestosql.orc.protobuf.GeneratedMessageV3.computeStringSize(1, error_);
}
for (int i = 0; i < file_.size(); i++) {
size += io.prestosql.orc.protobuf.CodedOutputStream
.computeMessageSize(15, file_.get(i));
}
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
private static final long serialVersionUID = 0L;
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse)) {
return super.equals(obj);
}
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse other = (io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse) obj;
boolean result = true;
result = result && (hasError() == other.hasError());
if (hasError()) {
result = result && getError()
.equals(other.getError());
}
result = result && getFileList()
.equals(other.getFileList());
result = result && unknownFields.equals(other.unknownFields);
return result;
}
@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 io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
io.prestosql.orc.protobuf.ByteString data)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
io.prestosql.orc.protobuf.ByteString data,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(byte[] data)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
byte[] data,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws io.prestosql.orc.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(java.io.InputStream input)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
java.io.InputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseDelimitedFrom(
java.io.InputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
io.prestosql.orc.protobuf.CodedInputStream input)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse parseFrom(
io.prestosql.orc.protobuf.CodedInputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return io.prestosql.orc.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
io.prestosql.orc.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
*
* The plugin writes an encoded CodeGeneratorResponse to stdout.
*
*
* Protobuf type {@code google.protobuf.compiler.CodeGeneratorResponse}
*/
public static final class Builder extends
io.prestosql.orc.protobuf.GeneratedMessageV3.Builder implements
// @@protoc_insertion_point(builder_implements:google.protobuf.compiler.CodeGeneratorResponse)
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponseOrBuilder {
public static final io.prestosql.orc.protobuf.Descriptors.Descriptor
getDescriptor() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_descriptor;
}
protected io.prestosql.orc.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_fieldAccessorTable
.ensureFieldAccessorsInitialized(
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.class, io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.Builder.class);
}
// Construct using io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
io.prestosql.orc.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (io.prestosql.orc.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
getFileFieldBuilder();
}
}
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;
}
public io.prestosql.orc.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.internal_static_google_protobuf_compiler_CodeGeneratorResponse_descriptor;
}
public io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse getDefaultInstanceForType() {
return io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse.getDefaultInstance();
}
public io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse build() {
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
public io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse buildPartial() {
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse result = new io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse(this);
int from_bitField0_ = bitField0_;
int to_bitField0_ = 0;
if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
to_bitField0_ |= 0x00000001;
}
result.error_ = error_;
if (fileBuilder_ == null) {
if (((bitField0_ & 0x00000002) == 0x00000002)) {
file_ = java.util.Collections.unmodifiableList(file_);
bitField0_ = (bitField0_ & ~0x00000002);
}
result.file_ = file_;
} else {
result.file_ = fileBuilder_.build();
}
result.bitField0_ = to_bitField0_;
onBuilt();
return result;
}
public Builder clone() {
return (Builder) super.clone();
}
public Builder setField(
io.prestosql.orc.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.setField(field, value);
}
public Builder clearField(
io.prestosql.orc.protobuf.Descriptors.FieldDescriptor field) {
return (Builder) super.clearField(field);
}
public Builder clearOneof(
io.prestosql.orc.protobuf.Descriptors.OneofDescriptor oneof) {
return (Builder) super.clearOneof(oneof);
}
public Builder setRepeatedField(
io.prestosql.orc.protobuf.Descriptors.FieldDescriptor field,
int index, Object value) {
return (Builder) super.setRepeatedField(field, index, value);
}
public Builder addRepeatedField(
io.prestosql.orc.protobuf.Descriptors.FieldDescriptor field,
Object value) {
return (Builder) super.addRepeatedField(field, value);
}
public Builder mergeFrom(io.prestosql.orc.protobuf.Message other) {
if (other instanceof io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse) {
return mergeFrom((io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse other) {
if (other == io.prestosql.orc.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_ =
io.prestosql.orc.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
getFileFieldBuilder() : null;
} else {
fileBuilder_.addAllMessages(other.file_);
}
}
}
this.mergeUnknownFields(other.unknownFields);
onChanged();
return this;
}
public final boolean isInitialized() {
return true;
}
public Builder mergeFrom(
io.prestosql.orc.protobuf.CodedInputStream input,
io.prestosql.orc.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
io.prestosql.orc.protobuf.compiler.PluginProtos.CodeGeneratorResponse parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (io.prestosql.orc.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (io.prestosql.orc.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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
* 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.
*
