1// Code generated by protoc-gen-gogo. DO NOT EDIT.
2// source: pkg/storage/stores/shipper/indexgateway/indexgatewaypb/gateway.proto
3
4package indexgatewaypb
5
6import (
7	bytes "bytes"
8	context "context"
9	fmt "fmt"
10	proto "github.com/gogo/protobuf/proto"
11	grpc "google.golang.org/grpc"
12	codes "google.golang.org/grpc/codes"
13	status "google.golang.org/grpc/status"
14	io "io"
15	math "math"
16	math_bits "math/bits"
17	reflect "reflect"
18	strings "strings"
19)
20
21// Reference imports to suppress errors if they are not otherwise used.
22var _ = proto.Marshal
23var _ = fmt.Errorf
24var _ = math.Inf
25
26// This is a compile-time assertion to ensure that this generated file
27// is compatible with the proto package it is being compiled against.
28// A compilation error at this line likely means your copy of the
29// proto package needs to be updated.
30const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
31
32type QueryIndexResponse struct {
33	QueryKey string `protobuf:"bytes,1,opt,name=QueryKey,proto3" json:"QueryKey,omitempty"`
34	Rows     []*Row `protobuf:"bytes,2,rep,name=rows,proto3" json:"rows,omitempty"`
35}
36
37func (m *QueryIndexResponse) Reset()      { *m = QueryIndexResponse{} }
38func (*QueryIndexResponse) ProtoMessage() {}
39func (*QueryIndexResponse) Descriptor() ([]byte, []int) {
40	return fileDescriptor_33a7bd4603d312b2, []int{0}
41}
42func (m *QueryIndexResponse) XXX_Unmarshal(b []byte) error {
43	return m.Unmarshal(b)
44}
45func (m *QueryIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
46	if deterministic {
47		return xxx_messageInfo_QueryIndexResponse.Marshal(b, m, deterministic)
48	} else {
49		b = b[:cap(b)]
50		n, err := m.MarshalToSizedBuffer(b)
51		if err != nil {
52			return nil, err
53		}
54		return b[:n], nil
55	}
56}
57func (m *QueryIndexResponse) XXX_Merge(src proto.Message) {
58	xxx_messageInfo_QueryIndexResponse.Merge(m, src)
59}
60func (m *QueryIndexResponse) XXX_Size() int {
61	return m.Size()
62}
63func (m *QueryIndexResponse) XXX_DiscardUnknown() {
64	xxx_messageInfo_QueryIndexResponse.DiscardUnknown(m)
65}
66
67var xxx_messageInfo_QueryIndexResponse proto.InternalMessageInfo
68
69func (m *QueryIndexResponse) GetQueryKey() string {
70	if m != nil {
71		return m.QueryKey
72	}
73	return ""
74}
75
76func (m *QueryIndexResponse) GetRows() []*Row {
77	if m != nil {
78		return m.Rows
79	}
80	return nil
81}
82
83type Row struct {
84	RangeValue []byte `protobuf:"bytes,1,opt,name=rangeValue,proto3" json:"rangeValue,omitempty"`
85	Value      []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
86}
87
88func (m *Row) Reset()      { *m = Row{} }
89func (*Row) ProtoMessage() {}
90func (*Row) Descriptor() ([]byte, []int) {
91	return fileDescriptor_33a7bd4603d312b2, []int{1}
92}
93func (m *Row) XXX_Unmarshal(b []byte) error {
94	return m.Unmarshal(b)
95}
96func (m *Row) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
97	if deterministic {
98		return xxx_messageInfo_Row.Marshal(b, m, deterministic)
99	} else {
100		b = b[:cap(b)]
101		n, err := m.MarshalToSizedBuffer(b)
102		if err != nil {
103			return nil, err
104		}
105		return b[:n], nil
106	}
107}
108func (m *Row) XXX_Merge(src proto.Message) {
109	xxx_messageInfo_Row.Merge(m, src)
110}
111func (m *Row) XXX_Size() int {
112	return m.Size()
113}
114func (m *Row) XXX_DiscardUnknown() {
115	xxx_messageInfo_Row.DiscardUnknown(m)
116}
117
118var xxx_messageInfo_Row proto.InternalMessageInfo
119
120func (m *Row) GetRangeValue() []byte {
121	if m != nil {
122		return m.RangeValue
123	}
124	return nil
125}
126
127func (m *Row) GetValue() []byte {
128	if m != nil {
129		return m.Value
130	}
131	return nil
132}
133
134type QueryIndexRequest struct {
135	Queries []*IndexQuery `protobuf:"bytes,1,rep,name=Queries,proto3" json:"Queries,omitempty"`
136}
137
138func (m *QueryIndexRequest) Reset()      { *m = QueryIndexRequest{} }
139func (*QueryIndexRequest) ProtoMessage() {}
140func (*QueryIndexRequest) Descriptor() ([]byte, []int) {
141	return fileDescriptor_33a7bd4603d312b2, []int{2}
142}
143func (m *QueryIndexRequest) XXX_Unmarshal(b []byte) error {
144	return m.Unmarshal(b)
145}
146func (m *QueryIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
147	if deterministic {
148		return xxx_messageInfo_QueryIndexRequest.Marshal(b, m, deterministic)
149	} else {
150		b = b[:cap(b)]
151		n, err := m.MarshalToSizedBuffer(b)
152		if err != nil {
153			return nil, err
154		}
155		return b[:n], nil
156	}
157}
158func (m *QueryIndexRequest) XXX_Merge(src proto.Message) {
159	xxx_messageInfo_QueryIndexRequest.Merge(m, src)
160}
161func (m *QueryIndexRequest) XXX_Size() int {
162	return m.Size()
163}
164func (m *QueryIndexRequest) XXX_DiscardUnknown() {
165	xxx_messageInfo_QueryIndexRequest.DiscardUnknown(m)
166}
167
168var xxx_messageInfo_QueryIndexRequest proto.InternalMessageInfo
169
170func (m *QueryIndexRequest) GetQueries() []*IndexQuery {
171	if m != nil {
172		return m.Queries
173	}
174	return nil
175}
176
177type IndexQuery struct {
178	TableName        string `protobuf:"bytes,1,opt,name=tableName,proto3" json:"tableName,omitempty"`
179	HashValue        string `protobuf:"bytes,2,opt,name=hashValue,proto3" json:"hashValue,omitempty"`
180	RangeValuePrefix []byte `protobuf:"bytes,3,opt,name=rangeValuePrefix,proto3" json:"rangeValuePrefix,omitempty"`
181	RangeValueStart  []byte `protobuf:"bytes,4,opt,name=rangeValueStart,proto3" json:"rangeValueStart,omitempty"`
182	ValueEqual       []byte `protobuf:"bytes,5,opt,name=valueEqual,proto3" json:"valueEqual,omitempty"`
183}
184
185func (m *IndexQuery) Reset()      { *m = IndexQuery{} }
186func (*IndexQuery) ProtoMessage() {}
187func (*IndexQuery) Descriptor() ([]byte, []int) {
188	return fileDescriptor_33a7bd4603d312b2, []int{3}
189}
190func (m *IndexQuery) XXX_Unmarshal(b []byte) error {
191	return m.Unmarshal(b)
192}
193func (m *IndexQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
194	if deterministic {
195		return xxx_messageInfo_IndexQuery.Marshal(b, m, deterministic)
196	} else {
197		b = b[:cap(b)]
198		n, err := m.MarshalToSizedBuffer(b)
199		if err != nil {
200			return nil, err
201		}
202		return b[:n], nil
203	}
204}
205func (m *IndexQuery) XXX_Merge(src proto.Message) {
206	xxx_messageInfo_IndexQuery.Merge(m, src)
207}
208func (m *IndexQuery) XXX_Size() int {
209	return m.Size()
210}
211func (m *IndexQuery) XXX_DiscardUnknown() {
212	xxx_messageInfo_IndexQuery.DiscardUnknown(m)
213}
214
215var xxx_messageInfo_IndexQuery proto.InternalMessageInfo
216
217func (m *IndexQuery) GetTableName() string {
218	if m != nil {
219		return m.TableName
220	}
221	return ""
222}
223
224func (m *IndexQuery) GetHashValue() string {
225	if m != nil {
226		return m.HashValue
227	}
228	return ""
229}
230
231func (m *IndexQuery) GetRangeValuePrefix() []byte {
232	if m != nil {
233		return m.RangeValuePrefix
234	}
235	return nil
236}
237
238func (m *IndexQuery) GetRangeValueStart() []byte {
239	if m != nil {
240		return m.RangeValueStart
241	}
242	return nil
243}
244
245func (m *IndexQuery) GetValueEqual() []byte {
246	if m != nil {
247		return m.ValueEqual
248	}
249	return nil
250}
251
252func init() {
253	proto.RegisterType((*QueryIndexResponse)(nil), "indexgatewaypb.QueryIndexResponse")
254	proto.RegisterType((*Row)(nil), "indexgatewaypb.Row")
255	proto.RegisterType((*QueryIndexRequest)(nil), "indexgatewaypb.QueryIndexRequest")
256	proto.RegisterType((*IndexQuery)(nil), "indexgatewaypb.IndexQuery")
257}
258
259func init() {
260	proto.RegisterFile("pkg/storage/stores/shipper/indexgateway/indexgatewaypb/gateway.proto", fileDescriptor_33a7bd4603d312b2)
261}
262
263var fileDescriptor_33a7bd4603d312b2 = []byte{
264	// 390 bytes of a gzipped FileDescriptorProto
265	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0xbb, 0x4e, 0xe3, 0x40,
266	0x14, 0x86, 0x3d, 0xb9, 0xec, 0x6e, 0xce, 0x46, 0x7b, 0x99, 0xdd, 0xc2, 0x8a, 0x56, 0xa3, 0xac,
267	0x9b, 0x8d, 0xb6, 0x88, 0x51, 0x48, 0x47, 0x87, 0x40, 0x28, 0x42, 0x42, 0x30, 0x88, 0x48, 0x94,
268	0x13, 0x71, 0x70, 0x2c, 0x42, 0xec, 0xcc, 0xd8, 0x38, 0xe9, 0x78, 0x04, 0x1e, 0x83, 0xa7, 0xa0,
269	0xa6, 0x4c, 0x99, 0x92, 0x38, 0x0d, 0x65, 0x1e, 0x01, 0x79, 0x1c, 0xe2, 0x5c, 0x24, 0x2a, 0xfb,
270	0x7c, 0xe7, 0xf7, 0x9c, 0xff, 0xfc, 0x1e, 0x38, 0xf0, 0x6f, 0x1c, 0x5b, 0x05, 0x9e, 0x14, 0x0e,
271	0xea, 0x27, 0x2a, 0x5b, 0x75, 0x5d, 0xdf, 0x47, 0x69, 0xbb, 0xfd, 0x2b, 0x1c, 0x3a, 0x22, 0xc0,
272	0x48, 0x8c, 0xd6, 0x0a, 0xbf, 0x63, 0x2f, 0xde, 0xea, 0xbe, 0xf4, 0x02, 0x8f, 0x7e, 0x5b, 0xef,
273	0x5a, 0x97, 0x40, 0xcf, 0x42, 0x94, 0xa3, 0x56, 0x82, 0x39, 0x2a, 0xdf, 0xeb, 0x2b, 0xa4, 0x15,
274	0xf8, 0xa2, 0xe9, 0x31, 0x8e, 0x4c, 0x52, 0x25, 0xb5, 0x12, 0x5f, 0xd6, 0xf4, 0x1f, 0x14, 0xa4,
275	0x17, 0x29, 0x33, 0x57, 0xcd, 0xd7, 0xbe, 0x36, 0x7e, 0xd5, 0xd7, 0x0f, 0xac, 0x73, 0x2f, 0xe2,
276	0x5a, 0x60, 0xed, 0x41, 0x9e, 0x7b, 0x11, 0x65, 0x00, 0x52, 0xf4, 0x1d, 0x6c, 0x8b, 0x5e, 0x88,
277	0xfa, 0xb4, 0x32, 0x5f, 0x21, 0xf4, 0x37, 0x14, 0xef, 0x74, 0x2b, 0xa7, 0x5b, 0x69, 0x61, 0xb5,
278	0xe0, 0xe7, 0xaa, 0xaf, 0x41, 0x88, 0x2a, 0xa0, 0x4d, 0xf8, 0x9c, 0x40, 0x17, 0x95, 0x49, 0xf4,
279	0xf4, 0xca, 0xe6, 0x74, 0x2d, 0xd7, 0x1f, 0xf2, 0x77, 0xa9, 0xf5, 0x44, 0x00, 0x32, 0x4e, 0xff,
280	0x40, 0x29, 0x10, 0x9d, 0x1e, 0x9e, 0x88, 0x5b, 0x5c, 0x2c, 0x97, 0x81, 0xa4, 0xdb, 0x15, 0xaa,
281	0xdb, 0x5e, 0x3a, 0x2a, 0xf1, 0x0c, 0xd0, 0xff, 0xf0, 0x23, 0x73, 0x7e, 0x2a, 0xf1, 0xda, 0x1d,
282	0x9a, 0x79, 0x6d, 0x7b, 0x8b, 0xd3, 0x1a, 0x7c, 0xcf, 0xd8, 0x79, 0x20, 0x64, 0x60, 0x16, 0xb4,
283	0x74, 0x13, 0x27, 0x09, 0xe9, 0xa5, 0x0f, 0x07, 0xa1, 0xe8, 0x99, 0xc5, 0x34, 0xa1, 0x8c, 0x34,
284	0x10, 0xca, 0xda, 0xff, 0x51, 0xba, 0x26, 0xbd, 0x00, 0xc8, 0xb2, 0xa1, 0x7f, 0x37, 0x33, 0xd8,
285	0xca, 0xad, 0x62, 0x7d, 0x24, 0x49, 0x7f, 0xf9, 0x0e, 0xd9, 0x6f, 0x8e, 0xa7, 0xcc, 0x98, 0x4c,
286	0x99, 0x31, 0x9f, 0x32, 0x72, 0x1f, 0x33, 0xf2, 0x18, 0x33, 0xf2, 0x1c, 0x33, 0x32, 0x8e, 0x19,
287	0x79, 0x89, 0x19, 0x79, 0x8d, 0x99, 0x31, 0x8f, 0x19, 0x79, 0x98, 0x31, 0x63, 0x3c, 0x63, 0xc6,
288	0x64, 0xc6, 0x8c, 0xce, 0x27, 0x7d, 0xaf, 0x76, 0xdf, 0x02, 0x00, 0x00, 0xff, 0xff, 0x95, 0x3c,
289	0x4e, 0x5e, 0x9f, 0x02, 0x00, 0x00,
290}
291
292func (this *QueryIndexResponse) Equal(that interface{}) bool {
293	if that == nil {
294		return this == nil
295	}
296
297	that1, ok := that.(*QueryIndexResponse)
298	if !ok {
299		that2, ok := that.(QueryIndexResponse)
300		if ok {
301			that1 = &that2
302		} else {
303			return false
304		}
305	}
306	if that1 == nil {
307		return this == nil
308	} else if this == nil {
309		return false
310	}
311	if this.QueryKey != that1.QueryKey {
312		return false
313	}
314	if len(this.Rows) != len(that1.Rows) {
315		return false
316	}
317	for i := range this.Rows {
318		if !this.Rows[i].Equal(that1.Rows[i]) {
319			return false
320		}
321	}
322	return true
323}
324func (this *Row) Equal(that interface{}) bool {
325	if that == nil {
326		return this == nil
327	}
328
329	that1, ok := that.(*Row)
330	if !ok {
331		that2, ok := that.(Row)
332		if ok {
333			that1 = &that2
334		} else {
335			return false
336		}
337	}
338	if that1 == nil {
339		return this == nil
340	} else if this == nil {
341		return false
342	}
343	if !bytes.Equal(this.RangeValue, that1.RangeValue) {
344		return false
345	}
346	if !bytes.Equal(this.Value, that1.Value) {
347		return false
348	}
349	return true
350}
351func (this *QueryIndexRequest) Equal(that interface{}) bool {
352	if that == nil {
353		return this == nil
354	}
355
356	that1, ok := that.(*QueryIndexRequest)
357	if !ok {
358		that2, ok := that.(QueryIndexRequest)
359		if ok {
360			that1 = &that2
361		} else {
362			return false
363		}
364	}
365	if that1 == nil {
366		return this == nil
367	} else if this == nil {
368		return false
369	}
370	if len(this.Queries) != len(that1.Queries) {
371		return false
372	}
373	for i := range this.Queries {
374		if !this.Queries[i].Equal(that1.Queries[i]) {
375			return false
376		}
377	}
378	return true
379}
380func (this *IndexQuery) Equal(that interface{}) bool {
381	if that == nil {
382		return this == nil
383	}
384
385	that1, ok := that.(*IndexQuery)
386	if !ok {
387		that2, ok := that.(IndexQuery)
388		if ok {
389			that1 = &that2
390		} else {
391			return false
392		}
393	}
394	if that1 == nil {
395		return this == nil
396	} else if this == nil {
397		return false
398	}
399	if this.TableName != that1.TableName {
400		return false
401	}
402	if this.HashValue != that1.HashValue {
403		return false
404	}
405	if !bytes.Equal(this.RangeValuePrefix, that1.RangeValuePrefix) {
406		return false
407	}
408	if !bytes.Equal(this.RangeValueStart, that1.RangeValueStart) {
409		return false
410	}
411	if !bytes.Equal(this.ValueEqual, that1.ValueEqual) {
412		return false
413	}
414	return true
415}
416func (this *QueryIndexResponse) GoString() string {
417	if this == nil {
418		return "nil"
419	}
420	s := make([]string, 0, 6)
421	s = append(s, "&indexgatewaypb.QueryIndexResponse{")
422	s = append(s, "QueryKey: "+fmt.Sprintf("%#v", this.QueryKey)+",\n")
423	if this.Rows != nil {
424		s = append(s, "Rows: "+fmt.Sprintf("%#v", this.Rows)+",\n")
425	}
426	s = append(s, "}")
427	return strings.Join(s, "")
428}
429func (this *Row) GoString() string {
430	if this == nil {
431		return "nil"
432	}
433	s := make([]string, 0, 6)
434	s = append(s, "&indexgatewaypb.Row{")
435	s = append(s, "RangeValue: "+fmt.Sprintf("%#v", this.RangeValue)+",\n")
436	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
437	s = append(s, "}")
438	return strings.Join(s, "")
439}
440func (this *QueryIndexRequest) GoString() string {
441	if this == nil {
442		return "nil"
443	}
444	s := make([]string, 0, 5)
445	s = append(s, "&indexgatewaypb.QueryIndexRequest{")
446	if this.Queries != nil {
447		s = append(s, "Queries: "+fmt.Sprintf("%#v", this.Queries)+",\n")
448	}
449	s = append(s, "}")
450	return strings.Join(s, "")
451}
452func (this *IndexQuery) GoString() string {
453	if this == nil {
454		return "nil"
455	}
456	s := make([]string, 0, 9)
457	s = append(s, "&indexgatewaypb.IndexQuery{")
458	s = append(s, "TableName: "+fmt.Sprintf("%#v", this.TableName)+",\n")
459	s = append(s, "HashValue: "+fmt.Sprintf("%#v", this.HashValue)+",\n")
460	s = append(s, "RangeValuePrefix: "+fmt.Sprintf("%#v", this.RangeValuePrefix)+",\n")
461	s = append(s, "RangeValueStart: "+fmt.Sprintf("%#v", this.RangeValueStart)+",\n")
462	s = append(s, "ValueEqual: "+fmt.Sprintf("%#v", this.ValueEqual)+",\n")
463	s = append(s, "}")
464	return strings.Join(s, "")
465}
466func valueToGoStringGateway(v interface{}, typ string) string {
467	rv := reflect.ValueOf(v)
468	if rv.IsNil() {
469		return "nil"
470	}
471	pv := reflect.Indirect(rv).Interface()
472	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
473}
474
475// Reference imports to suppress errors if they are not otherwise used.
476var _ context.Context
477var _ grpc.ClientConn
478
479// This is a compile-time assertion to ensure that this generated file
480// is compatible with the grpc package it is being compiled against.
481const _ = grpc.SupportPackageIsVersion4
482
483// IndexGatewayClient is the client API for IndexGateway service.
484//
485// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
486type IndexGatewayClient interface {
487	/// QueryIndex reads the indexes required for given query & sends back the batch of rows
488	/// in rpc streams
489	QueryIndex(ctx context.Context, in *QueryIndexRequest, opts ...grpc.CallOption) (IndexGateway_QueryIndexClient, error)
490}
491
492type indexGatewayClient struct {
493	cc *grpc.ClientConn
494}
495
496func NewIndexGatewayClient(cc *grpc.ClientConn) IndexGatewayClient {
497	return &indexGatewayClient{cc}
498}
499
500func (c *indexGatewayClient) QueryIndex(ctx context.Context, in *QueryIndexRequest, opts ...grpc.CallOption) (IndexGateway_QueryIndexClient, error) {
501	stream, err := c.cc.NewStream(ctx, &_IndexGateway_serviceDesc.Streams[0], "/indexgatewaypb.IndexGateway/QueryIndex", opts...)
502	if err != nil {
503		return nil, err
504	}
505	x := &indexGatewayQueryIndexClient{stream}
506	if err := x.ClientStream.SendMsg(in); err != nil {
507		return nil, err
508	}
509	if err := x.ClientStream.CloseSend(); err != nil {
510		return nil, err
511	}
512	return x, nil
513}
514
515type IndexGateway_QueryIndexClient interface {
516	Recv() (*QueryIndexResponse, error)
517	grpc.ClientStream
518}
519
520type indexGatewayQueryIndexClient struct {
521	grpc.ClientStream
522}
523
524func (x *indexGatewayQueryIndexClient) Recv() (*QueryIndexResponse, error) {
525	m := new(QueryIndexResponse)
526	if err := x.ClientStream.RecvMsg(m); err != nil {
527		return nil, err
528	}
529	return m, nil
530}
531
532// IndexGatewayServer is the server API for IndexGateway service.
533type IndexGatewayServer interface {
534	/// QueryIndex reads the indexes required for given query & sends back the batch of rows
535	/// in rpc streams
536	QueryIndex(*QueryIndexRequest, IndexGateway_QueryIndexServer) error
537}
538
539// UnimplementedIndexGatewayServer can be embedded to have forward compatible implementations.
540type UnimplementedIndexGatewayServer struct {
541}
542
543func (*UnimplementedIndexGatewayServer) QueryIndex(req *QueryIndexRequest, srv IndexGateway_QueryIndexServer) error {
544	return status.Errorf(codes.Unimplemented, "method QueryIndex not implemented")
545}
546
547func RegisterIndexGatewayServer(s *grpc.Server, srv IndexGatewayServer) {
548	s.RegisterService(&_IndexGateway_serviceDesc, srv)
549}
550
551func _IndexGateway_QueryIndex_Handler(srv interface{}, stream grpc.ServerStream) error {
552	m := new(QueryIndexRequest)
553	if err := stream.RecvMsg(m); err != nil {
554		return err
555	}
556	return srv.(IndexGatewayServer).QueryIndex(m, &indexGatewayQueryIndexServer{stream})
557}
558
559type IndexGateway_QueryIndexServer interface {
560	Send(*QueryIndexResponse) error
561	grpc.ServerStream
562}
563
564type indexGatewayQueryIndexServer struct {
565	grpc.ServerStream
566}
567
568func (x *indexGatewayQueryIndexServer) Send(m *QueryIndexResponse) error {
569	return x.ServerStream.SendMsg(m)
570}
571
572var _IndexGateway_serviceDesc = grpc.ServiceDesc{
573	ServiceName: "indexgatewaypb.IndexGateway",
574	HandlerType: (*IndexGatewayServer)(nil),
575	Methods:     []grpc.MethodDesc{},
576	Streams: []grpc.StreamDesc{
577		{
578			StreamName:    "QueryIndex",
579			Handler:       _IndexGateway_QueryIndex_Handler,
580			ServerStreams: true,
581		},
582	},
583	Metadata: "pkg/storage/stores/shipper/indexgateway/indexgatewaypb/gateway.proto",
584}
585
586func (m *QueryIndexResponse) Marshal() (dAtA []byte, err error) {
587	size := m.Size()
588	dAtA = make([]byte, size)
589	n, err := m.MarshalToSizedBuffer(dAtA[:size])
590	if err != nil {
591		return nil, err
592	}
593	return dAtA[:n], nil
594}
595
596func (m *QueryIndexResponse) MarshalTo(dAtA []byte) (int, error) {
597	size := m.Size()
598	return m.MarshalToSizedBuffer(dAtA[:size])
599}
600
601func (m *QueryIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
602	i := len(dAtA)
603	_ = i
604	var l int
605	_ = l
606	if len(m.Rows) > 0 {
607		for iNdEx := len(m.Rows) - 1; iNdEx >= 0; iNdEx-- {
608			{
609				size, err := m.Rows[iNdEx].MarshalToSizedBuffer(dAtA[:i])
610				if err != nil {
611					return 0, err
612				}
613				i -= size
614				i = encodeVarintGateway(dAtA, i, uint64(size))
615			}
616			i--
617			dAtA[i] = 0x12
618		}
619	}
620	if len(m.QueryKey) > 0 {
621		i -= len(m.QueryKey)
622		copy(dAtA[i:], m.QueryKey)
623		i = encodeVarintGateway(dAtA, i, uint64(len(m.QueryKey)))
624		i--
625		dAtA[i] = 0xa
626	}
627	return len(dAtA) - i, nil
628}
629
630func (m *Row) Marshal() (dAtA []byte, err error) {
631	size := m.Size()
632	dAtA = make([]byte, size)
633	n, err := m.MarshalToSizedBuffer(dAtA[:size])
634	if err != nil {
635		return nil, err
636	}
637	return dAtA[:n], nil
638}
639
640func (m *Row) MarshalTo(dAtA []byte) (int, error) {
641	size := m.Size()
642	return m.MarshalToSizedBuffer(dAtA[:size])
643}
644
645func (m *Row) MarshalToSizedBuffer(dAtA []byte) (int, error) {
646	i := len(dAtA)
647	_ = i
648	var l int
649	_ = l
650	if len(m.Value) > 0 {
651		i -= len(m.Value)
652		copy(dAtA[i:], m.Value)
653		i = encodeVarintGateway(dAtA, i, uint64(len(m.Value)))
654		i--
655		dAtA[i] = 0x12
656	}
657	if len(m.RangeValue) > 0 {
658		i -= len(m.RangeValue)
659		copy(dAtA[i:], m.RangeValue)
660		i = encodeVarintGateway(dAtA, i, uint64(len(m.RangeValue)))
661		i--
662		dAtA[i] = 0xa
663	}
664	return len(dAtA) - i, nil
665}
666
667func (m *QueryIndexRequest) Marshal() (dAtA []byte, err error) {
668	size := m.Size()
669	dAtA = make([]byte, size)
670	n, err := m.MarshalToSizedBuffer(dAtA[:size])
671	if err != nil {
672		return nil, err
673	}
674	return dAtA[:n], nil
675}
676
677func (m *QueryIndexRequest) MarshalTo(dAtA []byte) (int, error) {
678	size := m.Size()
679	return m.MarshalToSizedBuffer(dAtA[:size])
680}
681
682func (m *QueryIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
683	i := len(dAtA)
684	_ = i
685	var l int
686	_ = l
687	if len(m.Queries) > 0 {
688		for iNdEx := len(m.Queries) - 1; iNdEx >= 0; iNdEx-- {
689			{
690				size, err := m.Queries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
691				if err != nil {
692					return 0, err
693				}
694				i -= size
695				i = encodeVarintGateway(dAtA, i, uint64(size))
696			}
697			i--
698			dAtA[i] = 0xa
699		}
700	}
701	return len(dAtA) - i, nil
702}
703
704func (m *IndexQuery) Marshal() (dAtA []byte, err error) {
705	size := m.Size()
706	dAtA = make([]byte, size)
707	n, err := m.MarshalToSizedBuffer(dAtA[:size])
708	if err != nil {
709		return nil, err
710	}
711	return dAtA[:n], nil
712}
713
714func (m *IndexQuery) MarshalTo(dAtA []byte) (int, error) {
715	size := m.Size()
716	return m.MarshalToSizedBuffer(dAtA[:size])
717}
718
719func (m *IndexQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
720	i := len(dAtA)
721	_ = i
722	var l int
723	_ = l
724	if len(m.ValueEqual) > 0 {
725		i -= len(m.ValueEqual)
726		copy(dAtA[i:], m.ValueEqual)
727		i = encodeVarintGateway(dAtA, i, uint64(len(m.ValueEqual)))
728		i--
729		dAtA[i] = 0x2a
730	}
731	if len(m.RangeValueStart) > 0 {
732		i -= len(m.RangeValueStart)
733		copy(dAtA[i:], m.RangeValueStart)
734		i = encodeVarintGateway(dAtA, i, uint64(len(m.RangeValueStart)))
735		i--
736		dAtA[i] = 0x22
737	}
738	if len(m.RangeValuePrefix) > 0 {
739		i -= len(m.RangeValuePrefix)
740		copy(dAtA[i:], m.RangeValuePrefix)
741		i = encodeVarintGateway(dAtA, i, uint64(len(m.RangeValuePrefix)))
742		i--
743		dAtA[i] = 0x1a
744	}
745	if len(m.HashValue) > 0 {
746		i -= len(m.HashValue)
747		copy(dAtA[i:], m.HashValue)
748		i = encodeVarintGateway(dAtA, i, uint64(len(m.HashValue)))
749		i--
750		dAtA[i] = 0x12
751	}
752	if len(m.TableName) > 0 {
753		i -= len(m.TableName)
754		copy(dAtA[i:], m.TableName)
755		i = encodeVarintGateway(dAtA, i, uint64(len(m.TableName)))
756		i--
757		dAtA[i] = 0xa
758	}
759	return len(dAtA) - i, nil
760}
761
762func encodeVarintGateway(dAtA []byte, offset int, v uint64) int {
763	offset -= sovGateway(v)
764	base := offset
765	for v >= 1<<7 {
766		dAtA[offset] = uint8(v&0x7f | 0x80)
767		v >>= 7
768		offset++
769	}
770	dAtA[offset] = uint8(v)
771	return base
772}
773func (m *QueryIndexResponse) Size() (n int) {
774	if m == nil {
775		return 0
776	}
777	var l int
778	_ = l
779	l = len(m.QueryKey)
780	if l > 0 {
781		n += 1 + l + sovGateway(uint64(l))
782	}
783	if len(m.Rows) > 0 {
784		for _, e := range m.Rows {
785			l = e.Size()
786			n += 1 + l + sovGateway(uint64(l))
787		}
788	}
789	return n
790}
791
792func (m *Row) Size() (n int) {
793	if m == nil {
794		return 0
795	}
796	var l int
797	_ = l
798	l = len(m.RangeValue)
799	if l > 0 {
800		n += 1 + l + sovGateway(uint64(l))
801	}
802	l = len(m.Value)
803	if l > 0 {
804		n += 1 + l + sovGateway(uint64(l))
805	}
806	return n
807}
808
809func (m *QueryIndexRequest) Size() (n int) {
810	if m == nil {
811		return 0
812	}
813	var l int
814	_ = l
815	if len(m.Queries) > 0 {
816		for _, e := range m.Queries {
817			l = e.Size()
818			n += 1 + l + sovGateway(uint64(l))
819		}
820	}
821	return n
822}
823
824func (m *IndexQuery) Size() (n int) {
825	if m == nil {
826		return 0
827	}
828	var l int
829	_ = l
830	l = len(m.TableName)
831	if l > 0 {
832		n += 1 + l + sovGateway(uint64(l))
833	}
834	l = len(m.HashValue)
835	if l > 0 {
836		n += 1 + l + sovGateway(uint64(l))
837	}
838	l = len(m.RangeValuePrefix)
839	if l > 0 {
840		n += 1 + l + sovGateway(uint64(l))
841	}
842	l = len(m.RangeValueStart)
843	if l > 0 {
844		n += 1 + l + sovGateway(uint64(l))
845	}
846	l = len(m.ValueEqual)
847	if l > 0 {
848		n += 1 + l + sovGateway(uint64(l))
849	}
850	return n
851}
852
853func sovGateway(x uint64) (n int) {
854	return (math_bits.Len64(x|1) + 6) / 7
855}
856func sozGateway(x uint64) (n int) {
857	return sovGateway(uint64((x << 1) ^ uint64((int64(x) >> 63))))
858}
859func (this *QueryIndexResponse) String() string {
860	if this == nil {
861		return "nil"
862	}
863	repeatedStringForRows := "[]*Row{"
864	for _, f := range this.Rows {
865		repeatedStringForRows += strings.Replace(f.String(), "Row", "Row", 1) + ","
866	}
867	repeatedStringForRows += "}"
868	s := strings.Join([]string{`&QueryIndexResponse{`,
869		`QueryKey:` + fmt.Sprintf("%v", this.QueryKey) + `,`,
870		`Rows:` + repeatedStringForRows + `,`,
871		`}`,
872	}, "")
873	return s
874}
875func (this *Row) String() string {
876	if this == nil {
877		return "nil"
878	}
879	s := strings.Join([]string{`&Row{`,
880		`RangeValue:` + fmt.Sprintf("%v", this.RangeValue) + `,`,
881		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
882		`}`,
883	}, "")
884	return s
885}
886func (this *QueryIndexRequest) String() string {
887	if this == nil {
888		return "nil"
889	}
890	repeatedStringForQueries := "[]*IndexQuery{"
891	for _, f := range this.Queries {
892		repeatedStringForQueries += strings.Replace(f.String(), "IndexQuery", "IndexQuery", 1) + ","
893	}
894	repeatedStringForQueries += "}"
895	s := strings.Join([]string{`&QueryIndexRequest{`,
896		`Queries:` + repeatedStringForQueries + `,`,
897		`}`,
898	}, "")
899	return s
900}
901func (this *IndexQuery) String() string {
902	if this == nil {
903		return "nil"
904	}
905	s := strings.Join([]string{`&IndexQuery{`,
906		`TableName:` + fmt.Sprintf("%v", this.TableName) + `,`,
907		`HashValue:` + fmt.Sprintf("%v", this.HashValue) + `,`,
908		`RangeValuePrefix:` + fmt.Sprintf("%v", this.RangeValuePrefix) + `,`,
909		`RangeValueStart:` + fmt.Sprintf("%v", this.RangeValueStart) + `,`,
910		`ValueEqual:` + fmt.Sprintf("%v", this.ValueEqual) + `,`,
911		`}`,
912	}, "")
913	return s
914}
915func valueToStringGateway(v interface{}) string {
916	rv := reflect.ValueOf(v)
917	if rv.IsNil() {
918		return "nil"
919	}
920	pv := reflect.Indirect(rv).Interface()
921	return fmt.Sprintf("*%v", pv)
922}
923func (m *QueryIndexResponse) Unmarshal(dAtA []byte) error {
924	l := len(dAtA)
925	iNdEx := 0
926	for iNdEx < l {
927		preIndex := iNdEx
928		var wire uint64
929		for shift := uint(0); ; shift += 7 {
930			if shift >= 64 {
931				return ErrIntOverflowGateway
932			}
933			if iNdEx >= l {
934				return io.ErrUnexpectedEOF
935			}
936			b := dAtA[iNdEx]
937			iNdEx++
938			wire |= uint64(b&0x7F) << shift
939			if b < 0x80 {
940				break
941			}
942		}
943		fieldNum := int32(wire >> 3)
944		wireType := int(wire & 0x7)
945		if wireType == 4 {
946			return fmt.Errorf("proto: QueryIndexResponse: wiretype end group for non-group")
947		}
948		if fieldNum <= 0 {
949			return fmt.Errorf("proto: QueryIndexResponse: illegal tag %d (wire type %d)", fieldNum, wire)
950		}
951		switch fieldNum {
952		case 1:
953			if wireType != 2 {
954				return fmt.Errorf("proto: wrong wireType = %d for field QueryKey", wireType)
955			}
956			var stringLen uint64
957			for shift := uint(0); ; shift += 7 {
958				if shift >= 64 {
959					return ErrIntOverflowGateway
960				}
961				if iNdEx >= l {
962					return io.ErrUnexpectedEOF
963				}
964				b := dAtA[iNdEx]
965				iNdEx++
966				stringLen |= uint64(b&0x7F) << shift
967				if b < 0x80 {
968					break
969				}
970			}
971			intStringLen := int(stringLen)
972			if intStringLen < 0 {
973				return ErrInvalidLengthGateway
974			}
975			postIndex := iNdEx + intStringLen
976			if postIndex < 0 {
977				return ErrInvalidLengthGateway
978			}
979			if postIndex > l {
980				return io.ErrUnexpectedEOF
981			}
982			m.QueryKey = string(dAtA[iNdEx:postIndex])
983			iNdEx = postIndex
984		case 2:
985			if wireType != 2 {
986				return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType)
987			}
988			var msglen int
989			for shift := uint(0); ; shift += 7 {
990				if shift >= 64 {
991					return ErrIntOverflowGateway
992				}
993				if iNdEx >= l {
994					return io.ErrUnexpectedEOF
995				}
996				b := dAtA[iNdEx]
997				iNdEx++
998				msglen |= int(b&0x7F) << shift
999				if b < 0x80 {
1000					break
1001				}
1002			}
1003			if msglen < 0 {
1004				return ErrInvalidLengthGateway
1005			}
1006			postIndex := iNdEx + msglen
1007			if postIndex < 0 {
1008				return ErrInvalidLengthGateway
1009			}
1010			if postIndex > l {
1011				return io.ErrUnexpectedEOF
1012			}
1013			m.Rows = append(m.Rows, &Row{})
1014			if err := m.Rows[len(m.Rows)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1015				return err
1016			}
1017			iNdEx = postIndex
1018		default:
1019			iNdEx = preIndex
1020			skippy, err := skipGateway(dAtA[iNdEx:])
1021			if err != nil {
1022				return err
1023			}
1024			if skippy < 0 {
1025				return ErrInvalidLengthGateway
1026			}
1027			if (iNdEx + skippy) < 0 {
1028				return ErrInvalidLengthGateway
1029			}
1030			if (iNdEx + skippy) > l {
1031				return io.ErrUnexpectedEOF
1032			}
1033			iNdEx += skippy
1034		}
1035	}
1036
1037	if iNdEx > l {
1038		return io.ErrUnexpectedEOF
1039	}
1040	return nil
1041}
1042func (m *Row) Unmarshal(dAtA []byte) error {
1043	l := len(dAtA)
1044	iNdEx := 0
1045	for iNdEx < l {
1046		preIndex := iNdEx
1047		var wire uint64
1048		for shift := uint(0); ; shift += 7 {
1049			if shift >= 64 {
1050				return ErrIntOverflowGateway
1051			}
1052			if iNdEx >= l {
1053				return io.ErrUnexpectedEOF
1054			}
1055			b := dAtA[iNdEx]
1056			iNdEx++
1057			wire |= uint64(b&0x7F) << shift
1058			if b < 0x80 {
1059				break
1060			}
1061		}
1062		fieldNum := int32(wire >> 3)
1063		wireType := int(wire & 0x7)
1064		if wireType == 4 {
1065			return fmt.Errorf("proto: Row: wiretype end group for non-group")
1066		}
1067		if fieldNum <= 0 {
1068			return fmt.Errorf("proto: Row: illegal tag %d (wire type %d)", fieldNum, wire)
1069		}
1070		switch fieldNum {
1071		case 1:
1072			if wireType != 2 {
1073				return fmt.Errorf("proto: wrong wireType = %d for field RangeValue", wireType)
1074			}
1075			var byteLen int
1076			for shift := uint(0); ; shift += 7 {
1077				if shift >= 64 {
1078					return ErrIntOverflowGateway
1079				}
1080				if iNdEx >= l {
1081					return io.ErrUnexpectedEOF
1082				}
1083				b := dAtA[iNdEx]
1084				iNdEx++
1085				byteLen |= int(b&0x7F) << shift
1086				if b < 0x80 {
1087					break
1088				}
1089			}
1090			if byteLen < 0 {
1091				return ErrInvalidLengthGateway
1092			}
1093			postIndex := iNdEx + byteLen
1094			if postIndex < 0 {
1095				return ErrInvalidLengthGateway
1096			}
1097			if postIndex > l {
1098				return io.ErrUnexpectedEOF
1099			}
1100			m.RangeValue = append(m.RangeValue[:0], dAtA[iNdEx:postIndex]...)
1101			if m.RangeValue == nil {
1102				m.RangeValue = []byte{}
1103			}
1104			iNdEx = postIndex
1105		case 2:
1106			if wireType != 2 {
1107				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
1108			}
1109			var byteLen int
1110			for shift := uint(0); ; shift += 7 {
1111				if shift >= 64 {
1112					return ErrIntOverflowGateway
1113				}
1114				if iNdEx >= l {
1115					return io.ErrUnexpectedEOF
1116				}
1117				b := dAtA[iNdEx]
1118				iNdEx++
1119				byteLen |= int(b&0x7F) << shift
1120				if b < 0x80 {
1121					break
1122				}
1123			}
1124			if byteLen < 0 {
1125				return ErrInvalidLengthGateway
1126			}
1127			postIndex := iNdEx + byteLen
1128			if postIndex < 0 {
1129				return ErrInvalidLengthGateway
1130			}
1131			if postIndex > l {
1132				return io.ErrUnexpectedEOF
1133			}
1134			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
1135			if m.Value == nil {
1136				m.Value = []byte{}
1137			}
1138			iNdEx = postIndex
1139		default:
1140			iNdEx = preIndex
1141			skippy, err := skipGateway(dAtA[iNdEx:])
1142			if err != nil {
1143				return err
1144			}
1145			if skippy < 0 {
1146				return ErrInvalidLengthGateway
1147			}
1148			if (iNdEx + skippy) < 0 {
1149				return ErrInvalidLengthGateway
1150			}
1151			if (iNdEx + skippy) > l {
1152				return io.ErrUnexpectedEOF
1153			}
1154			iNdEx += skippy
1155		}
1156	}
1157
1158	if iNdEx > l {
1159		return io.ErrUnexpectedEOF
1160	}
1161	return nil
1162}
1163func (m *QueryIndexRequest) Unmarshal(dAtA []byte) error {
1164	l := len(dAtA)
1165	iNdEx := 0
1166	for iNdEx < l {
1167		preIndex := iNdEx
1168		var wire uint64
1169		for shift := uint(0); ; shift += 7 {
1170			if shift >= 64 {
1171				return ErrIntOverflowGateway
1172			}
1173			if iNdEx >= l {
1174				return io.ErrUnexpectedEOF
1175			}
1176			b := dAtA[iNdEx]
1177			iNdEx++
1178			wire |= uint64(b&0x7F) << shift
1179			if b < 0x80 {
1180				break
1181			}
1182		}
1183		fieldNum := int32(wire >> 3)
1184		wireType := int(wire & 0x7)
1185		if wireType == 4 {
1186			return fmt.Errorf("proto: QueryIndexRequest: wiretype end group for non-group")
1187		}
1188		if fieldNum <= 0 {
1189			return fmt.Errorf("proto: QueryIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire)
1190		}
1191		switch fieldNum {
1192		case 1:
1193			if wireType != 2 {
1194				return fmt.Errorf("proto: wrong wireType = %d for field Queries", wireType)
1195			}
1196			var msglen int
1197			for shift := uint(0); ; shift += 7 {
1198				if shift >= 64 {
1199					return ErrIntOverflowGateway
1200				}
1201				if iNdEx >= l {
1202					return io.ErrUnexpectedEOF
1203				}
1204				b := dAtA[iNdEx]
1205				iNdEx++
1206				msglen |= int(b&0x7F) << shift
1207				if b < 0x80 {
1208					break
1209				}
1210			}
1211			if msglen < 0 {
1212				return ErrInvalidLengthGateway
1213			}
1214			postIndex := iNdEx + msglen
1215			if postIndex < 0 {
1216				return ErrInvalidLengthGateway
1217			}
1218			if postIndex > l {
1219				return io.ErrUnexpectedEOF
1220			}
1221			m.Queries = append(m.Queries, &IndexQuery{})
1222			if err := m.Queries[len(m.Queries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1223				return err
1224			}
1225			iNdEx = postIndex
1226		default:
1227			iNdEx = preIndex
1228			skippy, err := skipGateway(dAtA[iNdEx:])
1229			if err != nil {
1230				return err
1231			}
1232			if skippy < 0 {
1233				return ErrInvalidLengthGateway
1234			}
1235			if (iNdEx + skippy) < 0 {
1236				return ErrInvalidLengthGateway
1237			}
1238			if (iNdEx + skippy) > l {
1239				return io.ErrUnexpectedEOF
1240			}
1241			iNdEx += skippy
1242		}
1243	}
1244
1245	if iNdEx > l {
1246		return io.ErrUnexpectedEOF
1247	}
1248	return nil
1249}
1250func (m *IndexQuery) Unmarshal(dAtA []byte) error {
1251	l := len(dAtA)
1252	iNdEx := 0
1253	for iNdEx < l {
1254		preIndex := iNdEx
1255		var wire uint64
1256		for shift := uint(0); ; shift += 7 {
1257			if shift >= 64 {
1258				return ErrIntOverflowGateway
1259			}
1260			if iNdEx >= l {
1261				return io.ErrUnexpectedEOF
1262			}
1263			b := dAtA[iNdEx]
1264			iNdEx++
1265			wire |= uint64(b&0x7F) << shift
1266			if b < 0x80 {
1267				break
1268			}
1269		}
1270		fieldNum := int32(wire >> 3)
1271		wireType := int(wire & 0x7)
1272		if wireType == 4 {
1273			return fmt.Errorf("proto: IndexQuery: wiretype end group for non-group")
1274		}
1275		if fieldNum <= 0 {
1276			return fmt.Errorf("proto: IndexQuery: illegal tag %d (wire type %d)", fieldNum, wire)
1277		}
1278		switch fieldNum {
1279		case 1:
1280			if wireType != 2 {
1281				return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType)
1282			}
1283			var stringLen uint64
1284			for shift := uint(0); ; shift += 7 {
1285				if shift >= 64 {
1286					return ErrIntOverflowGateway
1287				}
1288				if iNdEx >= l {
1289					return io.ErrUnexpectedEOF
1290				}
1291				b := dAtA[iNdEx]
1292				iNdEx++
1293				stringLen |= uint64(b&0x7F) << shift
1294				if b < 0x80 {
1295					break
1296				}
1297			}
1298			intStringLen := int(stringLen)
1299			if intStringLen < 0 {
1300				return ErrInvalidLengthGateway
1301			}
1302			postIndex := iNdEx + intStringLen
1303			if postIndex < 0 {
1304				return ErrInvalidLengthGateway
1305			}
1306			if postIndex > l {
1307				return io.ErrUnexpectedEOF
1308			}
1309			m.TableName = string(dAtA[iNdEx:postIndex])
1310			iNdEx = postIndex
1311		case 2:
1312			if wireType != 2 {
1313				return fmt.Errorf("proto: wrong wireType = %d for field HashValue", wireType)
1314			}
1315			var stringLen uint64
1316			for shift := uint(0); ; shift += 7 {
1317				if shift >= 64 {
1318					return ErrIntOverflowGateway
1319				}
1320				if iNdEx >= l {
1321					return io.ErrUnexpectedEOF
1322				}
1323				b := dAtA[iNdEx]
1324				iNdEx++
1325				stringLen |= uint64(b&0x7F) << shift
1326				if b < 0x80 {
1327					break
1328				}
1329			}
1330			intStringLen := int(stringLen)
1331			if intStringLen < 0 {
1332				return ErrInvalidLengthGateway
1333			}
1334			postIndex := iNdEx + intStringLen
1335			if postIndex < 0 {
1336				return ErrInvalidLengthGateway
1337			}
1338			if postIndex > l {
1339				return io.ErrUnexpectedEOF
1340			}
1341			m.HashValue = string(dAtA[iNdEx:postIndex])
1342			iNdEx = postIndex
1343		case 3:
1344			if wireType != 2 {
1345				return fmt.Errorf("proto: wrong wireType = %d for field RangeValuePrefix", wireType)
1346			}
1347			var byteLen int
1348			for shift := uint(0); ; shift += 7 {
1349				if shift >= 64 {
1350					return ErrIntOverflowGateway
1351				}
1352				if iNdEx >= l {
1353					return io.ErrUnexpectedEOF
1354				}
1355				b := dAtA[iNdEx]
1356				iNdEx++
1357				byteLen |= int(b&0x7F) << shift
1358				if b < 0x80 {
1359					break
1360				}
1361			}
1362			if byteLen < 0 {
1363				return ErrInvalidLengthGateway
1364			}
1365			postIndex := iNdEx + byteLen
1366			if postIndex < 0 {
1367				return ErrInvalidLengthGateway
1368			}
1369			if postIndex > l {
1370				return io.ErrUnexpectedEOF
1371			}
1372			m.RangeValuePrefix = append(m.RangeValuePrefix[:0], dAtA[iNdEx:postIndex]...)
1373			if m.RangeValuePrefix == nil {
1374				m.RangeValuePrefix = []byte{}
1375			}
1376			iNdEx = postIndex
1377		case 4:
1378			if wireType != 2 {
1379				return fmt.Errorf("proto: wrong wireType = %d for field RangeValueStart", wireType)
1380			}
1381			var byteLen int
1382			for shift := uint(0); ; shift += 7 {
1383				if shift >= 64 {
1384					return ErrIntOverflowGateway
1385				}
1386				if iNdEx >= l {
1387					return io.ErrUnexpectedEOF
1388				}
1389				b := dAtA[iNdEx]
1390				iNdEx++
1391				byteLen |= int(b&0x7F) << shift
1392				if b < 0x80 {
1393					break
1394				}
1395			}
1396			if byteLen < 0 {
1397				return ErrInvalidLengthGateway
1398			}
1399			postIndex := iNdEx + byteLen
1400			if postIndex < 0 {
1401				return ErrInvalidLengthGateway
1402			}
1403			if postIndex > l {
1404				return io.ErrUnexpectedEOF
1405			}
1406			m.RangeValueStart = append(m.RangeValueStart[:0], dAtA[iNdEx:postIndex]...)
1407			if m.RangeValueStart == nil {
1408				m.RangeValueStart = []byte{}
1409			}
1410			iNdEx = postIndex
1411		case 5:
1412			if wireType != 2 {
1413				return fmt.Errorf("proto: wrong wireType = %d for field ValueEqual", wireType)
1414			}
1415			var byteLen int
1416			for shift := uint(0); ; shift += 7 {
1417				if shift >= 64 {
1418					return ErrIntOverflowGateway
1419				}
1420				if iNdEx >= l {
1421					return io.ErrUnexpectedEOF
1422				}
1423				b := dAtA[iNdEx]
1424				iNdEx++
1425				byteLen |= int(b&0x7F) << shift
1426				if b < 0x80 {
1427					break
1428				}
1429			}
1430			if byteLen < 0 {
1431				return ErrInvalidLengthGateway
1432			}
1433			postIndex := iNdEx + byteLen
1434			if postIndex < 0 {
1435				return ErrInvalidLengthGateway
1436			}
1437			if postIndex > l {
1438				return io.ErrUnexpectedEOF
1439			}
1440			m.ValueEqual = append(m.ValueEqual[:0], dAtA[iNdEx:postIndex]...)
1441			if m.ValueEqual == nil {
1442				m.ValueEqual = []byte{}
1443			}
1444			iNdEx = postIndex
1445		default:
1446			iNdEx = preIndex
1447			skippy, err := skipGateway(dAtA[iNdEx:])
1448			if err != nil {
1449				return err
1450			}
1451			if skippy < 0 {
1452				return ErrInvalidLengthGateway
1453			}
1454			if (iNdEx + skippy) < 0 {
1455				return ErrInvalidLengthGateway
1456			}
1457			if (iNdEx + skippy) > l {
1458				return io.ErrUnexpectedEOF
1459			}
1460			iNdEx += skippy
1461		}
1462	}
1463
1464	if iNdEx > l {
1465		return io.ErrUnexpectedEOF
1466	}
1467	return nil
1468}
1469func skipGateway(dAtA []byte) (n int, err error) {
1470	l := len(dAtA)
1471	iNdEx := 0
1472	for iNdEx < l {
1473		var wire uint64
1474		for shift := uint(0); ; shift += 7 {
1475			if shift >= 64 {
1476				return 0, ErrIntOverflowGateway
1477			}
1478			if iNdEx >= l {
1479				return 0, io.ErrUnexpectedEOF
1480			}
1481			b := dAtA[iNdEx]
1482			iNdEx++
1483			wire |= (uint64(b) & 0x7F) << shift
1484			if b < 0x80 {
1485				break
1486			}
1487		}
1488		wireType := int(wire & 0x7)
1489		switch wireType {
1490		case 0:
1491			for shift := uint(0); ; shift += 7 {
1492				if shift >= 64 {
1493					return 0, ErrIntOverflowGateway
1494				}
1495				if iNdEx >= l {
1496					return 0, io.ErrUnexpectedEOF
1497				}
1498				iNdEx++
1499				if dAtA[iNdEx-1] < 0x80 {
1500					break
1501				}
1502			}
1503			return iNdEx, nil
1504		case 1:
1505			iNdEx += 8
1506			return iNdEx, nil
1507		case 2:
1508			var length int
1509			for shift := uint(0); ; shift += 7 {
1510				if shift >= 64 {
1511					return 0, ErrIntOverflowGateway
1512				}
1513				if iNdEx >= l {
1514					return 0, io.ErrUnexpectedEOF
1515				}
1516				b := dAtA[iNdEx]
1517				iNdEx++
1518				length |= (int(b) & 0x7F) << shift
1519				if b < 0x80 {
1520					break
1521				}
1522			}
1523			if length < 0 {
1524				return 0, ErrInvalidLengthGateway
1525			}
1526			iNdEx += length
1527			if iNdEx < 0 {
1528				return 0, ErrInvalidLengthGateway
1529			}
1530			return iNdEx, nil
1531		case 3:
1532			for {
1533				var innerWire uint64
1534				var start int = iNdEx
1535				for shift := uint(0); ; shift += 7 {
1536					if shift >= 64 {
1537						return 0, ErrIntOverflowGateway
1538					}
1539					if iNdEx >= l {
1540						return 0, io.ErrUnexpectedEOF
1541					}
1542					b := dAtA[iNdEx]
1543					iNdEx++
1544					innerWire |= (uint64(b) & 0x7F) << shift
1545					if b < 0x80 {
1546						break
1547					}
1548				}
1549				innerWireType := int(innerWire & 0x7)
1550				if innerWireType == 4 {
1551					break
1552				}
1553				next, err := skipGateway(dAtA[start:])
1554				if err != nil {
1555					return 0, err
1556				}
1557				iNdEx = start + next
1558				if iNdEx < 0 {
1559					return 0, ErrInvalidLengthGateway
1560				}
1561			}
1562			return iNdEx, nil
1563		case 4:
1564			return iNdEx, nil
1565		case 5:
1566			iNdEx += 4
1567			return iNdEx, nil
1568		default:
1569			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1570		}
1571	}
1572	panic("unreachable")
1573}
1574
1575var (
1576	ErrInvalidLengthGateway = fmt.Errorf("proto: negative length found during unmarshaling")
1577	ErrIntOverflowGateway   = fmt.Errorf("proto: integer overflow")
1578)
1579