github.com/hoveychen/protoreflect@v1.4.7-0.20221103114119-0b4b3385ec76/internal/testprotos/desc_test_comments.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: desc_test_comments.proto

// And now the package declaration

package testprotos

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	grpc "google.golang.org/grpc"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type Request_MarioCharacters int32

const (
	Request_MARIO     Request_MarioCharacters = 1
	Request_LUIGI     Request_MarioCharacters = 2
	Request_PEACH     Request_MarioCharacters = 3
	Request_BOWSER    Request_MarioCharacters = 4
	Request_WARIO     Request_MarioCharacters = 5
	Request_WALUIGI   Request_MarioCharacters = 6
	Request_SHY_GUY   Request_MarioCharacters = 7
	Request_HEY_HO    Request_MarioCharacters = 7
	Request_MAGIKOOPA Request_MarioCharacters = 8
	Request_KAMEK     Request_MarioCharacters = 8
	Request_SNIFIT    Request_MarioCharacters = -101
)

var Request_MarioCharacters_name = map[int32]string{
	1: "MARIO",
	2: "LUIGI",
	3: "PEACH",
	4: "BOWSER",
	5: "WARIO",
	6: "WALUIGI",
	7: "SHY_GUY",
	// Duplicate value: 7: "HEY_HO",
	8: "MAGIKOOPA",
	// Duplicate value: 8: "KAMEK",
	-101: "SNIFIT",
}

var Request_MarioCharacters_value = map[string]int32{
	"MARIO":     1,
	"LUIGI":     2,
	"PEACH":     3,
	"BOWSER":    4,
	"WARIO":     5,
	"WALUIGI":   6,
	"SHY_GUY":   7,
	"HEY_HO":    7,
	"MAGIKOOPA": 8,
	"KAMEK":     8,
	"SNIFIT":    -101,
}

func (x Request_MarioCharacters) Enum() *Request_MarioCharacters {
	p := new(Request_MarioCharacters)
	*p = x
	return p
}

func (x Request_MarioCharacters) String() string {
	return proto.EnumName(Request_MarioCharacters_name, int32(x))
}

func (x *Request_MarioCharacters) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Request_MarioCharacters_value, data, "Request_MarioCharacters")
	if err != nil {
		return err
	}
	*x = Request_MarioCharacters(value)
	return nil
}

func (Request_MarioCharacters) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_62dea87c686ed756, []int{0, 0}
}

// We need a request for our RPC service below.
//
// Deprecated: Do not use.
type Request struct {
	// A field comment
	Ids []int32 `protobuf:"varint,1,rep,packed,name=ids,json=|foo|" json:"ids,omitempty"`
	// label comment
	Name   *string         `protobuf:"bytes,2,opt,name=name,def=fubar" json:"name,omitempty"`
	Extras *Request_Extras `protobuf:"group,3,opt,name=Extras,json=extras" json:"extras,omitempty"`
	// can be this or that
	//
	// Types that are valid to be assigned to Abc:
	//	*Request_This
	//	*Request_That
	Abc isRequest_Abc `protobuf_oneof:"abc"`
	// can be these or those
	//
	// Types that are valid to be assigned to Xyz:
	//	*Request_These
	//	*Request_Those
	Xyz isRequest_Xyz `protobuf_oneof:"xyz"`
	// map field
	Things                       map[string]string `protobuf:"bytes,8,rep,name=things" json:"things,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	XXX_NoUnkeyedLiteral         struct{}          `json:"-"`
	proto.XXX_InternalExtensions `json:"-"`
	XXX_unrecognized             []byte `json:"-"`
	XXX_sizecache                int32  `json:"-"`
}

func (m *Request) Reset()         { *m = Request{} }
func (m *Request) String() string { return proto.CompactTextString(m) }
func (*Request) ProtoMessage()    {}
func (*Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_62dea87c686ed756, []int{0}
}

var extRange_Request = []proto.ExtensionRange{
	{Start: 100, End: 200},
	{Start: 201, End: 250},
}

func (*Request) ExtensionRangeArray() []proto.ExtensionRange {
	return extRange_Request
}

func (m *Request) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Request.Unmarshal(m, b)
}
func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Request.Marshal(b, m, deterministic)
}
func (m *Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Request.Merge(m, src)
}
func (m *Request) XXX_Size() int {
	return xxx_messageInfo_Request.Size(m)
}
func (m *Request) XXX_DiscardUnknown() {
	xxx_messageInfo_Request.DiscardUnknown(m)
}

var xxx_messageInfo_Request proto.InternalMessageInfo

const Default_Request_Name string = "fubar"

func (m *Request) GetIds() []int32 {
	if m != nil {
		return m.Ids
	}
	return nil
}

func (m *Request) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return Default_Request_Name
}

func (m *Request) GetExtras() *Request_Extras {
	if m != nil {
		return m.Extras
	}
	return nil
}

type isRequest_Abc interface {
	isRequest_Abc()
}

type Request_This struct {
	This string `protobuf:"bytes,4,opt,name=this,oneof"`
}

type Request_That struct {
	That int32 `protobuf:"varint,5,opt,name=that,oneof"`
}

func (*Request_This) isRequest_Abc() {}

func (*Request_That) isRequest_Abc() {}

func (m *Request) GetAbc() isRequest_Abc {
	if m != nil {
		return m.Abc
	}
	return nil
}

func (m *Request) GetThis() string {
	if x, ok := m.GetAbc().(*Request_This); ok {
		return x.This
	}
	return ""
}

func (m *Request) GetThat() int32 {
	if x, ok := m.GetAbc().(*Request_That); ok {
		return x.That
	}
	return 0
}

type isRequest_Xyz interface {
	isRequest_Xyz()
}

type Request_These struct {
	These string `protobuf:"bytes,6,opt,name=these,oneof"`
}

type Request_Those struct {
	Those int32 `protobuf:"varint,7,opt,name=those,oneof"`
}

func (*Request_These) isRequest_Xyz() {}

func (*Request_Those) isRequest_Xyz() {}

func (m *Request) GetXyz() isRequest_Xyz {
	if m != nil {
		return m.Xyz
	}
	return nil
}

func (m *Request) GetThese() string {
	if x, ok := m.GetXyz().(*Request_These); ok {
		return x.These
	}
	return ""
}

func (m *Request) GetThose() int32 {
	if x, ok := m.GetXyz().(*Request_Those); ok {
		return x.Those
	}
	return 0
}

func (m *Request) GetThings() map[string]string {
	if m != nil {
		return m.Things
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Request) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Request_This)(nil),
		(*Request_That)(nil),
		(*Request_These)(nil),
		(*Request_Those)(nil),
	}
}

// Group comment
type Request_Extras struct {
	Dbl *float64 `protobuf:"fixed64,1,opt,name=dbl" json:"dbl,omitempty"`
	Flt *float32 `protobuf:"fixed32,2,opt,name=flt" json:"flt,omitempty"`
	// Leading comment...
	Str                  *string  `protobuf:"bytes,3,opt,name=str" json:"str,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Request_Extras) Reset()         { *m = Request_Extras{} }
func (m *Request_Extras) String() string { return proto.CompactTextString(m) }
func (*Request_Extras) ProtoMessage()    {}
func (*Request_Extras) Descriptor() ([]byte, []int) {
	return fileDescriptor_62dea87c686ed756, []int{0, 0}
}

func (m *Request_Extras) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Request_Extras.Unmarshal(m, b)
}
func (m *Request_Extras) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Request_Extras.Marshal(b, m, deterministic)
}
func (m *Request_Extras) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Request_Extras.Merge(m, src)
}
func (m *Request_Extras) XXX_Size() int {
	return xxx_messageInfo_Request_Extras.Size(m)
}
func (m *Request_Extras) XXX_DiscardUnknown() {
	xxx_messageInfo_Request_Extras.DiscardUnknown(m)
}

var xxx_messageInfo_Request_Extras proto.InternalMessageInfo

func (m *Request_Extras) GetDbl() float64 {
	if m != nil && m.Dbl != nil {
		return *m.Dbl
	}
	return 0
}

func (m *Request_Extras) GetFlt() float32 {
	if m != nil && m.Flt != nil {
		return *m.Flt
	}
	return 0
}

func (m *Request_Extras) GetStr() string {
	if m != nil && m.Str != nil {
		return *m.Str
	}
	return ""
}

type AnEmptyMessage struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AnEmptyMessage) Reset()         { *m = AnEmptyMessage{} }
func (m *AnEmptyMessage) String() string { return proto.CompactTextString(m) }
func (*AnEmptyMessage) ProtoMessage()    {}
func (*AnEmptyMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_62dea87c686ed756, []int{1}
}

func (m *AnEmptyMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AnEmptyMessage.Unmarshal(m, b)
}
func (m *AnEmptyMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AnEmptyMessage.Marshal(b, m, deterministic)
}
func (m *AnEmptyMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AnEmptyMessage.Merge(m, src)
}
func (m *AnEmptyMessage) XXX_Size() int {
	return xxx_messageInfo_AnEmptyMessage.Size(m)
}
func (m *AnEmptyMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_AnEmptyMessage.DiscardUnknown(m)
}

var xxx_messageInfo_AnEmptyMessage proto.InternalMessageInfo

var E_Guid1 = &proto.ExtensionDesc{
	ExtendedType:  (*Request)(nil),
	ExtensionType: (*uint64)(nil),
	Field:         123,
	Name:          "foo.bar.guid1",
	Tag:           "varint,123,opt,name=guid1",
	Filename:      "desc_test_comments.proto",
}

var E_Guid2 = &proto.ExtensionDesc{
	ExtendedType:  (*Request)(nil),
	ExtensionType: (*uint64)(nil),
	Field:         124,
	Name:          "foo.bar.guid2",
	Tag:           "varint,124,opt,name=guid2",
	Filename:      "desc_test_comments.proto",
}

func init() {
	proto.RegisterEnum("foo.bar.Request_MarioCharacters", Request_MarioCharacters_name, Request_MarioCharacters_value)
	proto.RegisterType((*Request)(nil), "foo.bar.Request")
	proto.RegisterMapType((map[string]string)(nil), "foo.bar.Request.ThingsEntry")
	proto.RegisterType((*Request_Extras)(nil), "foo.bar.Request.Extras")
	proto.RegisterType((*AnEmptyMessage)(nil), "foo.bar.AnEmptyMessage")
	proto.RegisterExtension(E_Guid1)
	proto.RegisterExtension(E_Guid2)
}

func init() { proto.RegisterFile("desc_test_comments.proto", fileDescriptor_62dea87c686ed756) }

var fileDescriptor_62dea87c686ed756 = []byte{
	// 785 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x54, 0x4f, 0x6f, 0x1b, 0x45,
	0x14, 0xf7, 0x78, 0x67, 0xd6, 0xeb, 0x67, 0xfe, 0x8c, 0x86, 0x26, 0x5d, 0xb6, 0xa8, 0x32, 0x11,
	0x02, 0xab, 0x87, 0xb5, 0xea, 0x72, 0x80, 0x9c, 0x70, 0x2a, 0x37, 0x76, 0x83, 0x71, 0x35, 0x6e,
	0x14, 0x85, 0x03, 0xd1, 0xec, 0x7a, 0x6c, 0x2f, 0xd8, 0x3b, 0x66, 0x67, 0x5c, 0xe2, 0x34, 0x17,
	0x6e, 0xfd, 0x04, 0x5c, 0x38, 0x70, 0x41, 0x22, 0x8a, 0x84, 0x14, 0x7a, 0xe3, 0x82, 0xe0, 0x46,
	0xbe, 0x00, 0x37, 0x3e, 0x05, 0x87, 0x3d, 0x70, 0x00, 0xed, 0xae, 0xab, 0x22, 0x92, 0xb9, 0xcc,
	0x7b, 0xbf, 0xf7, 0x7b, 0xbf, 0x79, 0x6f, 0xf4, 0x66, 0xc0, 0x1d, 0x49, 0x1d, 0x1e, 0x19, 0xa9,
	0xcd, 0x51, 0xa8, 0xe6, 0x73, 0x19, 0x1b, 0xed, 0x2f, 0x12, 0x65, 0x14, 0xab, 0x8c, 0x95, 0xf2,
	0x03, 0x91, 0x78, 0xb7, 0x26, 0x4a, 0x4d, 0x66, 0xb2, 0x99, 0xc3, 0xc1, 0x72, 0xdc, 0x94, 0xf3,
	0x85, 0x59, 0x15, 0x2c, 0xef, 0xe6, 0xcb, 0x7c, 0xb5, 0x30, 0x91, 0x8a, 0xd7, 0xe9, 0x5b, 0xbf,
	0x11, 0xa8, 0x70, 0xf9, 0xe5, 0x52, 0x6a, 0xc3, 0xde, 0x01, 0x2b, 0x1a, 0x69, 0x17, 0xd5, 0xad,
	0x06, 0xd9, 0xa1, 0xe7, 0x29, 0xb6, 0x44, 0x10, 0x3e, 0x4f, 0xb1, 0x75, 0xbc, 0x3a, 0xa1, 0x88,
	0x93, 0xd3, 0xb1, 0x52, 0xa7, 0xec, 0x4d, 0xc0, 0xb1, 0x98, 0x4b, 0xb7, 0x5c, 0x47, 0x8d, 0xea,
	0x36, 0x19, 0x2f, 0x03, 0x91, 0xf0, 0x1c, 0x62, 0x4d, 0xb0, 0xe5, 0xb1, 0x49, 0x84, 0x76, 0xad,
	0x3a, 0x6a, 0x40, 0xeb, 0xa6, 0xbf, 0x2e, 0xce, 0x5f, 0x1f, 0xe1, 0x77, 0xf2, 0x30, 0x5f, 0xd3,
	0xd8, 0x0d, 0xc0, 0x66, 0x1a, 0x69, 0x17, 0x67, 0x5a, 0xdd, 0x12, 0xcf, 0xbd, 0x02, 0x15, 0xc6,
	0x25, 0x75, 0xd4, 0x20, 0x05, 0x2a, 0x0c, 0xdb, 0x04, 0x62, 0xa6, 0x52, 0x4b, 0xd7, 0xce, 0xc9,
	0x88, 0x17, 0x6e, 0x81, 0x2b, 0x2d, 0xdd, 0x4a, 0x4e, 0xcf, 0x71, 0xa5, 0x25, 0x7b, 0x1f, 0x6c,
	0x33, 0x8d, 0xe2, 0x89, 0x76, 0x9d, 0xba, 0xd5, 0xa8, 0xb5, 0xde, 0xba, 0x52, 0xcc, 0xe3, 0x3c,
	0xdc, 0x89, 0x4d, 0xb2, 0xe2, 0x6b, 0xae, 0xf7, 0x00, 0xec, 0xa2, 0x46, 0x46, 0xc1, 0x1a, 0x05,
	0x33, 0x17, 0xd5, 0x51, 0x03, 0xf1, 0xcc, 0xcc, 0x90, 0xf1, 0xcc, 0xe4, 0x8d, 0x97, 0x79, 0x66,
	0x66, 0x88, 0x36, 0x49, 0xde, 0x6d, 0x95, 0x67, 0xe6, 0xb6, 0x7d, 0x96, 0xe2, 0x12, 0x2d, 0x79,
	0x1f, 0x42, 0xed, 0x3f, 0xf2, 0x19, 0xf1, 0x0b, 0xb9, 0xca, 0xc5, 0xaa, 0x3c, 0x33, 0xd9, 0x0d,
	0x20, 0x4f, 0xc4, 0x6c, 0xb9, 0xbe, 0x47, 0x5e, 0x38, 0xdb, 0xe5, 0x0f, 0xd0, 0xd6, 0x1f, 0x08,
	0x5e, 0xef, 0x8b, 0x24, 0x52, 0xf7, 0xa7, 0x22, 0x11, 0xa1, 0x91, 0x89, 0x66, 0x1b, 0x40, 0xfa,
	0x6d, 0xde, 0x1b, 0x50, 0xe4, 0xc1, 0x59, 0x8a, 0xbf, 0x29, 0x5f, 0xa4, 0xf8, 0x2f, 0xcc, 0x6e,
	0x01, 0xf9, 0x78, 0xbf, 0xb7, 0xdb, 0xa3, 0x65, 0x8f, 0xfe, 0x9a, 0xe2, 0xdf, 0xd1, 0x65, 0x8a,
	0x47, 0xa5, 0x62, 0xb1, 0x2a, 0x90, 0x47, 0x9d, 0xf6, 0xfd, 0x2e, 0xb5, 0x18, 0x80, 0xbd, 0x33,
	0x38, 0x18, 0x76, 0x38, 0xc5, 0x19, 0x7c, 0x90, 0x4b, 0x11, 0x56, 0x83, 0xca, 0x41, 0xbb, 0x10,
	0xb0, 0x99, 0x0b, 0x95, 0x61, 0xf7, 0xf0, 0x68, 0x77, 0xff, 0x90, 0x56, 0xbc, 0xda, 0xcf, 0x29,
	0x5e, 0xbe, 0xb7, 0x16, 0x02, 0xb0, 0xbb, 0x9d, 0xc3, 0xa3, 0xee, 0x80, 0x56, 0xd8, 0xab, 0x50,
	0xed, 0xb7, 0x77, 0x7b, 0x7b, 0x83, 0xc1, 0xa3, 0x36, 0x75, 0x32, 0xb1, 0xbd, 0x76, 0xbf, 0xb3,
	0x47, 0x1d, 0xf6, 0x06, 0xd8, 0xc3, 0x4f, 0x7a, 0x0f, 0x7a, 0x8f, 0xe9, 0xb7, 0xff, 0xac, 0x17,
	0xf2, 0x6a, 0x67, 0x29, 0x7e, 0x7a, 0x91, 0xe2, 0xaf, 0x09, 0x45, 0x77, 0x88, 0x33, 0xa2, 0x97,
	0xe8, 0xce, 0x6d, 0xe7, 0x12, 0xd1, 0xbf, 0x91, 0xb7, 0x79, 0x9e, 0x62, 0x5b, 0x2f, 0x66, 0xc2,
	0xbc, 0xfd, 0x3c, 0xc5, 0x4e, 0x09, 0x95, 0x2d, 0x4c, 0xec, 0x4a, 0x7e, 0x85, 0xc8, 0x45, 0x3b,
	0x04, 0xb2, 0xf9, 0xcb, 0xb6, 0xe3, 0xd5, 0xc9, 0x43, 0xec, 0x00, 0xdd, 0x78, 0x88, 0x9d, 0xdb,
	0xf4, 0x1e, 0xb7, 0xc6, 0x4a, 0x71, 0x2b, 0x9b, 0x3b, 0x2b, 0x10, 0x27, 0x5b, 0x14, 0x5e, 0x6b,
	0xc7, 0x9d, 0x6c, 0xda, 0xfb, 0x52, 0x6b, 0x31, 0x91, 0xad, 0x1f, 0x10, 0x00, 0x5f, 0x84, 0x43,
	0x99, 0x3c, 0x89, 0xc2, 0x6c, 0x14, 0x5e, 0x19, 0x9a, 0x44, 0x8a, 0x79, 0x14, 0x4f, 0xf8, 0x22,
	0x64, 0xf4, 0xff, 0xa3, 0xe0, 0x5d, 0x41, 0x1a, 0x88, 0xed, 0x81, 0xb3, 0x1f, 0x8b, 0x64, 0x75,
	0x7d, 0xc6, 0xa6, 0x5f, 0xbc, 0x37, 0xff, 0xc5, 0x7b, 0xf3, 0xf3, 0x0a, 0xb6, 0x36, 0x7e, 0x4c,
	0xf1, 0xf7, 0x8b, 0x4e, 0xfb, 0xa7, 0x14, 0x7f, 0xf5, 0xcb, 0x77, 0x5e, 0xf3, 0xcf, 0xcf, 0x3e,
	0x7a, 0x56, 0x2e, 0x9a, 0x2d, 0x3b, 0xa3, 0xf3, 0x14, 0x13, 0x66, 0x05, 0x2a, 0xb8, 0x48, 0x31,
	0x7a, 0x56, 0x2e, 0x6d, 0xbf, 0x0b, 0x64, 0xb2, 0x8c, 0x46, 0x77, 0xaf, 0x9e, 0xe0, 0x3e, 0xad,
	0xa3, 0x06, 0xe6, 0x45, 0xf8, 0x05, 0xaf, 0x75, 0x0d, 0xef, 0xf4, 0x25, 0xaf, 0xb5, 0x73, 0xef,
	0xd3, 0xbb, 0x93, 0xc8, 0x4c, 0x97, 0x81, 0x1f, 0xaa, 0x79, 0xf3, 0xf3, 0xe9, 0x72, 0xbe, 0x28,
	0x7e, 0x84, 0x44, 0x8e, 0x67, 0x32, 0x34, 0xcd, 0x28, 0x36, 0x32, 0x89, 0xc5, 0xac, 0x99, 0x7d,
	0x06, 0x79, 0x44, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xb0, 0x33, 0x20, 0x0a, 0x5e, 0x04, 0x00,
	0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// RpcServiceClient is the client API for RpcService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RpcServiceClient interface {
	// Method comment
	StreamingRpc(ctx context.Context, opts ...grpc.CallOption) (RpcService_StreamingRpcClient, error)
	UnaryRpc(ctx context.Context, in *Request, opts ...grpc.CallOption) (*empty.Empty, error)
}

type rpcServiceClient struct {
	cc *grpc.ClientConn
}

func NewRpcServiceClient(cc *grpc.ClientConn) RpcServiceClient {
	return &rpcServiceClient{cc}
}

func (c *rpcServiceClient) StreamingRpc(ctx context.Context, opts ...grpc.CallOption) (RpcService_StreamingRpcClient, error) {
	stream, err := c.cc.NewStream(ctx, &_RpcService_serviceDesc.Streams[0], "/foo.bar.RpcService/StreamingRpc", opts...)
	if err != nil {
		return nil, err
	}
	x := &rpcServiceStreamingRpcClient{stream}
	return x, nil
}

type RpcService_StreamingRpcClient interface {
	Send(*Request) error
	CloseAndRecv() (*Request, error)
	grpc.ClientStream
}

type rpcServiceStreamingRpcClient struct {
	grpc.ClientStream
}

func (x *rpcServiceStreamingRpcClient) Send(m *Request) error {
	return x.ClientStream.SendMsg(m)
}

func (x *rpcServiceStreamingRpcClient) CloseAndRecv() (*Request, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(Request)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Deprecated: Do not use.
func (c *rpcServiceClient) UnaryRpc(ctx context.Context, in *Request, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/foo.bar.RpcService/UnaryRpc", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RpcServiceServer is the server API for RpcService service.
type RpcServiceServer interface {
	// Method comment
	StreamingRpc(RpcService_StreamingRpcServer) error
	UnaryRpc(context.Context, *Request) (*empty.Empty, error)
}

func RegisterRpcServiceServer(s *grpc.Server, srv RpcServiceServer) {
	s.RegisterService(&_RpcService_serviceDesc, srv)
}

func _RpcService_StreamingRpc_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RpcServiceServer).StreamingRpc(&rpcServiceStreamingRpcServer{stream})
}

type RpcService_StreamingRpcServer interface {
	SendAndClose(*Request) error
	Recv() (*Request, error)
	grpc.ServerStream
}

type rpcServiceStreamingRpcServer struct {
	grpc.ServerStream
}

func (x *rpcServiceStreamingRpcServer) SendAndClose(m *Request) error {
	return x.ServerStream.SendMsg(m)
}

func (x *rpcServiceStreamingRpcServer) Recv() (*Request, error) {
	m := new(Request)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _RpcService_UnaryRpc_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RpcServiceServer).UnaryRpc(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/foo.bar.RpcService/UnaryRpc",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RpcServiceServer).UnaryRpc(ctx, req.(*Request))
	}
	return interceptor(ctx, in, info, handler)
}

var _RpcService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "foo.bar.RpcService",
	HandlerType: (*RpcServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "UnaryRpc",
			Handler:    _RpcService_UnaryRpc_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamingRpc",
			Handler:       _RpcService_StreamingRpc_Handler,
			ClientStreams: true,
		},
	},
	Metadata: "desc_test_comments.proto",
}