cmd/bpa-operator/vendor/github.com/golang/protobuf/protoc-gen-go/plugin/plugin.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/protobuf/compiler/plugin.proto
   3
   4 /*
   5 Package plugin_go is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         google/protobuf/compiler/plugin.proto
   9
  10 It has these top-level messages:
  11         Version
  12         CodeGeneratorRequest
  13         CodeGeneratorResponse
  14 */
  15 package plugin_go
  16
  17 import proto "github.com/golang/protobuf/proto"
  18 import fmt "fmt"
  19 import math "math"
  20 import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
  21
  22 // Reference imports to suppress errors if they are not otherwise used.
  23 var _ = proto.Marshal
  24 var _ = fmt.Errorf
  25 var _ = math.Inf
  26
  27 // This is a compile-time assertion to ensure that this generated file
  28 // is compatible with the proto package it is being compiled against.
  29 // A compilation error at this line likely means your copy of the
  30 // proto package needs to be updated.
  31 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  32
  33 // The version number of protocol compiler.
  34 type Version struct {
  35         Major *int32 `protobuf:"varint,1,opt,name=major" json:"major,omitempty"`
  36         Minor *int32 `protobuf:"varint,2,opt,name=minor" json:"minor,omitempty"`
  37         Patch *int32 `protobuf:"varint,3,opt,name=patch" json:"patch,omitempty"`
  38         // A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
  39         // be empty for mainline stable releases.
  40         Suffix               *string  `protobuf:"bytes,4,opt,name=suffix" json:"suffix,omitempty"`
  41         XXX_NoUnkeyedLiteral struct{} `json:"-"`
  42         XXX_unrecognized     []byte   `json:"-"`
  43         XXX_sizecache        int32    `json:"-"`
  44 }
  45
  46 func (m *Version) Reset()                    { *m = Version{} }
  47 func (m *Version) String() string            { return proto.CompactTextString(m) }
  48 func (*Version) ProtoMessage()               {}
  49 func (*Version) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  50 func (m *Version) Unmarshal(b []byte) error {
  51         return xxx_messageInfo_Version.Unmarshal(m, b)
  52 }
  53 func (m *Version) Marshal(b []byte, deterministic bool) ([]byte, error) {
  54         return xxx_messageInfo_Version.Marshal(b, m, deterministic)
  55 }
  56 func (dst *Version) XXX_Merge(src proto.Message) {
  57         xxx_messageInfo_Version.Merge(dst, src)
  58 }
  59 func (m *Version) XXX_Size() int {
  60         return xxx_messageInfo_Version.Size(m)
  61 }
  62 func (m *Version) XXX_DiscardUnknown() {
  63         xxx_messageInfo_Version.DiscardUnknown(m)
  64 }
  65
  66 var xxx_messageInfo_Version proto.InternalMessageInfo
  67
  68 func (m *Version) GetMajor() int32 {
  69         if m != nil && m.Major != nil {
  70                 return *m.Major
  71         }
  72         return 0
  73 }
  74
  75 func (m *Version) GetMinor() int32 {
  76         if m != nil && m.Minor != nil {
  77                 return *m.Minor
  78         }
  79         return 0
  80 }
  81
  82 func (m *Version) GetPatch() int32 {
  83         if m != nil && m.Patch != nil {
  84                 return *m.Patch
  85         }
  86         return 0
  87 }
  88
  89 func (m *Version) GetSuffix() string {
  90         if m != nil && m.Suffix != nil {
  91                 return *m.Suffix
  92         }
  93         return ""
  94 }
  95
  96 // An encoded CodeGeneratorRequest is written to the plugin's stdin.
  97 type CodeGeneratorRequest struct {
  98         // The .proto files that were explicitly listed on the command-line.  The
  99         // code generator should generate code only for these files.  Each file's
 100         // descriptor will be included in proto_file, below.
 101         FileToGenerate []string `protobuf:"bytes,1,rep,name=file_to_generate,json=fileToGenerate" json:"file_to_generate,omitempty"`
 102         // The generator parameter passed on the command-line.
 103         Parameter *string `protobuf:"bytes,2,opt,name=parameter" json:"parameter,omitempty"`
 104         // FileDescriptorProtos for all files in files_to_generate and everything
 105         // they import.  The files will appear in topological order, so each file
 106         // appears before any file that imports it.
 107         //
 108         // protoc guarantees that all proto_files will be written after
 109         // the fields above, even though this is not technically guaranteed by the
 110         // protobuf wire format.  This theoretically could allow a plugin to stream
 111         // in the FileDescriptorProtos and handle them one by one rather than read
 112         // the entire set into memory at once.  However, as of this writing, this
 113         // is not similarly optimized on protoc's end -- it will store all fields in
 114         // memory at once before sending them to the plugin.
 115         //
 116         // Type names of fields and extensions in the FileDescriptorProto are always
 117         // fully qualified.
 118         ProtoFile []*google_protobuf.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file,json=protoFile" json:"proto_file,omitempty"`
 119         // The version number of protocol compiler.
 120         CompilerVersion      *Version `protobuf:"bytes,3,opt,name=compiler_version,json=compilerVersion" json:"compiler_version,omitempty"`
 121         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 122         XXX_unrecognized     []byte   `json:"-"`
 123         XXX_sizecache        int32    `json:"-"`
 124 }
 125
 126 func (m *CodeGeneratorRequest) Reset()                    { *m = CodeGeneratorRequest{} }
 127 func (m *CodeGeneratorRequest) String() string            { return proto.CompactTextString(m) }
 128 func (*CodeGeneratorRequest) ProtoMessage()               {}
 129 func (*CodeGeneratorRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 130 func (m *CodeGeneratorRequest) Unmarshal(b []byte) error {
 131         return xxx_messageInfo_CodeGeneratorRequest.Unmarshal(m, b)
 132 }
 133 func (m *CodeGeneratorRequest) Marshal(b []byte, deterministic bool) ([]byte, error) {
 134         return xxx_messageInfo_CodeGeneratorRequest.Marshal(b, m, deterministic)
 135 }
 136 func (dst *CodeGeneratorRequest) XXX_Merge(src proto.Message) {
 137         xxx_messageInfo_CodeGeneratorRequest.Merge(dst, src)
 138 }
 139 func (m *CodeGeneratorRequest) XXX_Size() int {
 140         return xxx_messageInfo_CodeGeneratorRequest.Size(m)
 141 }
 142 func (m *CodeGeneratorRequest) XXX_DiscardUnknown() {
 143         xxx_messageInfo_CodeGeneratorRequest.DiscardUnknown(m)
 144 }
 145
 146 var xxx_messageInfo_CodeGeneratorRequest proto.InternalMessageInfo
 147
 148 func (m *CodeGeneratorRequest) GetFileToGenerate() []string {
 149         if m != nil {
 150                 return m.FileToGenerate
 151         }
 152         return nil
 153 }
 154
 155 func (m *CodeGeneratorRequest) GetParameter() string {
 156         if m != nil && m.Parameter != nil {
 157                 return *m.Parameter
 158         }
 159         return ""
 160 }
 161
 162 func (m *CodeGeneratorRequest) GetProtoFile() []*google_protobuf.FileDescriptorProto {
 163         if m != nil {
 164                 return m.ProtoFile
 165         }
 166         return nil
 167 }
 168
 169 func (m *CodeGeneratorRequest) GetCompilerVersion() *Version {
 170         if m != nil {
 171                 return m.CompilerVersion
 172         }
 173         return nil
 174 }
 175
 176 // The plugin writes an encoded CodeGeneratorResponse to stdout.
 177 type CodeGeneratorResponse struct {
 178         // Error message.  If non-empty, code generation failed.  The plugin process
 179         // should exit with status code zero even if it reports an error in this way.
 180         //
 181         // This should be used to indicate errors in .proto files which prevent the
 182         // code generator from generating correct code.  Errors which indicate a
 183         // problem in protoc itself -- such as the input CodeGeneratorRequest being
 184         // unparseable -- should be reported by writing a message to stderr and
 185         // exiting with a non-zero status code.
 186         Error                *string                       `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
 187         File                 []*CodeGeneratorResponse_File `protobuf:"bytes,15,rep,name=file" json:"file,omitempty"`
 188         XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
 189         XXX_unrecognized     []byte                        `json:"-"`
 190         XXX_sizecache        int32                         `json:"-"`
 191 }
 192
 193 func (m *CodeGeneratorResponse) Reset()                    { *m = CodeGeneratorResponse{} }
 194 func (m *CodeGeneratorResponse) String() string            { return proto.CompactTextString(m) }
 195 func (*CodeGeneratorResponse) ProtoMessage()               {}
 196 func (*CodeGeneratorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 197 func (m *CodeGeneratorResponse) Unmarshal(b []byte) error {
 198         return xxx_messageInfo_CodeGeneratorResponse.Unmarshal(m, b)
 199 }
 200 func (m *CodeGeneratorResponse) Marshal(b []byte, deterministic bool) ([]byte, error) {
 201         return xxx_messageInfo_CodeGeneratorResponse.Marshal(b, m, deterministic)
 202 }
 203 func (dst *CodeGeneratorResponse) XXX_Merge(src proto.Message) {
 204         xxx_messageInfo_CodeGeneratorResponse.Merge(dst, src)
 205 }
 206 func (m *CodeGeneratorResponse) XXX_Size() int {
 207         return xxx_messageInfo_CodeGeneratorResponse.Size(m)
 208 }
 209 func (m *CodeGeneratorResponse) XXX_DiscardUnknown() {
 210         xxx_messageInfo_CodeGeneratorResponse.DiscardUnknown(m)
 211 }
 212
 213 var xxx_messageInfo_CodeGeneratorResponse proto.InternalMessageInfo
 214
 215 func (m *CodeGeneratorResponse) GetError() string {
 216         if m != nil && m.Error != nil {
 217                 return *m.Error
 218         }
 219         return ""
 220 }
 221
 222 func (m *CodeGeneratorResponse) GetFile() []*CodeGeneratorResponse_File {
 223         if m != nil {
 224                 return m.File
 225         }
 226         return nil
 227 }
 228
 229 // Represents a single generated file.
 230 type CodeGeneratorResponse_File struct {
 231         // The file name, relative to the output directory.  The name must not
 232         // contain "." or ".." components and must be relative, not be absolute (so,
 233         // the file cannot lie outside the output directory).  "/" must be used as
 234         // the path separator, not "\".
 235         //
 236         // If the name is omitted, the content will be appended to the previous
 237         // file.  This allows the generator to break large files into small chunks,
 238         // and allows the generated text to be streamed back to protoc so that large
 239         // files need not reside completely in memory at one time.  Note that as of
 240         // this writing protoc does not optimize for this -- it will read the entire
 241         // CodeGeneratorResponse before writing files to disk.
 242         Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
 243         // If non-empty, indicates that the named file should already exist, and the
 244         // content here is to be inserted into that file at a defined insertion
 245         // point.  This feature allows a code generator to extend the output
 246         // produced by another code generator.  The original generator may provide
 247         // insertion points by placing special annotations in the file that look
 248         // like:
 249         //   @@protoc_insertion_point(NAME)
 250         // The annotation can have arbitrary text before and after it on the line,
 251         // which allows it to be placed in a comment.  NAME should be replaced with
 252         // an identifier naming the point -- this is what other generators will use
 253         // as the insertion_point.  Code inserted at this point will be placed
 254         // immediately above the line containing the insertion point (thus multiple
 255         // insertions to the same point will come out in the order they were added).
 256         // The double-@ is intended to make it unlikely that the generated code
 257         // could contain things that look like insertion points by accident.
 258         //
 259         // For example, the C++ code generator places the following line in the
 260         // .pb.h files that it generates:
 261         //   // @@protoc_insertion_point(namespace_scope)
 262         // This line appears within the scope of the file's package namespace, but
 263         // outside of any particular class.  Another plugin can then specify the
 264         // insertion_point "namespace_scope" to generate additional classes or
 265         // other declarations that should be placed in this scope.
 266         //
 267         // Note that if the line containing the insertion point begins with
 268         // whitespace, the same whitespace will be added to every line of the
 269         // inserted text.  This is useful for languages like Python, where
 270         // indentation matters.  In these languages, the insertion point comment
 271         // should be indented the same amount as any inserted code will need to be
 272         // in order to work correctly in that context.
 273         //
 274         // The code generator that generates the initial file and the one which
 275         // inserts into it must both run as part of a single invocation of protoc.
 276         // Code generators are executed in the order in which they appear on the
 277         // command line.
 278         //
 279         // If |insertion_point| is present, |name| must also be present.
 280         InsertionPoint *string `protobuf:"bytes,2,opt,name=insertion_point,json=insertionPoint" json:"insertion_point,omitempty"`
 281         // The file contents.
 282         Content              *string  `protobuf:"bytes,15,opt,name=content" json:"content,omitempty"`
 283         XXX_NoUnkeyedLiteral struct{} `json:"-"`
 284         XXX_unrecognized     []byte   `json:"-"`
 285         XXX_sizecache        int32    `json:"-"`
 286 }
 287
 288 func (m *CodeGeneratorResponse_File) Reset()                    { *m = CodeGeneratorResponse_File{} }
 289 func (m *CodeGeneratorResponse_File) String() string            { return proto.CompactTextString(m) }
 290 func (*CodeGeneratorResponse_File) ProtoMessage()               {}
 291 func (*CodeGeneratorResponse_File) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
 292 func (m *CodeGeneratorResponse_File) Unmarshal(b []byte) error {
 293         return xxx_messageInfo_CodeGeneratorResponse_File.Unmarshal(m, b)
 294 }
 295 func (m *CodeGeneratorResponse_File) Marshal(b []byte, deterministic bool) ([]byte, error) {
 296         return xxx_messageInfo_CodeGeneratorResponse_File.Marshal(b, m, deterministic)
 297 }
 298 func (dst *CodeGeneratorResponse_File) XXX_Merge(src proto.Message) {
 299         xxx_messageInfo_CodeGeneratorResponse_File.Merge(dst, src)
 300 }
 301 func (m *CodeGeneratorResponse_File) XXX_Size() int {
 302         return xxx_messageInfo_CodeGeneratorResponse_File.Size(m)
 303 }
 304 func (m *CodeGeneratorResponse_File) XXX_DiscardUnknown() {
 305         xxx_messageInfo_CodeGeneratorResponse_File.DiscardUnknown(m)
 306 }
 307
 308 var xxx_messageInfo_CodeGeneratorResponse_File proto.InternalMessageInfo
 309
 310 func (m *CodeGeneratorResponse_File) GetName() string {
 311         if m != nil && m.Name != nil {
 312                 return *m.Name
 313         }
 314         return ""
 315 }
 316
 317 func (m *CodeGeneratorResponse_File) GetInsertionPoint() string {
 318         if m != nil && m.InsertionPoint != nil {
 319                 return *m.InsertionPoint
 320         }
 321         return ""
 322 }
 323
 324 func (m *CodeGeneratorResponse_File) GetContent() string {
 325         if m != nil && m.Content != nil {
 326                 return *m.Content
 327         }
 328         return ""
 329 }
 330
 331 func init() {
 332         proto.RegisterType((*Version)(nil), "google.protobuf.compiler.Version")
 333         proto.RegisterType((*CodeGeneratorRequest)(nil), "google.protobuf.compiler.CodeGeneratorRequest")
 334         proto.RegisterType((*CodeGeneratorResponse)(nil), "google.protobuf.compiler.CodeGeneratorResponse")
 335         proto.RegisterType((*CodeGeneratorResponse_File)(nil), "google.protobuf.compiler.CodeGeneratorResponse.File")
 336 }
 337
 338 func init() { proto.RegisterFile("google/protobuf/compiler/plugin.proto", fileDescriptor0) }
 339
 340 var fileDescriptor0 = []byte{
 341         // 417 bytes of a gzipped FileDescriptorProto
 342         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xcf, 0x6a, 0x14, 0x41,
 343         0x10, 0xc6, 0x19, 0x77, 0x63, 0x98, 0x8a, 0x64, 0x43, 0x13, 0xa5, 0x09, 0x39, 0x8c, 0x8b, 0xe2,
 344         0x5c, 0x32, 0x0b, 0xc1, 0x8b, 0x78, 0x4b, 0x44, 0x3d, 0x78, 0x58, 0x1a, 0xf1, 0x20, 0xc8, 0x30,
 345         0x99, 0xd4, 0x74, 0x5a, 0x66, 0xba, 0xc6, 0xee, 0x1e, 0xf1, 0x49, 0x7d, 0x0f, 0xdf, 0x40, 0xfa,
 346         0xcf, 0x24, 0xb2, 0xb8, 0xa7, 0xee, 0xef, 0x57, 0xd5, 0xd5, 0x55, 0x1f, 0x05, 0x2f, 0x25, 0x91,
 347         0xec, 0x71, 0x33, 0x1a, 0x72, 0x74, 0x33, 0x75, 0x9b, 0x96, 0x86, 0x51, 0xf5, 0x68, 0x36, 0x63,
 348         0x3f, 0x49, 0xa5, 0xab, 0x10, 0x60, 0x3c, 0xa6, 0x55, 0x73, 0x5a, 0x35, 0xa7, 0x9d, 0x15, 0xbb,
 349         0x05, 0x6e, 0xd1, 0xb6, 0x46, 0x8d, 0x8e, 0x4c, 0xcc, 0x5e, 0xb7, 0x70, 0xf8, 0x05, 0x8d, 0x55,
 350         0xa4, 0xd9, 0x29, 0x1c, 0x0c, 0xcd, 0x77, 0x32, 0x3c, 0x2b, 0xb2, 0xf2, 0x40, 0x44, 0x11, 0xa8,
 351         0xd2, 0x64, 0xf8, 0xa3, 0x44, 0xbd, 0xf0, 0x74, 0x6c, 0x5c, 0x7b, 0xc7, 0x17, 0x91, 0x06, 0xc1,
 352         0x9e, 0xc1, 0x63, 0x3b, 0x75, 0x9d, 0xfa, 0xc5, 0x97, 0x45, 0x56, 0xe6, 0x22, 0xa9, 0xf5, 0x9f,
 353         0x0c, 0x4e, 0xaf, 0xe9, 0x16, 0x3f, 0xa0, 0x46, 0xd3, 0x38, 0x32, 0x02, 0x7f, 0x4c, 0x68, 0x1d,
 354         0x2b, 0xe1, 0xa4, 0x53, 0x3d, 0xd6, 0x8e, 0x6a, 0x19, 0x63, 0xc8, 0xb3, 0x62, 0x51, 0xe6, 0xe2,
 355         0xd8, 0xf3, 0xcf, 0x94, 0x5e, 0x20, 0x3b, 0x87, 0x7c, 0x6c, 0x4c, 0x33, 0xa0, 0xc3, 0xd8, 0x4a,
 356         0x2e, 0x1e, 0x00, 0xbb, 0x06, 0x08, 0xe3, 0xd4, 0xfe, 0x15, 0x5f, 0x15, 0x8b, 0xf2, 0xe8, 0xf2,
 357         0x45, 0xb5, 0x6b, 0xcb, 0x7b, 0xd5, 0xe3, 0xbb, 0x7b, 0x03, 0xb6, 0x1e, 0x8b, 0x3c, 0x44, 0x7d,
 358         0x84, 0x7d, 0x82, 0x93, 0xd9, 0xb8, 0xfa, 0x67, 0xf4, 0x24, 0x8c, 0x77, 0x74, 0xf9, 0xbc, 0xda,
 359         0xe7, 0x70, 0x95, 0xcc, 0x13, 0xab, 0x99, 0x24, 0xb0, 0xfe, 0x9d, 0xc1, 0xd3, 0x9d, 0x99, 0xed,
 360         0x48, 0xda, 0xa2, 0xf7, 0x0e, 0x8d, 0x49, 0x3e, 0xe7, 0x22, 0x0a, 0xf6, 0x11, 0x96, 0xff, 0x34,
 361         0xff, 0x7a, 0xff, 0x8f, 0xff, 0x2d, 0x1a, 0x66, 0x13, 0xa1, 0xc2, 0xd9, 0x37, 0x58, 0x86, 0x79,
 362         0x18, 0x2c, 0x75, 0x33, 0x60, 0xfa, 0x26, 0xdc, 0xd9, 0x2b, 0x58, 0x29, 0x6d, 0xd1, 0x38, 0x45,
 363         0xba, 0x1e, 0x49, 0x69, 0x97, 0xcc, 0x3c, 0xbe, 0xc7, 0x5b, 0x4f, 0x19, 0x87, 0xc3, 0x96, 0xb4,
 364         0x43, 0xed, 0xf8, 0x2a, 0x24, 0xcc, 0xf2, 0x4a, 0xc2, 0x79, 0x4b, 0xc3, 0xde, 0xfe, 0xae, 0x9e,
 365         0x6c, 0xc3, 0x6e, 0x06, 0x7b, 0xed, 0xd7, 0x37, 0x52, 0xb9, 0xbb, 0xe9, 0xc6, 0x87, 0x37, 0x92,
 366         0xfa, 0x46, 0xcb, 0x87, 0x65, 0x0c, 0x97, 0xf6, 0x42, 0xa2, 0xbe, 0x90, 0x94, 0x56, 0xfa, 0x6d,
 367         0x3c, 0x6a, 0x49, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xf7, 0x15, 0x40, 0xc5, 0xfe, 0x02, 0x00,
 368         0x00,
 369 }