vendor/google.golang.org/grpc/benchmark/grpc_testing/payloads.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: payloads.proto
   3
   4 package grpc_testing
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9
  10 // Reference imports to suppress errors if they are not otherwise used.
  11 var _ = proto.Marshal
  12 var _ = fmt.Errorf
  13 var _ = math.Inf
  14
  15 type ByteBufferParams struct {
  16         ReqSize  int32 `protobuf:"varint,1,opt,name=req_size,json=reqSize" json:"req_size,omitempty"`
  17         RespSize int32 `protobuf:"varint,2,opt,name=resp_size,json=respSize" json:"resp_size,omitempty"`
  18 }
  19
  20 func (m *ByteBufferParams) Reset()                    { *m = ByteBufferParams{} }
  21 func (m *ByteBufferParams) String() string            { return proto.CompactTextString(m) }
  22 func (*ByteBufferParams) ProtoMessage()               {}
  23 func (*ByteBufferParams) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
  24
  25 func (m *ByteBufferParams) GetReqSize() int32 {
  26         if m != nil {
  27                 return m.ReqSize
  28         }
  29         return 0
  30 }
  31
  32 func (m *ByteBufferParams) GetRespSize() int32 {
  33         if m != nil {
  34                 return m.RespSize
  35         }
  36         return 0
  37 }
  38
  39 type SimpleProtoParams struct {
  40         ReqSize  int32 `protobuf:"varint,1,opt,name=req_size,json=reqSize" json:"req_size,omitempty"`
  41         RespSize int32 `protobuf:"varint,2,opt,name=resp_size,json=respSize" json:"resp_size,omitempty"`
  42 }
  43
  44 func (m *SimpleProtoParams) Reset()                    { *m = SimpleProtoParams{} }
  45 func (m *SimpleProtoParams) String() string            { return proto.CompactTextString(m) }
  46 func (*SimpleProtoParams) ProtoMessage()               {}
  47 func (*SimpleProtoParams) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
  48
  49 func (m *SimpleProtoParams) GetReqSize() int32 {
  50         if m != nil {
  51                 return m.ReqSize
  52         }
  53         return 0
  54 }
  55
  56 func (m *SimpleProtoParams) GetRespSize() int32 {
  57         if m != nil {
  58                 return m.RespSize
  59         }
  60         return 0
  61 }
  62
  63 type ComplexProtoParams struct {
  64 }
  65
  66 func (m *ComplexProtoParams) Reset()                    { *m = ComplexProtoParams{} }
  67 func (m *ComplexProtoParams) String() string            { return proto.CompactTextString(m) }
  68 func (*ComplexProtoParams) ProtoMessage()               {}
  69 func (*ComplexProtoParams) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} }
  70
  71 type PayloadConfig struct {
  72         // Types that are valid to be assigned to Payload:
  73         //      *PayloadConfig_BytebufParams
  74         //      *PayloadConfig_SimpleParams
  75         //      *PayloadConfig_ComplexParams
  76         Payload isPayloadConfig_Payload `protobuf_oneof:"payload"`
  77 }
  78
  79 func (m *PayloadConfig) Reset()                    { *m = PayloadConfig{} }
  80 func (m *PayloadConfig) String() string            { return proto.CompactTextString(m) }
  81 func (*PayloadConfig) ProtoMessage()               {}
  82 func (*PayloadConfig) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} }
  83
  84 type isPayloadConfig_Payload interface {
  85         isPayloadConfig_Payload()
  86 }
  87
  88 type PayloadConfig_BytebufParams struct {
  89         BytebufParams *ByteBufferParams `protobuf:"bytes,1,opt,name=bytebuf_params,json=bytebufParams,oneof"`
  90 }
  91 type PayloadConfig_SimpleParams struct {
  92         SimpleParams *SimpleProtoParams `protobuf:"bytes,2,opt,name=simple_params,json=simpleParams,oneof"`
  93 }
  94 type PayloadConfig_ComplexParams struct {
  95         ComplexParams *ComplexProtoParams `protobuf:"bytes,3,opt,name=complex_params,json=complexParams,oneof"`
  96 }
  97
  98 func (*PayloadConfig_BytebufParams) isPayloadConfig_Payload() {}
  99 func (*PayloadConfig_SimpleParams) isPayloadConfig_Payload()  {}
 100 func (*PayloadConfig_ComplexParams) isPayloadConfig_Payload() {}
 101
 102 func (m *PayloadConfig) GetPayload() isPayloadConfig_Payload {
 103         if m != nil {
 104                 return m.Payload
 105         }
 106         return nil
 107 }
 108
 109 func (m *PayloadConfig) GetBytebufParams() *ByteBufferParams {
 110         if x, ok := m.GetPayload().(*PayloadConfig_BytebufParams); ok {
 111                 return x.BytebufParams
 112         }
 113         return nil
 114 }
 115
 116 func (m *PayloadConfig) GetSimpleParams() *SimpleProtoParams {
 117         if x, ok := m.GetPayload().(*PayloadConfig_SimpleParams); ok {
 118                 return x.SimpleParams
 119         }
 120         return nil
 121 }
 122
 123 func (m *PayloadConfig) GetComplexParams() *ComplexProtoParams {
 124         if x, ok := m.GetPayload().(*PayloadConfig_ComplexParams); ok {
 125                 return x.ComplexParams
 126         }
 127         return nil
 128 }
 129
 130 // XXX_OneofFuncs is for the internal use of the proto package.
 131 func (*PayloadConfig) 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{}) {
 132         return _PayloadConfig_OneofMarshaler, _PayloadConfig_OneofUnmarshaler, _PayloadConfig_OneofSizer, []interface{}{
 133                 (*PayloadConfig_BytebufParams)(nil),
 134                 (*PayloadConfig_SimpleParams)(nil),
 135                 (*PayloadConfig_ComplexParams)(nil),
 136         }
 137 }
 138
 139 func _PayloadConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 140         m := msg.(*PayloadConfig)
 141         // payload
 142         switch x := m.Payload.(type) {
 143         case *PayloadConfig_BytebufParams:
 144                 b.EncodeVarint(1<<3 | proto.WireBytes)
 145                 if err := b.EncodeMessage(x.BytebufParams); err != nil {
 146                         return err
 147                 }
 148         case *PayloadConfig_SimpleParams:
 149                 b.EncodeVarint(2<<3 | proto.WireBytes)
 150                 if err := b.EncodeMessage(x.SimpleParams); err != nil {
 151                         return err
 152                 }
 153         case *PayloadConfig_ComplexParams:
 154                 b.EncodeVarint(3<<3 | proto.WireBytes)
 155                 if err := b.EncodeMessage(x.ComplexParams); err != nil {
 156                         return err
 157                 }
 158         case nil:
 159         default:
 160                 return fmt.Errorf("PayloadConfig.Payload has unexpected type %T", x)
 161         }
 162         return nil
 163 }
 164
 165 func _PayloadConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 166         m := msg.(*PayloadConfig)
 167         switch tag {
 168         case 1: // payload.bytebuf_params
 169                 if wire != proto.WireBytes {
 170                         return true, proto.ErrInternalBadWireType
 171                 }
 172                 msg := new(ByteBufferParams)
 173                 err := b.DecodeMessage(msg)
 174                 m.Payload = &PayloadConfig_BytebufParams{msg}
 175                 return true, err
 176         case 2: // payload.simple_params
 177                 if wire != proto.WireBytes {
 178                         return true, proto.ErrInternalBadWireType
 179                 }
 180                 msg := new(SimpleProtoParams)
 181                 err := b.DecodeMessage(msg)
 182                 m.Payload = &PayloadConfig_SimpleParams{msg}
 183                 return true, err
 184         case 3: // payload.complex_params
 185                 if wire != proto.WireBytes {
 186                         return true, proto.ErrInternalBadWireType
 187                 }
 188                 msg := new(ComplexProtoParams)
 189                 err := b.DecodeMessage(msg)
 190                 m.Payload = &PayloadConfig_ComplexParams{msg}
 191                 return true, err
 192         default:
 193                 return false, nil
 194         }
 195 }
 196
 197 func _PayloadConfig_OneofSizer(msg proto.Message) (n int) {
 198         m := msg.(*PayloadConfig)
 199         // payload
 200         switch x := m.Payload.(type) {
 201         case *PayloadConfig_BytebufParams:
 202                 s := proto.Size(x.BytebufParams)
 203                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 204                 n += proto.SizeVarint(uint64(s))
 205                 n += s
 206         case *PayloadConfig_SimpleParams:
 207                 s := proto.Size(x.SimpleParams)
 208                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 209                 n += proto.SizeVarint(uint64(s))
 210                 n += s
 211         case *PayloadConfig_ComplexParams:
 212                 s := proto.Size(x.ComplexParams)
 213                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 214                 n += proto.SizeVarint(uint64(s))
 215                 n += s
 216         case nil:
 217         default:
 218                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 219         }
 220         return n
 221 }
 222
 223 func init() {
 224         proto.RegisterType((*ByteBufferParams)(nil), "grpc.testing.ByteBufferParams")
 225         proto.RegisterType((*SimpleProtoParams)(nil), "grpc.testing.SimpleProtoParams")
 226         proto.RegisterType((*ComplexProtoParams)(nil), "grpc.testing.ComplexProtoParams")
 227         proto.RegisterType((*PayloadConfig)(nil), "grpc.testing.PayloadConfig")
 228 }
 229
 230 func init() { proto.RegisterFile("payloads.proto", fileDescriptor2) }
 231
 232 var fileDescriptor2 = []byte{
 233         // 254 bytes of a gzipped FileDescriptorProto
 234         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2b, 0x48, 0xac, 0xcc,
 235         0xc9, 0x4f, 0x4c, 0x29, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x49, 0x2f, 0x2a, 0x48,
 236         0xd6, 0x2b, 0x49, 0x2d, 0x2e, 0xc9, 0xcc, 0x4b, 0x57, 0xf2, 0xe2, 0x12, 0x70, 0xaa, 0x2c, 0x49,
 237         0x75, 0x2a, 0x4d, 0x4b, 0x4b, 0x2d, 0x0a, 0x48, 0x2c, 0x4a, 0xcc, 0x2d, 0x16, 0x92, 0xe4, 0xe2,
 238         0x28, 0x4a, 0x2d, 0x8c, 0x2f, 0xce, 0xac, 0x4a, 0x95, 0x60, 0x54, 0x60, 0xd4, 0x60, 0x0d, 0x62,
 239         0x2f, 0x4a, 0x2d, 0x0c, 0xce, 0xac, 0x4a, 0x15, 0x92, 0xe6, 0xe2, 0x2c, 0x4a, 0x2d, 0x2e, 0x80,
 240         0xc8, 0x31, 0x81, 0xe5, 0x38, 0x40, 0x02, 0x20, 0x49, 0x25, 0x6f, 0x2e, 0xc1, 0xe0, 0xcc, 0xdc,
 241         0x82, 0x9c, 0xd4, 0x00, 0x90, 0x45, 0x14, 0x1a, 0x26, 0xc2, 0x25, 0xe4, 0x9c, 0x0f, 0x32, 0xac,
 242         0x02, 0xc9, 0x34, 0xa5, 0x6f, 0x8c, 0x5c, 0xbc, 0x01, 0x10, 0xff, 0x38, 0xe7, 0xe7, 0xa5, 0x65,
 243         0xa6, 0x0b, 0xb9, 0x73, 0xf1, 0x25, 0x55, 0x96, 0xa4, 0x26, 0x95, 0xa6, 0xc5, 0x17, 0x80, 0xd5,
 244         0x80, 0x6d, 0xe1, 0x36, 0x92, 0xd3, 0x43, 0xf6, 0xa7, 0x1e, 0xba, 0x27, 0x3d, 0x18, 0x82, 0x78,
 245         0xa1, 0xfa, 0xa0, 0x0e, 0x75, 0xe3, 0xe2, 0x2d, 0x06, 0xbb, 0x1e, 0x66, 0x0e, 0x13, 0xd8, 0x1c,
 246         0x79, 0x54, 0x73, 0x30, 0x3c, 0xe8, 0xc1, 0x10, 0xc4, 0x03, 0xd1, 0x07, 0x35, 0xc7, 0x93, 0x8b,
 247         0x2f, 0x19, 0xe2, 0x70, 0x98, 0x41, 0xcc, 0x60, 0x83, 0x14, 0x50, 0x0d, 0xc2, 0xf4, 0x1c, 0xc8,
 248         0x49, 0x50, 0x9d, 0x10, 0x01, 0x27, 0x4e, 0x2e, 0x76, 0x68, 0xe4, 0x25, 0xb1, 0x81, 0x23, 0xcf,
 249         0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xb0, 0x8c, 0x18, 0x4e, 0xce, 0x01, 0x00, 0x00,
 250 }