vendor/google.golang.org/grpc/reflection/grpc_reflection_v1alpha/reflection.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: grpc_reflection_v1alpha/reflection.proto
   3
   4 /*
   5 Package grpc_reflection_v1alpha is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         grpc_reflection_v1alpha/reflection.proto
   9
  10 It has these top-level messages:
  11         ServerReflectionRequest
  12         ExtensionRequest
  13         ServerReflectionResponse
  14         FileDescriptorResponse
  15         ExtensionNumberResponse
  16         ListServiceResponse
  17         ServiceResponse
  18         ErrorResponse
  19 */
  20 package grpc_reflection_v1alpha
  21
  22 import proto "github.com/golang/protobuf/proto"
  23 import fmt "fmt"
  24 import math "math"
  25
  26 import (
  27         context "golang.org/x/net/context"
  28         grpc "google.golang.org/grpc"
  29 )
  30
  31 // Reference imports to suppress errors if they are not otherwise used.
  32 var _ = proto.Marshal
  33 var _ = fmt.Errorf
  34 var _ = math.Inf
  35
  36 // This is a compile-time assertion to ensure that this generated file
  37 // is compatible with the proto package it is being compiled against.
  38 // A compilation error at this line likely means your copy of the
  39 // proto package needs to be updated.
  40 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  41
  42 // The message sent by the client when calling ServerReflectionInfo method.
  43 type ServerReflectionRequest struct {
  44         Host string `protobuf:"bytes,1,opt,name=host" json:"host,omitempty"`
  45         // To use reflection service, the client should set one of the following
  46         // fields in message_request. The server distinguishes requests by their
  47         // defined field and then handles them using corresponding methods.
  48         //
  49         // Types that are valid to be assigned to MessageRequest:
  50         //      *ServerReflectionRequest_FileByFilename
  51         //      *ServerReflectionRequest_FileContainingSymbol
  52         //      *ServerReflectionRequest_FileContainingExtension
  53         //      *ServerReflectionRequest_AllExtensionNumbersOfType
  54         //      *ServerReflectionRequest_ListServices
  55         MessageRequest isServerReflectionRequest_MessageRequest `protobuf_oneof:"message_request"`
  56 }
  57
  58 func (m *ServerReflectionRequest) Reset()                    { *m = ServerReflectionRequest{} }
  59 func (m *ServerReflectionRequest) String() string            { return proto.CompactTextString(m) }
  60 func (*ServerReflectionRequest) ProtoMessage()               {}
  61 func (*ServerReflectionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  62
  63 type isServerReflectionRequest_MessageRequest interface {
  64         isServerReflectionRequest_MessageRequest()
  65 }
  66
  67 type ServerReflectionRequest_FileByFilename struct {
  68         FileByFilename string `protobuf:"bytes,3,opt,name=file_by_filename,json=fileByFilename,oneof"`
  69 }
  70 type ServerReflectionRequest_FileContainingSymbol struct {
  71         FileContainingSymbol string `protobuf:"bytes,4,opt,name=file_containing_symbol,json=fileContainingSymbol,oneof"`
  72 }
  73 type ServerReflectionRequest_FileContainingExtension struct {
  74         FileContainingExtension *ExtensionRequest `protobuf:"bytes,5,opt,name=file_containing_extension,json=fileContainingExtension,oneof"`
  75 }
  76 type ServerReflectionRequest_AllExtensionNumbersOfType struct {
  77         AllExtensionNumbersOfType string `protobuf:"bytes,6,opt,name=all_extension_numbers_of_type,json=allExtensionNumbersOfType,oneof"`
  78 }
  79 type ServerReflectionRequest_ListServices struct {
  80         ListServices string `protobuf:"bytes,7,opt,name=list_services,json=listServices,oneof"`
  81 }
  82
  83 func (*ServerReflectionRequest_FileByFilename) isServerReflectionRequest_MessageRequest()            {}
  84 func (*ServerReflectionRequest_FileContainingSymbol) isServerReflectionRequest_MessageRequest()      {}
  85 func (*ServerReflectionRequest_FileContainingExtension) isServerReflectionRequest_MessageRequest()   {}
  86 func (*ServerReflectionRequest_AllExtensionNumbersOfType) isServerReflectionRequest_MessageRequest() {}
  87 func (*ServerReflectionRequest_ListServices) isServerReflectionRequest_MessageRequest()              {}
  88
  89 func (m *ServerReflectionRequest) GetMessageRequest() isServerReflectionRequest_MessageRequest {
  90         if m != nil {
  91                 return m.MessageRequest
  92         }
  93         return nil
  94 }
  95
  96 func (m *ServerReflectionRequest) GetHost() string {
  97         if m != nil {
  98                 return m.Host
  99         }
 100         return ""
 101 }
 102
 103 func (m *ServerReflectionRequest) GetFileByFilename() string {
 104         if x, ok := m.GetMessageRequest().(*ServerReflectionRequest_FileByFilename); ok {
 105                 return x.FileByFilename
 106         }
 107         return ""
 108 }
 109
 110 func (m *ServerReflectionRequest) GetFileContainingSymbol() string {
 111         if x, ok := m.GetMessageRequest().(*ServerReflectionRequest_FileContainingSymbol); ok {
 112                 return x.FileContainingSymbol
 113         }
 114         return ""
 115 }
 116
 117 func (m *ServerReflectionRequest) GetFileContainingExtension() *ExtensionRequest {
 118         if x, ok := m.GetMessageRequest().(*ServerReflectionRequest_FileContainingExtension); ok {
 119                 return x.FileContainingExtension
 120         }
 121         return nil
 122 }
 123
 124 func (m *ServerReflectionRequest) GetAllExtensionNumbersOfType() string {
 125         if x, ok := m.GetMessageRequest().(*ServerReflectionRequest_AllExtensionNumbersOfType); ok {
 126                 return x.AllExtensionNumbersOfType
 127         }
 128         return ""
 129 }
 130
 131 func (m *ServerReflectionRequest) GetListServices() string {
 132         if x, ok := m.GetMessageRequest().(*ServerReflectionRequest_ListServices); ok {
 133                 return x.ListServices
 134         }
 135         return ""
 136 }
 137
 138 // XXX_OneofFuncs is for the internal use of the proto package.
 139 func (*ServerReflectionRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 140         return _ServerReflectionRequest_OneofMarshaler, _ServerReflectionRequest_OneofUnmarshaler, _ServerReflectionRequest_OneofSizer, []interface{}{
 141                 (*ServerReflectionRequest_FileByFilename)(nil),
 142                 (*ServerReflectionRequest_FileContainingSymbol)(nil),
 143                 (*ServerReflectionRequest_FileContainingExtension)(nil),
 144                 (*ServerReflectionRequest_AllExtensionNumbersOfType)(nil),
 145                 (*ServerReflectionRequest_ListServices)(nil),
 146         }
 147 }
 148
 149 func _ServerReflectionRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 150         m := msg.(*ServerReflectionRequest)
 151         // message_request
 152         switch x := m.MessageRequest.(type) {
 153         case *ServerReflectionRequest_FileByFilename:
 154                 b.EncodeVarint(3<<3 | proto.WireBytes)
 155                 b.EncodeStringBytes(x.FileByFilename)
 156         case *ServerReflectionRequest_FileContainingSymbol:
 157                 b.EncodeVarint(4<<3 | proto.WireBytes)
 158                 b.EncodeStringBytes(x.FileContainingSymbol)
 159         case *ServerReflectionRequest_FileContainingExtension:
 160                 b.EncodeVarint(5<<3 | proto.WireBytes)
 161                 if err := b.EncodeMessage(x.FileContainingExtension); err != nil {
 162                         return err
 163                 }
 164         case *ServerReflectionRequest_AllExtensionNumbersOfType:
 165                 b.EncodeVarint(6<<3 | proto.WireBytes)
 166                 b.EncodeStringBytes(x.AllExtensionNumbersOfType)
 167         case *ServerReflectionRequest_ListServices:
 168                 b.EncodeVarint(7<<3 | proto.WireBytes)
 169                 b.EncodeStringBytes(x.ListServices)
 170         case nil:
 171         default:
 172                 return fmt.Errorf("ServerReflectionRequest.MessageRequest has unexpected type %T", x)
 173         }
 174         return nil
 175 }
 176
 177 func _ServerReflectionRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 178         m := msg.(*ServerReflectionRequest)
 179         switch tag {
 180         case 3: // message_request.file_by_filename
 181                 if wire != proto.WireBytes {
 182                         return true, proto.ErrInternalBadWireType
 183                 }
 184                 x, err := b.DecodeStringBytes()
 185                 m.MessageRequest = &ServerReflectionRequest_FileByFilename{x}
 186                 return true, err
 187         case 4: // message_request.file_containing_symbol
 188                 if wire != proto.WireBytes {
 189                         return true, proto.ErrInternalBadWireType
 190                 }
 191                 x, err := b.DecodeStringBytes()
 192                 m.MessageRequest = &ServerReflectionRequest_FileContainingSymbol{x}
 193                 return true, err
 194         case 5: // message_request.file_containing_extension
 195                 if wire != proto.WireBytes {
 196                         return true, proto.ErrInternalBadWireType
 197                 }
 198                 msg := new(ExtensionRequest)
 199                 err := b.DecodeMessage(msg)
 200                 m.MessageRequest = &ServerReflectionRequest_FileContainingExtension{msg}
 201                 return true, err
 202         case 6: // message_request.all_extension_numbers_of_type
 203                 if wire != proto.WireBytes {
 204                         return true, proto.ErrInternalBadWireType
 205                 }
 206                 x, err := b.DecodeStringBytes()
 207                 m.MessageRequest = &ServerReflectionRequest_AllExtensionNumbersOfType{x}
 208                 return true, err
 209         case 7: // message_request.list_services
 210                 if wire != proto.WireBytes {
 211                         return true, proto.ErrInternalBadWireType
 212                 }
 213                 x, err := b.DecodeStringBytes()
 214                 m.MessageRequest = &ServerReflectionRequest_ListServices{x}
 215                 return true, err
 216         default:
 217                 return false, nil
 218         }
 219 }
 220
 221 func _ServerReflectionRequest_OneofSizer(msg proto.Message) (n int) {
 222         m := msg.(*ServerReflectionRequest)
 223         // message_request
 224         switch x := m.MessageRequest.(type) {
 225         case *ServerReflectionRequest_FileByFilename:
 226                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 227                 n += proto.SizeVarint(uint64(len(x.FileByFilename)))
 228                 n += len(x.FileByFilename)
 229         case *ServerReflectionRequest_FileContainingSymbol:
 230                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 231                 n += proto.SizeVarint(uint64(len(x.FileContainingSymbol)))
 232                 n += len(x.FileContainingSymbol)
 233         case *ServerReflectionRequest_FileContainingExtension:
 234                 s := proto.Size(x.FileContainingExtension)
 235                 n += proto.SizeVarint(5<<3 | proto.WireBytes)
 236                 n += proto.SizeVarint(uint64(s))
 237                 n += s
 238         case *ServerReflectionRequest_AllExtensionNumbersOfType:
 239                 n += proto.SizeVarint(6<<3 | proto.WireBytes)
 240                 n += proto.SizeVarint(uint64(len(x.AllExtensionNumbersOfType)))
 241                 n += len(x.AllExtensionNumbersOfType)
 242         case *ServerReflectionRequest_ListServices:
 243                 n += proto.SizeVarint(7<<3 | proto.WireBytes)
 244                 n += proto.SizeVarint(uint64(len(x.ListServices)))
 245                 n += len(x.ListServices)
 246         case nil:
 247         default:
 248                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 249         }
 250         return n
 251 }
 252
 253 // The type name and extension number sent by the client when requesting
 254 // file_containing_extension.
 255 type ExtensionRequest struct {
 256         // Fully-qualified type name. The format should be <package>.<type>
 257         ContainingType  string `protobuf:"bytes,1,opt,name=containing_type,json=containingType" json:"containing_type,omitempty"`
 258         ExtensionNumber int32  `protobuf:"varint,2,opt,name=extension_number,json=extensionNumber" json:"extension_number,omitempty"`
 259 }
 260
 261 func (m *ExtensionRequest) Reset()                    { *m = ExtensionRequest{} }
 262 func (m *ExtensionRequest) String() string            { return proto.CompactTextString(m) }
 263 func (*ExtensionRequest) ProtoMessage()               {}
 264 func (*ExtensionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 265
 266 func (m *ExtensionRequest) GetContainingType() string {
 267         if m != nil {
 268                 return m.ContainingType
 269         }
 270         return ""
 271 }
 272
 273 func (m *ExtensionRequest) GetExtensionNumber() int32 {
 274         if m != nil {
 275                 return m.ExtensionNumber
 276         }
 277         return 0
 278 }
 279
 280 // The message sent by the server to answer ServerReflectionInfo method.
 281 type ServerReflectionResponse struct {
 282         ValidHost       string                   `protobuf:"bytes,1,opt,name=valid_host,json=validHost" json:"valid_host,omitempty"`
 283         OriginalRequest *ServerReflectionRequest `protobuf:"bytes,2,opt,name=original_request,json=originalRequest" json:"original_request,omitempty"`
 284         // The server set one of the following fields according to the message_request
 285         // in the request.
 286         //
 287         // Types that are valid to be assigned to MessageResponse:
 288         //      *ServerReflectionResponse_FileDescriptorResponse
 289         //      *ServerReflectionResponse_AllExtensionNumbersResponse
 290         //      *ServerReflectionResponse_ListServicesResponse
 291         //      *ServerReflectionResponse_ErrorResponse
 292         MessageResponse isServerReflectionResponse_MessageResponse `protobuf_oneof:"message_response"`
 293 }
 294
 295 func (m *ServerReflectionResponse) Reset()                    { *m = ServerReflectionResponse{} }
 296 func (m *ServerReflectionResponse) String() string            { return proto.CompactTextString(m) }
 297 func (*ServerReflectionResponse) ProtoMessage()               {}
 298 func (*ServerReflectionResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 299
 300 type isServerReflectionResponse_MessageResponse interface {
 301         isServerReflectionResponse_MessageResponse()
 302 }
 303
 304 type ServerReflectionResponse_FileDescriptorResponse struct {
 305         FileDescriptorResponse *FileDescriptorResponse `protobuf:"bytes,4,opt,name=file_descriptor_response,json=fileDescriptorResponse,oneof"`
 306 }
 307 type ServerReflectionResponse_AllExtensionNumbersResponse struct {
 308         AllExtensionNumbersResponse *ExtensionNumberResponse `protobuf:"bytes,5,opt,name=all_extension_numbers_response,json=allExtensionNumbersResponse,oneof"`
 309 }
 310 type ServerReflectionResponse_ListServicesResponse struct {
 311         ListServicesResponse *ListServiceResponse `protobuf:"bytes,6,opt,name=list_services_response,json=listServicesResponse,oneof"`
 312 }
 313 type ServerReflectionResponse_ErrorResponse struct {
 314         ErrorResponse *ErrorResponse `protobuf:"bytes,7,opt,name=error_response,json=errorResponse,oneof"`
 315 }
 316
 317 func (*ServerReflectionResponse_FileDescriptorResponse) isServerReflectionResponse_MessageResponse() {}
 318 func (*ServerReflectionResponse_AllExtensionNumbersResponse) isServerReflectionResponse_MessageResponse() {
 319 }
 320 func (*ServerReflectionResponse_ListServicesResponse) isServerReflectionResponse_MessageResponse() {}
 321 func (*ServerReflectionResponse_ErrorResponse) isServerReflectionResponse_MessageResponse()        {}
 322
 323 func (m *ServerReflectionResponse) GetMessageResponse() isServerReflectionResponse_MessageResponse {
 324         if m != nil {
 325                 return m.MessageResponse
 326         }
 327         return nil
 328 }
 329
 330 func (m *ServerReflectionResponse) GetValidHost() string {
 331         if m != nil {
 332                 return m.ValidHost
 333         }
 334         return ""
 335 }
 336
 337 func (m *ServerReflectionResponse) GetOriginalRequest() *ServerReflectionRequest {
 338         if m != nil {
 339                 return m.OriginalRequest
 340         }
 341         return nil
 342 }
 343
 344 func (m *ServerReflectionResponse) GetFileDescriptorResponse() *FileDescriptorResponse {
 345         if x, ok := m.GetMessageResponse().(*ServerReflectionResponse_FileDescriptorResponse); ok {
 346                 return x.FileDescriptorResponse
 347         }
 348         return nil
 349 }
 350
 351 func (m *ServerReflectionResponse) GetAllExtensionNumbersResponse() *ExtensionNumberResponse {
 352         if x, ok := m.GetMessageResponse().(*ServerReflectionResponse_AllExtensionNumbersResponse); ok {
 353                 return x.AllExtensionNumbersResponse
 354         }
 355         return nil
 356 }
 357
 358 func (m *ServerReflectionResponse) GetListServicesResponse() *ListServiceResponse {
 359         if x, ok := m.GetMessageResponse().(*ServerReflectionResponse_ListServicesResponse); ok {
 360                 return x.ListServicesResponse
 361         }
 362         return nil
 363 }
 364
 365 func (m *ServerReflectionResponse) GetErrorResponse() *ErrorResponse {
 366         if x, ok := m.GetMessageResponse().(*ServerReflectionResponse_ErrorResponse); ok {
 367                 return x.ErrorResponse
 368         }
 369         return nil
 370 }
 371
 372 // XXX_OneofFuncs is for the internal use of the proto package.
 373 func (*ServerReflectionResponse) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 374         return _ServerReflectionResponse_OneofMarshaler, _ServerReflectionResponse_OneofUnmarshaler, _ServerReflectionResponse_OneofSizer, []interface{}{
 375                 (*ServerReflectionResponse_FileDescriptorResponse)(nil),
 376                 (*ServerReflectionResponse_AllExtensionNumbersResponse)(nil),
 377                 (*ServerReflectionResponse_ListServicesResponse)(nil),
 378                 (*ServerReflectionResponse_ErrorResponse)(nil),
 379         }
 380 }
 381
 382 func _ServerReflectionResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 383         m := msg.(*ServerReflectionResponse)
 384         // message_response
 385         switch x := m.MessageResponse.(type) {
 386         case *ServerReflectionResponse_FileDescriptorResponse:
 387                 b.EncodeVarint(4<<3 | proto.WireBytes)
 388                 if err := b.EncodeMessage(x.FileDescriptorResponse); err != nil {
 389                         return err
 390                 }
 391         case *ServerReflectionResponse_AllExtensionNumbersResponse:
 392                 b.EncodeVarint(5<<3 | proto.WireBytes)
 393                 if err := b.EncodeMessage(x.AllExtensionNumbersResponse); err != nil {
 394                         return err
 395                 }
 396         case *ServerReflectionResponse_ListServicesResponse:
 397                 b.EncodeVarint(6<<3 | proto.WireBytes)
 398                 if err := b.EncodeMessage(x.ListServicesResponse); err != nil {
 399                         return err
 400                 }
 401         case *ServerReflectionResponse_ErrorResponse:
 402                 b.EncodeVarint(7<<3 | proto.WireBytes)
 403                 if err := b.EncodeMessage(x.ErrorResponse); err != nil {
 404                         return err
 405                 }
 406         case nil:
 407         default:
 408                 return fmt.Errorf("ServerReflectionResponse.MessageResponse has unexpected type %T", x)
 409         }
 410         return nil
 411 }
 412
 413 func _ServerReflectionResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 414         m := msg.(*ServerReflectionResponse)
 415         switch tag {
 416         case 4: // message_response.file_descriptor_response
 417                 if wire != proto.WireBytes {
 418                         return true, proto.ErrInternalBadWireType
 419                 }
 420                 msg := new(FileDescriptorResponse)
 421                 err := b.DecodeMessage(msg)
 422                 m.MessageResponse = &ServerReflectionResponse_FileDescriptorResponse{msg}
 423                 return true, err
 424         case 5: // message_response.all_extension_numbers_response
 425                 if wire != proto.WireBytes {
 426                         return true, proto.ErrInternalBadWireType
 427                 }
 428                 msg := new(ExtensionNumberResponse)
 429                 err := b.DecodeMessage(msg)
 430                 m.MessageResponse = &ServerReflectionResponse_AllExtensionNumbersResponse{msg}
 431                 return true, err
 432         case 6: // message_response.list_services_response
 433                 if wire != proto.WireBytes {
 434                         return true, proto.ErrInternalBadWireType
 435                 }
 436                 msg := new(ListServiceResponse)
 437                 err := b.DecodeMessage(msg)
 438                 m.MessageResponse = &ServerReflectionResponse_ListServicesResponse{msg}
 439                 return true, err
 440         case 7: // message_response.error_response
 441                 if wire != proto.WireBytes {
 442                         return true, proto.ErrInternalBadWireType
 443                 }
 444                 msg := new(ErrorResponse)
 445                 err := b.DecodeMessage(msg)
 446                 m.MessageResponse = &ServerReflectionResponse_ErrorResponse{msg}
 447                 return true, err
 448         default:
 449                 return false, nil
 450         }
 451 }
 452
 453 func _ServerReflectionResponse_OneofSizer(msg proto.Message) (n int) {
 454         m := msg.(*ServerReflectionResponse)
 455         // message_response
 456         switch x := m.MessageResponse.(type) {
 457         case *ServerReflectionResponse_FileDescriptorResponse:
 458                 s := proto.Size(x.FileDescriptorResponse)
 459                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 460                 n += proto.SizeVarint(uint64(s))
 461                 n += s
 462         case *ServerReflectionResponse_AllExtensionNumbersResponse:
 463                 s := proto.Size(x.AllExtensionNumbersResponse)
 464                 n += proto.SizeVarint(5<<3 | proto.WireBytes)
 465                 n += proto.SizeVarint(uint64(s))
 466                 n += s
 467         case *ServerReflectionResponse_ListServicesResponse:
 468                 s := proto.Size(x.ListServicesResponse)
 469                 n += proto.SizeVarint(6<<3 | proto.WireBytes)
 470                 n += proto.SizeVarint(uint64(s))
 471                 n += s
 472         case *ServerReflectionResponse_ErrorResponse:
 473                 s := proto.Size(x.ErrorResponse)
 474                 n += proto.SizeVarint(7<<3 | proto.WireBytes)
 475                 n += proto.SizeVarint(uint64(s))
 476                 n += s
 477         case nil:
 478         default:
 479                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 480         }
 481         return n
 482 }
 483
 484 // Serialized FileDescriptorProto messages sent by the server answering
 485 // a file_by_filename, file_containing_symbol, or file_containing_extension
 486 // request.
 487 type FileDescriptorResponse struct {
 488         // Serialized FileDescriptorProto messages. We avoid taking a dependency on
 489         // descriptor.proto, which uses proto2 only features, by making them opaque
 490         // bytes instead.
 491         FileDescriptorProto [][]byte `protobuf:"bytes,1,rep,name=file_descriptor_proto,json=fileDescriptorProto,proto3" json:"file_descriptor_proto,omitempty"`
 492 }
 493
 494 func (m *FileDescriptorResponse) Reset()                    { *m = FileDescriptorResponse{} }
 495 func (m *FileDescriptorResponse) String() string            { return proto.CompactTextString(m) }
 496 func (*FileDescriptorResponse) ProtoMessage()               {}
 497 func (*FileDescriptorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 498
 499 func (m *FileDescriptorResponse) GetFileDescriptorProto() [][]byte {
 500         if m != nil {
 501                 return m.FileDescriptorProto
 502         }
 503         return nil
 504 }
 505
 506 // A list of extension numbers sent by the server answering
 507 // all_extension_numbers_of_type request.
 508 type ExtensionNumberResponse struct {
 509         // Full name of the base type, including the package name. The format
 510         // is <package>.<type>
 511         BaseTypeName    string  `protobuf:"bytes,1,opt,name=base_type_name,json=baseTypeName" json:"base_type_name,omitempty"`
 512         ExtensionNumber []int32 `protobuf:"varint,2,rep,packed,name=extension_number,json=extensionNumber" json:"extension_number,omitempty"`
 513 }
 514
 515 func (m *ExtensionNumberResponse) Reset()                    { *m = ExtensionNumberResponse{} }
 516 func (m *ExtensionNumberResponse) String() string            { return proto.CompactTextString(m) }
 517 func (*ExtensionNumberResponse) ProtoMessage()               {}
 518 func (*ExtensionNumberResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 519
 520 func (m *ExtensionNumberResponse) GetBaseTypeName() string {
 521         if m != nil {
 522                 return m.BaseTypeName
 523         }
 524         return ""
 525 }
 526
 527 func (m *ExtensionNumberResponse) GetExtensionNumber() []int32 {
 528         if m != nil {
 529                 return m.ExtensionNumber
 530         }
 531         return nil
 532 }
 533
 534 // A list of ServiceResponse sent by the server answering list_services request.
 535 type ListServiceResponse struct {
 536         // The information of each service may be expanded in the future, so we use
 537         // ServiceResponse message to encapsulate it.
 538         Service []*ServiceResponse `protobuf:"bytes,1,rep,name=service" json:"service,omitempty"`
 539 }
 540
 541 func (m *ListServiceResponse) Reset()                    { *m = ListServiceResponse{} }
 542 func (m *ListServiceResponse) String() string            { return proto.CompactTextString(m) }
 543 func (*ListServiceResponse) ProtoMessage()               {}
 544 func (*ListServiceResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 545
 546 func (m *ListServiceResponse) GetService() []*ServiceResponse {
 547         if m != nil {
 548                 return m.Service
 549         }
 550         return nil
 551 }
 552
 553 // The information of a single service used by ListServiceResponse to answer
 554 // list_services request.
 555 type ServiceResponse struct {
 556         // Full name of a registered service, including its package name. The format
 557         // is <package>.<service>
 558         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
 559 }
 560
 561 func (m *ServiceResponse) Reset()                    { *m = ServiceResponse{} }
 562 func (m *ServiceResponse) String() string            { return proto.CompactTextString(m) }
 563 func (*ServiceResponse) ProtoMessage()               {}
 564 func (*ServiceResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 565
 566 func (m *ServiceResponse) GetName() string {
 567         if m != nil {
 568                 return m.Name
 569         }
 570         return ""
 571 }
 572
 573 // The error code and error message sent by the server when an error occurs.
 574 type ErrorResponse struct {
 575         // This field uses the error codes defined in grpc::StatusCode.
 576         ErrorCode    int32  `protobuf:"varint,1,opt,name=error_code,json=errorCode" json:"error_code,omitempty"`
 577         ErrorMessage string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage" json:"error_message,omitempty"`
 578 }
 579
 580 func (m *ErrorResponse) Reset()                    { *m = ErrorResponse{} }
 581 func (m *ErrorResponse) String() string            { return proto.CompactTextString(m) }
 582 func (*ErrorResponse) ProtoMessage()               {}
 583 func (*ErrorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 584
 585 func (m *ErrorResponse) GetErrorCode() int32 {
 586         if m != nil {
 587                 return m.ErrorCode
 588         }
 589         return 0
 590 }
 591
 592 func (m *ErrorResponse) GetErrorMessage() string {
 593         if m != nil {
 594                 return m.ErrorMessage
 595         }
 596         return ""
 597 }
 598
 599 func init() {
 600         proto.RegisterType((*ServerReflectionRequest)(nil), "grpc.reflection.v1alpha.ServerReflectionRequest")
 601         proto.RegisterType((*ExtensionRequest)(nil), "grpc.reflection.v1alpha.ExtensionRequest")
 602         proto.RegisterType((*ServerReflectionResponse)(nil), "grpc.reflection.v1alpha.ServerReflectionResponse")
 603         proto.RegisterType((*FileDescriptorResponse)(nil), "grpc.reflection.v1alpha.FileDescriptorResponse")
 604         proto.RegisterType((*ExtensionNumberResponse)(nil), "grpc.reflection.v1alpha.ExtensionNumberResponse")
 605         proto.RegisterType((*ListServiceResponse)(nil), "grpc.reflection.v1alpha.ListServiceResponse")
 606         proto.RegisterType((*ServiceResponse)(nil), "grpc.reflection.v1alpha.ServiceResponse")
 607         proto.RegisterType((*ErrorResponse)(nil), "grpc.reflection.v1alpha.ErrorResponse")
 608 }
 609
 610 // Reference imports to suppress errors if they are not otherwise used.
 611 var _ context.Context
 612 var _ grpc.ClientConn
 613
 614 // This is a compile-time assertion to ensure that this generated file
 615 // is compatible with the grpc package it is being compiled against.
 616 const _ = grpc.SupportPackageIsVersion4
 617
 618 // Client API for ServerReflection service
 619
 620 type ServerReflectionClient interface {
 621         // The reflection service is structured as a bidirectional stream, ensuring
 622         // all related requests go to a single server.
 623         ServerReflectionInfo(ctx context.Context, opts ...grpc.CallOption) (ServerReflection_ServerReflectionInfoClient, error)
 624 }
 625
 626 type serverReflectionClient struct {
 627         cc *grpc.ClientConn
 628 }
 629
 630 func NewServerReflectionClient(cc *grpc.ClientConn) ServerReflectionClient {
 631         return &serverReflectionClient{cc}
 632 }
 633
 634 func (c *serverReflectionClient) ServerReflectionInfo(ctx context.Context, opts ...grpc.CallOption) (ServerReflection_ServerReflectionInfoClient, error) {
 635         stream, err := grpc.NewClientStream(ctx, &_ServerReflection_serviceDesc.Streams[0], c.cc, "/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo", opts...)
 636         if err != nil {
 637                 return nil, err
 638         }
 639         x := &serverReflectionServerReflectionInfoClient{stream}
 640         return x, nil
 641 }
 642
 643 type ServerReflection_ServerReflectionInfoClient interface {
 644         Send(*ServerReflectionRequest) error
 645         Recv() (*ServerReflectionResponse, error)
 646         grpc.ClientStream
 647 }
 648
 649 type serverReflectionServerReflectionInfoClient struct {
 650         grpc.ClientStream
 651 }
 652
 653 func (x *serverReflectionServerReflectionInfoClient) Send(m *ServerReflectionRequest) error {
 654         return x.ClientStream.SendMsg(m)
 655 }
 656
 657 func (x *serverReflectionServerReflectionInfoClient) Recv() (*ServerReflectionResponse, error) {
 658         m := new(ServerReflectionResponse)
 659         if err := x.ClientStream.RecvMsg(m); err != nil {
 660                 return nil, err
 661         }
 662         return m, nil
 663 }
 664
 665 // Server API for ServerReflection service
 666
 667 type ServerReflectionServer interface {
 668         // The reflection service is structured as a bidirectional stream, ensuring
 669         // all related requests go to a single server.
 670         ServerReflectionInfo(ServerReflection_ServerReflectionInfoServer) error
 671 }
 672
 673 func RegisterServerReflectionServer(s *grpc.Server, srv ServerReflectionServer) {
 674         s.RegisterService(&_ServerReflection_serviceDesc, srv)
 675 }
 676
 677 func _ServerReflection_ServerReflectionInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
 678         return srv.(ServerReflectionServer).ServerReflectionInfo(&serverReflectionServerReflectionInfoServer{stream})
 679 }
 680
 681 type ServerReflection_ServerReflectionInfoServer interface {
 682         Send(*ServerReflectionResponse) error
 683         Recv() (*ServerReflectionRequest, error)
 684         grpc.ServerStream
 685 }
 686
 687 type serverReflectionServerReflectionInfoServer struct {
 688         grpc.ServerStream
 689 }
 690
 691 func (x *serverReflectionServerReflectionInfoServer) Send(m *ServerReflectionResponse) error {
 692         return x.ServerStream.SendMsg(m)
 693 }
 694
 695 func (x *serverReflectionServerReflectionInfoServer) Recv() (*ServerReflectionRequest, error) {
 696         m := new(ServerReflectionRequest)
 697         if err := x.ServerStream.RecvMsg(m); err != nil {
 698                 return nil, err
 699         }
 700         return m, nil
 701 }
 702
 703 var _ServerReflection_serviceDesc = grpc.ServiceDesc{
 704         ServiceName: "grpc.reflection.v1alpha.ServerReflection",
 705         HandlerType: (*ServerReflectionServer)(nil),
 706         Methods:     []grpc.MethodDesc{},
 707         Streams: []grpc.StreamDesc{
 708                 {
 709                         StreamName:    "ServerReflectionInfo",
 710                         Handler:       _ServerReflection_ServerReflectionInfo_Handler,
 711                         ServerStreams: true,
 712                         ClientStreams: true,
 713                 },
 714         },
 715         Metadata: "grpc_reflection_v1alpha/reflection.proto",
 716 }
 717
 718 func init() { proto.RegisterFile("grpc_reflection_v1alpha/reflection.proto", fileDescriptor0) }
 719
 720 var fileDescriptor0 = []byte{
 721         // 656 bytes of a gzipped FileDescriptorProto
 722         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x51, 0x73, 0xd2, 0x40,
 723         0x10, 0x6e, 0x5a, 0x68, 0x87, 0x85, 0x02, 0x5e, 0x2b, 0xa4, 0x3a, 0x75, 0x98, 0x68, 0x35, 0x75,
 724         0x1c, 0xda, 0xe2, 0x8c, 0x3f, 0x80, 0xaa, 0x83, 0x33, 0xb5, 0x75, 0x0e, 0x5f, 0x1c, 0x1f, 0x6e,
 725         0x02, 0x2c, 0x34, 0x1a, 0x72, 0xf1, 0x2e, 0x45, 0x79, 0xf2, 0x47, 0xf8, 0xa3, 0xfc, 0x4b, 0x3e,
 726         0x3a, 0x77, 0x09, 0x21, 0xa4, 0x44, 0xa7, 0x4f, 0x30, 0xdf, 0xee, 0xde, 0xb7, 0xbb, 0xdf, 0xb7,
 727         0x01, 0x7b, 0x22, 0x82, 0x21, 0x13, 0x38, 0xf6, 0x70, 0x18, 0xba, 0xdc, 0x67, 0xb3, 0x33, 0xc7,
 728         0x0b, 0xae, 0x9d, 0x93, 0x25, 0xd4, 0x0e, 0x04, 0x0f, 0x39, 0x69, 0xaa, 0xcc, 0x76, 0x0a, 0x8e,
 729         0x33, 0xad, 0x3f, 0x9b, 0xd0, 0xec, 0xa3, 0x98, 0xa1, 0xa0, 0x49, 0x90, 0xe2, 0xb7, 0x1b, 0x94,
 730         0x21, 0x21, 0x50, 0xb8, 0xe6, 0x32, 0x34, 0x8d, 0x96, 0x61, 0x97, 0xa8, 0xfe, 0x4f, 0x9e, 0x43,
 731         0x7d, 0xec, 0x7a, 0xc8, 0x06, 0x73, 0xa6, 0x7e, 0x7d, 0x67, 0x8a, 0xe6, 0x96, 0x8a, 0xf7, 0x36,
 732         0x68, 0x55, 0x21, 0xdd, 0xf9, 0xdb, 0x18, 0x27, 0xaf, 0xa0, 0xa1, 0x73, 0x87, 0xdc, 0x0f, 0x1d,
 733         0xd7, 0x77, 0xfd, 0x09, 0x93, 0xf3, 0xe9, 0x80, 0x7b, 0x66, 0x21, 0xae, 0xd8, 0x57, 0xf1, 0xf3,
 734         0x24, 0xdc, 0xd7, 0x51, 0x32, 0x81, 0x83, 0x6c, 0x1d, 0xfe, 0x08, 0xd1, 0x97, 0x2e, 0xf7, 0xcd,
 735         0x62, 0xcb, 0xb0, 0xcb, 0x9d, 0xe3, 0x76, 0xce, 0x40, 0xed, 0x37, 0x8b, 0xcc, 0x78, 0x8a, 0xde,
 736         0x06, 0x6d, 0xae, 0xb2, 0x24, 0x19, 0xa4, 0x0b, 0x87, 0x8e, 0xe7, 0x2d, 0x1f, 0x67, 0xfe, 0xcd,
 737         0x74, 0x80, 0x42, 0x32, 0x3e, 0x66, 0xe1, 0x3c, 0x40, 0x73, 0x3b, 0xee, 0xf3, 0xc0, 0xf1, 0xbc,
 738         0xa4, 0xec, 0x32, 0x4a, 0xba, 0x1a, 0x7f, 0x9c, 0x07, 0x48, 0x8e, 0x60, 0xd7, 0x73, 0x65, 0xc8,
 739         0x24, 0x8a, 0x99, 0x3b, 0x44, 0x69, 0xee, 0xc4, 0x35, 0x15, 0x05, 0xf7, 0x63, 0xb4, 0x7b, 0x0f,
 740         0x6a, 0x53, 0x94, 0xd2, 0x99, 0x20, 0x13, 0x51, 0x63, 0xd6, 0x18, 0xea, 0xd9, 0x66, 0xc9, 0x33,
 741         0xa8, 0xa5, 0xa6, 0xd6, 0x3d, 0x44, 0xdb, 0xaf, 0x2e, 0x61, 0x4d, 0x7b, 0x0c, 0xf5, 0x6c, 0xdb,
 742         0xe6, 0x66, 0xcb, 0xb0, 0x8b, 0xb4, 0x86, 0xab, 0x8d, 0x5a, 0xbf, 0x0b, 0x60, 0xde, 0x96, 0x58,
 743         0x06, 0xdc, 0x97, 0x48, 0x0e, 0x01, 0x66, 0x8e, 0xe7, 0x8e, 0x58, 0x4a, 0xe9, 0x92, 0x46, 0x7a,
 744         0x4a, 0xee, 0xcf, 0x50, 0xe7, 0xc2, 0x9d, 0xb8, 0xbe, 0xe3, 0x2d, 0xfa, 0xd6, 0x34, 0xe5, 0xce,
 745         0x69, 0xae, 0x02, 0x39, 0x76, 0xa2, 0xb5, 0xc5, 0x4b, 0x8b, 0x61, 0xbf, 0x82, 0xa9, 0x75, 0x1e,
 746         0xa1, 0x1c, 0x0a, 0x37, 0x08, 0xb9, 0x60, 0x22, 0xee, 0x4b, 0x3b, 0xa4, 0xdc, 0x39, 0xc9, 0x25,
 747         0x51, 0x26, 0x7b, 0x9d, 0xd4, 0x2d, 0xc6, 0xe9, 0x6d, 0x50, 0x6d, 0xb9, 0xdb, 0x11, 0xf2, 0x1d,
 748         0x1e, 0xad, 0xd7, 0x3a, 0xa1, 0x2c, 0xfe, 0x67, 0xae, 0x8c, 0x01, 0x52, 0x9c, 0x0f, 0xd7, 0xd8,
 749         0x23, 0x21, 0x1e, 0x41, 0x63, 0xc5, 0x20, 0x4b, 0xc2, 0x6d, 0x4d, 0xf8, 0x22, 0x97, 0xf0, 0x62,
 750         0x69, 0xa0, 0x14, 0xd9, 0x7e, 0xda, 0x57, 0x09, 0xcb, 0x15, 0x54, 0x51, 0x88, 0xf4, 0x06, 0x77,
 751         0xf4, 0xeb, 0x4f, 0xf3, 0xc7, 0x51, 0xe9, 0xa9, 0x77, 0x77, 0x31, 0x0d, 0x74, 0x09, 0xd4, 0x97,
 752         0x86, 0x8d, 0x30, 0xeb, 0x02, 0x1a, 0xeb, 0xf7, 0x4e, 0x3a, 0x70, 0x3f, 0x2b, 0xa5, 0xfe, 0xf0,
 753         0x98, 0x46, 0x6b, 0xcb, 0xae, 0xd0, 0xbd, 0x55, 0x51, 0x3e, 0xa8, 0x90, 0xf5, 0x05, 0x9a, 0x39,
 754         0x2b, 0x25, 0x4f, 0xa0, 0x3a, 0x70, 0x24, 0xea, 0x03, 0x60, 0xfa, 0x1b, 0x13, 0x39, 0xb3, 0xa2,
 755         0x50, 0xe5, 0xff, 0x4b, 0xf5, 0x7d, 0x59, 0x7f, 0x03, 0x5b, 0xeb, 0x6e, 0xe0, 0x13, 0xec, 0xad,
 756         0xd9, 0x26, 0xe9, 0xc2, 0x4e, 0x2c, 0x8b, 0x6e, 0xb4, 0xdc, 0xb1, 0xff, 0xe9, 0xea, 0x54, 0x29,
 757         0x5d, 0x14, 0x5a, 0x47, 0x50, 0xcb, 0x3e, 0x4b, 0xa0, 0x90, 0x6a, 0x5a, 0xff, 0xb7, 0xfa, 0xb0,
 758         0xbb, 0xb2, 0x71, 0x75, 0x79, 0x91, 0x62, 0x43, 0x3e, 0x8a, 0x52, 0x8b, 0xb4, 0xa4, 0x91, 0x73,
 759         0x3e, 0x42, 0xf2, 0x18, 0x22, 0x41, 0x58, 0xac, 0x82, 0x3e, 0xbb, 0x12, 0xad, 0x68, 0xf0, 0x7d,
 760         0x84, 0x75, 0x7e, 0x19, 0x50, 0xcf, 0x9e, 0x1b, 0xf9, 0x09, 0xfb, 0x59, 0xec, 0x9d, 0x3f, 0xe6,
 761         0xe4, 0xce, 0x17, 0xfb, 0xe0, 0xec, 0x0e, 0x15, 0xd1, 0x54, 0xb6, 0x71, 0x6a, 0x0c, 0xb6, 0xb5,
 762         0xf4, 0x2f, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x85, 0x02, 0x09, 0x9d, 0x9f, 0x06, 0x00, 0x00,
 763 }