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