1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: kv.proto 3 4package memberlist 5 6import ( 7 bytes "bytes" 8 fmt "fmt" 9 _ "github.com/gogo/protobuf/gogoproto" 10 proto "github.com/gogo/protobuf/proto" 11 io "io" 12 math "math" 13 math_bits "math/bits" 14 reflect "reflect" 15 strings "strings" 16) 17 18// Reference imports to suppress errors if they are not otherwise used. 19var _ = proto.Marshal 20var _ = fmt.Errorf 21var _ = math.Inf 22 23// This is a compile-time assertion to ensure that this generated file 24// is compatible with the proto package it is being compiled against. 25// A compilation error at this line likely means your copy of the 26// proto package needs to be updated. 27const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 28 29// KV Store is just a series of key-value pairs. 30type KeyValueStore struct { 31 Pairs []*KeyValuePair `protobuf:"bytes,1,rep,name=pairs,proto3" json:"pairs,omitempty"` 32} 33 34func (m *KeyValueStore) Reset() { *m = KeyValueStore{} } 35func (*KeyValueStore) ProtoMessage() {} 36func (*KeyValueStore) Descriptor() ([]byte, []int) { 37 return fileDescriptor_2216fe83c9c12408, []int{0} 38} 39func (m *KeyValueStore) XXX_Unmarshal(b []byte) error { 40 return m.Unmarshal(b) 41} 42func (m *KeyValueStore) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 43 if deterministic { 44 return xxx_messageInfo_KeyValueStore.Marshal(b, m, deterministic) 45 } else { 46 b = b[:cap(b)] 47 n, err := m.MarshalToSizedBuffer(b) 48 if err != nil { 49 return nil, err 50 } 51 return b[:n], nil 52 } 53} 54func (m *KeyValueStore) XXX_Merge(src proto.Message) { 55 xxx_messageInfo_KeyValueStore.Merge(m, src) 56} 57func (m *KeyValueStore) XXX_Size() int { 58 return m.Size() 59} 60func (m *KeyValueStore) XXX_DiscardUnknown() { 61 xxx_messageInfo_KeyValueStore.DiscardUnknown(m) 62} 63 64var xxx_messageInfo_KeyValueStore proto.InternalMessageInfo 65 66func (m *KeyValueStore) GetPairs() []*KeyValuePair { 67 if m != nil { 68 return m.Pairs 69 } 70 return nil 71} 72 73// Single Key-Value pair. Key must be non-empty. 74type KeyValuePair struct { 75 Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` 76 Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` 77 // ID of the codec used to write the value 78 Codec string `protobuf:"bytes,3,opt,name=codec,proto3" json:"codec,omitempty"` 79} 80 81func (m *KeyValuePair) Reset() { *m = KeyValuePair{} } 82func (*KeyValuePair) ProtoMessage() {} 83func (*KeyValuePair) Descriptor() ([]byte, []int) { 84 return fileDescriptor_2216fe83c9c12408, []int{1} 85} 86func (m *KeyValuePair) XXX_Unmarshal(b []byte) error { 87 return m.Unmarshal(b) 88} 89func (m *KeyValuePair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 90 if deterministic { 91 return xxx_messageInfo_KeyValuePair.Marshal(b, m, deterministic) 92 } else { 93 b = b[:cap(b)] 94 n, err := m.MarshalToSizedBuffer(b) 95 if err != nil { 96 return nil, err 97 } 98 return b[:n], nil 99 } 100} 101func (m *KeyValuePair) XXX_Merge(src proto.Message) { 102 xxx_messageInfo_KeyValuePair.Merge(m, src) 103} 104func (m *KeyValuePair) XXX_Size() int { 105 return m.Size() 106} 107func (m *KeyValuePair) XXX_DiscardUnknown() { 108 xxx_messageInfo_KeyValuePair.DiscardUnknown(m) 109} 110 111var xxx_messageInfo_KeyValuePair proto.InternalMessageInfo 112 113func (m *KeyValuePair) GetKey() string { 114 if m != nil { 115 return m.Key 116 } 117 return "" 118} 119 120func (m *KeyValuePair) GetValue() []byte { 121 if m != nil { 122 return m.Value 123 } 124 return nil 125} 126 127func (m *KeyValuePair) GetCodec() string { 128 if m != nil { 129 return m.Codec 130 } 131 return "" 132} 133 134func init() { 135 proto.RegisterType((*KeyValueStore)(nil), "memberlist.KeyValueStore") 136 proto.RegisterType((*KeyValuePair)(nil), "memberlist.KeyValuePair") 137} 138 139func init() { proto.RegisterFile("kv.proto", fileDescriptor_2216fe83c9c12408) } 140 141var fileDescriptor_2216fe83c9c12408 = []byte{ 142 // 236 bytes of a gzipped FileDescriptorProto 143 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xc8, 0x2e, 0xd3, 0x2b, 144 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0xca, 0x4d, 0xcd, 0x4d, 0x4a, 0x2d, 0xca, 0xc9, 0x2c, 0x2e, 145 0x91, 0xd2, 0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0x4f, 146 0xcf, 0xd7, 0x07, 0x2b, 0x49, 0x2a, 0x4d, 0x03, 0xf3, 0xc0, 0x1c, 0x30, 0x0b, 0xa2, 0x55, 0xc9, 147 0x9e, 0x8b, 0xd7, 0x3b, 0xb5, 0x32, 0x2c, 0x31, 0xa7, 0x34, 0x35, 0xb8, 0x24, 0xbf, 0x28, 0x55, 148 0x48, 0x8f, 0x8b, 0xb5, 0x20, 0x31, 0xb3, 0xa8, 0x58, 0x82, 0x51, 0x81, 0x59, 0x83, 0xdb, 0x48, 149 0x42, 0x0f, 0x61, 0xb6, 0x1e, 0x4c, 0x65, 0x40, 0x62, 0x66, 0x51, 0x10, 0x44, 0x99, 0x92, 0x0f, 150 0x17, 0x0f, 0xb2, 0xb0, 0x90, 0x00, 0x17, 0x73, 0x76, 0x6a, 0xa5, 0x04, 0xa3, 0x02, 0xa3, 0x06, 151 0x67, 0x10, 0x88, 0x29, 0x24, 0xc2, 0xc5, 0x5a, 0x06, 0x92, 0x96, 0x60, 0x52, 0x60, 0xd4, 0xe0, 152 0x09, 0x82, 0x70, 0x40, 0xa2, 0xc9, 0xf9, 0x29, 0xa9, 0xc9, 0x12, 0xcc, 0x60, 0x95, 0x10, 0x8e, 153 0x93, 0xc9, 0x85, 0x87, 0x72, 0x0c, 0x37, 0x1e, 0xca, 0x31, 0x7c, 0x78, 0x28, 0xc7, 0xd8, 0xf0, 154 0x48, 0x8e, 0x71, 0xc5, 0x23, 0x39, 0xc6, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 155 0xf0, 0x48, 0x8e, 0xf1, 0xc5, 0x23, 0x39, 0x86, 0x0f, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 156 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x24, 0x36, 0xb0, 0x5f, 0x8c, 0x01, 0x01, 157 0x00, 0x00, 0xff, 0xff, 0x7a, 0x22, 0xdf, 0xec, 0x12, 0x01, 0x00, 0x00, 158} 159 160func (this *KeyValueStore) Equal(that interface{}) bool { 161 if that == nil { 162 return this == nil 163 } 164 165 that1, ok := that.(*KeyValueStore) 166 if !ok { 167 that2, ok := that.(KeyValueStore) 168 if ok { 169 that1 = &that2 170 } else { 171 return false 172 } 173 } 174 if that1 == nil { 175 return this == nil 176 } else if this == nil { 177 return false 178 } 179 if len(this.Pairs) != len(that1.Pairs) { 180 return false 181 } 182 for i := range this.Pairs { 183 if !this.Pairs[i].Equal(that1.Pairs[i]) { 184 return false 185 } 186 } 187 return true 188} 189func (this *KeyValuePair) Equal(that interface{}) bool { 190 if that == nil { 191 return this == nil 192 } 193 194 that1, ok := that.(*KeyValuePair) 195 if !ok { 196 that2, ok := that.(KeyValuePair) 197 if ok { 198 that1 = &that2 199 } else { 200 return false 201 } 202 } 203 if that1 == nil { 204 return this == nil 205 } else if this == nil { 206 return false 207 } 208 if this.Key != that1.Key { 209 return false 210 } 211 if !bytes.Equal(this.Value, that1.Value) { 212 return false 213 } 214 if this.Codec != that1.Codec { 215 return false 216 } 217 return true 218} 219func (this *KeyValueStore) GoString() string { 220 if this == nil { 221 return "nil" 222 } 223 s := make([]string, 0, 5) 224 s = append(s, "&memberlist.KeyValueStore{") 225 if this.Pairs != nil { 226 s = append(s, "Pairs: "+fmt.Sprintf("%#v", this.Pairs)+",\n") 227 } 228 s = append(s, "}") 229 return strings.Join(s, "") 230} 231func (this *KeyValuePair) GoString() string { 232 if this == nil { 233 return "nil" 234 } 235 s := make([]string, 0, 7) 236 s = append(s, "&memberlist.KeyValuePair{") 237 s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n") 238 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 239 s = append(s, "Codec: "+fmt.Sprintf("%#v", this.Codec)+",\n") 240 s = append(s, "}") 241 return strings.Join(s, "") 242} 243func valueToGoStringKv(v interface{}, typ string) string { 244 rv := reflect.ValueOf(v) 245 if rv.IsNil() { 246 return "nil" 247 } 248 pv := reflect.Indirect(rv).Interface() 249 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) 250} 251func (m *KeyValueStore) Marshal() (dAtA []byte, err error) { 252 size := m.Size() 253 dAtA = make([]byte, size) 254 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 255 if err != nil { 256 return nil, err 257 } 258 return dAtA[:n], nil 259} 260 261func (m *KeyValueStore) MarshalTo(dAtA []byte) (int, error) { 262 size := m.Size() 263 return m.MarshalToSizedBuffer(dAtA[:size]) 264} 265 266func (m *KeyValueStore) MarshalToSizedBuffer(dAtA []byte) (int, error) { 267 i := len(dAtA) 268 _ = i 269 var l int 270 _ = l 271 if len(m.Pairs) > 0 { 272 for iNdEx := len(m.Pairs) - 1; iNdEx >= 0; iNdEx-- { 273 { 274 size, err := m.Pairs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 275 if err != nil { 276 return 0, err 277 } 278 i -= size 279 i = encodeVarintKv(dAtA, i, uint64(size)) 280 } 281 i-- 282 dAtA[i] = 0xa 283 } 284 } 285 return len(dAtA) - i, nil 286} 287 288func (m *KeyValuePair) Marshal() (dAtA []byte, err error) { 289 size := m.Size() 290 dAtA = make([]byte, size) 291 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 292 if err != nil { 293 return nil, err 294 } 295 return dAtA[:n], nil 296} 297 298func (m *KeyValuePair) MarshalTo(dAtA []byte) (int, error) { 299 size := m.Size() 300 return m.MarshalToSizedBuffer(dAtA[:size]) 301} 302 303func (m *KeyValuePair) MarshalToSizedBuffer(dAtA []byte) (int, error) { 304 i := len(dAtA) 305 _ = i 306 var l int 307 _ = l 308 if len(m.Codec) > 0 { 309 i -= len(m.Codec) 310 copy(dAtA[i:], m.Codec) 311 i = encodeVarintKv(dAtA, i, uint64(len(m.Codec))) 312 i-- 313 dAtA[i] = 0x1a 314 } 315 if len(m.Value) > 0 { 316 i -= len(m.Value) 317 copy(dAtA[i:], m.Value) 318 i = encodeVarintKv(dAtA, i, uint64(len(m.Value))) 319 i-- 320 dAtA[i] = 0x12 321 } 322 if len(m.Key) > 0 { 323 i -= len(m.Key) 324 copy(dAtA[i:], m.Key) 325 i = encodeVarintKv(dAtA, i, uint64(len(m.Key))) 326 i-- 327 dAtA[i] = 0xa 328 } 329 return len(dAtA) - i, nil 330} 331 332func encodeVarintKv(dAtA []byte, offset int, v uint64) int { 333 offset -= sovKv(v) 334 base := offset 335 for v >= 1<<7 { 336 dAtA[offset] = uint8(v&0x7f | 0x80) 337 v >>= 7 338 offset++ 339 } 340 dAtA[offset] = uint8(v) 341 return base 342} 343func (m *KeyValueStore) Size() (n int) { 344 if m == nil { 345 return 0 346 } 347 var l int 348 _ = l 349 if len(m.Pairs) > 0 { 350 for _, e := range m.Pairs { 351 l = e.Size() 352 n += 1 + l + sovKv(uint64(l)) 353 } 354 } 355 return n 356} 357 358func (m *KeyValuePair) Size() (n int) { 359 if m == nil { 360 return 0 361 } 362 var l int 363 _ = l 364 l = len(m.Key) 365 if l > 0 { 366 n += 1 + l + sovKv(uint64(l)) 367 } 368 l = len(m.Value) 369 if l > 0 { 370 n += 1 + l + sovKv(uint64(l)) 371 } 372 l = len(m.Codec) 373 if l > 0 { 374 n += 1 + l + sovKv(uint64(l)) 375 } 376 return n 377} 378 379func sovKv(x uint64) (n int) { 380 return (math_bits.Len64(x|1) + 6) / 7 381} 382func sozKv(x uint64) (n int) { 383 return sovKv(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 384} 385func (this *KeyValueStore) String() string { 386 if this == nil { 387 return "nil" 388 } 389 repeatedStringForPairs := "[]*KeyValuePair{" 390 for _, f := range this.Pairs { 391 repeatedStringForPairs += strings.Replace(f.String(), "KeyValuePair", "KeyValuePair", 1) + "," 392 } 393 repeatedStringForPairs += "}" 394 s := strings.Join([]string{`&KeyValueStore{`, 395 `Pairs:` + repeatedStringForPairs + `,`, 396 `}`, 397 }, "") 398 return s 399} 400func (this *KeyValuePair) String() string { 401 if this == nil { 402 return "nil" 403 } 404 s := strings.Join([]string{`&KeyValuePair{`, 405 `Key:` + fmt.Sprintf("%v", this.Key) + `,`, 406 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 407 `Codec:` + fmt.Sprintf("%v", this.Codec) + `,`, 408 `}`, 409 }, "") 410 return s 411} 412func valueToStringKv(v interface{}) string { 413 rv := reflect.ValueOf(v) 414 if rv.IsNil() { 415 return "nil" 416 } 417 pv := reflect.Indirect(rv).Interface() 418 return fmt.Sprintf("*%v", pv) 419} 420func (m *KeyValueStore) Unmarshal(dAtA []byte) error { 421 l := len(dAtA) 422 iNdEx := 0 423 for iNdEx < l { 424 preIndex := iNdEx 425 var wire uint64 426 for shift := uint(0); ; shift += 7 { 427 if shift >= 64 { 428 return ErrIntOverflowKv 429 } 430 if iNdEx >= l { 431 return io.ErrUnexpectedEOF 432 } 433 b := dAtA[iNdEx] 434 iNdEx++ 435 wire |= uint64(b&0x7F) << shift 436 if b < 0x80 { 437 break 438 } 439 } 440 fieldNum := int32(wire >> 3) 441 wireType := int(wire & 0x7) 442 if wireType == 4 { 443 return fmt.Errorf("proto: KeyValueStore: wiretype end group for non-group") 444 } 445 if fieldNum <= 0 { 446 return fmt.Errorf("proto: KeyValueStore: illegal tag %d (wire type %d)", fieldNum, wire) 447 } 448 switch fieldNum { 449 case 1: 450 if wireType != 2 { 451 return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType) 452 } 453 var msglen int 454 for shift := uint(0); ; shift += 7 { 455 if shift >= 64 { 456 return ErrIntOverflowKv 457 } 458 if iNdEx >= l { 459 return io.ErrUnexpectedEOF 460 } 461 b := dAtA[iNdEx] 462 iNdEx++ 463 msglen |= int(b&0x7F) << shift 464 if b < 0x80 { 465 break 466 } 467 } 468 if msglen < 0 { 469 return ErrInvalidLengthKv 470 } 471 postIndex := iNdEx + msglen 472 if postIndex < 0 { 473 return ErrInvalidLengthKv 474 } 475 if postIndex > l { 476 return io.ErrUnexpectedEOF 477 } 478 m.Pairs = append(m.Pairs, &KeyValuePair{}) 479 if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 480 return err 481 } 482 iNdEx = postIndex 483 default: 484 iNdEx = preIndex 485 skippy, err := skipKv(dAtA[iNdEx:]) 486 if err != nil { 487 return err 488 } 489 if skippy < 0 { 490 return ErrInvalidLengthKv 491 } 492 if (iNdEx + skippy) < 0 { 493 return ErrInvalidLengthKv 494 } 495 if (iNdEx + skippy) > l { 496 return io.ErrUnexpectedEOF 497 } 498 iNdEx += skippy 499 } 500 } 501 502 if iNdEx > l { 503 return io.ErrUnexpectedEOF 504 } 505 return nil 506} 507func (m *KeyValuePair) Unmarshal(dAtA []byte) error { 508 l := len(dAtA) 509 iNdEx := 0 510 for iNdEx < l { 511 preIndex := iNdEx 512 var wire uint64 513 for shift := uint(0); ; shift += 7 { 514 if shift >= 64 { 515 return ErrIntOverflowKv 516 } 517 if iNdEx >= l { 518 return io.ErrUnexpectedEOF 519 } 520 b := dAtA[iNdEx] 521 iNdEx++ 522 wire |= uint64(b&0x7F) << shift 523 if b < 0x80 { 524 break 525 } 526 } 527 fieldNum := int32(wire >> 3) 528 wireType := int(wire & 0x7) 529 if wireType == 4 { 530 return fmt.Errorf("proto: KeyValuePair: wiretype end group for non-group") 531 } 532 if fieldNum <= 0 { 533 return fmt.Errorf("proto: KeyValuePair: illegal tag %d (wire type %d)", fieldNum, wire) 534 } 535 switch fieldNum { 536 case 1: 537 if wireType != 2 { 538 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) 539 } 540 var stringLen uint64 541 for shift := uint(0); ; shift += 7 { 542 if shift >= 64 { 543 return ErrIntOverflowKv 544 } 545 if iNdEx >= l { 546 return io.ErrUnexpectedEOF 547 } 548 b := dAtA[iNdEx] 549 iNdEx++ 550 stringLen |= uint64(b&0x7F) << shift 551 if b < 0x80 { 552 break 553 } 554 } 555 intStringLen := int(stringLen) 556 if intStringLen < 0 { 557 return ErrInvalidLengthKv 558 } 559 postIndex := iNdEx + intStringLen 560 if postIndex < 0 { 561 return ErrInvalidLengthKv 562 } 563 if postIndex > l { 564 return io.ErrUnexpectedEOF 565 } 566 m.Key = string(dAtA[iNdEx:postIndex]) 567 iNdEx = postIndex 568 case 2: 569 if wireType != 2 { 570 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 571 } 572 var byteLen int 573 for shift := uint(0); ; shift += 7 { 574 if shift >= 64 { 575 return ErrIntOverflowKv 576 } 577 if iNdEx >= l { 578 return io.ErrUnexpectedEOF 579 } 580 b := dAtA[iNdEx] 581 iNdEx++ 582 byteLen |= int(b&0x7F) << shift 583 if b < 0x80 { 584 break 585 } 586 } 587 if byteLen < 0 { 588 return ErrInvalidLengthKv 589 } 590 postIndex := iNdEx + byteLen 591 if postIndex < 0 { 592 return ErrInvalidLengthKv 593 } 594 if postIndex > l { 595 return io.ErrUnexpectedEOF 596 } 597 m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) 598 if m.Value == nil { 599 m.Value = []byte{} 600 } 601 iNdEx = postIndex 602 case 3: 603 if wireType != 2 { 604 return fmt.Errorf("proto: wrong wireType = %d for field Codec", wireType) 605 } 606 var stringLen uint64 607 for shift := uint(0); ; shift += 7 { 608 if shift >= 64 { 609 return ErrIntOverflowKv 610 } 611 if iNdEx >= l { 612 return io.ErrUnexpectedEOF 613 } 614 b := dAtA[iNdEx] 615 iNdEx++ 616 stringLen |= uint64(b&0x7F) << shift 617 if b < 0x80 { 618 break 619 } 620 } 621 intStringLen := int(stringLen) 622 if intStringLen < 0 { 623 return ErrInvalidLengthKv 624 } 625 postIndex := iNdEx + intStringLen 626 if postIndex < 0 { 627 return ErrInvalidLengthKv 628 } 629 if postIndex > l { 630 return io.ErrUnexpectedEOF 631 } 632 m.Codec = string(dAtA[iNdEx:postIndex]) 633 iNdEx = postIndex 634 default: 635 iNdEx = preIndex 636 skippy, err := skipKv(dAtA[iNdEx:]) 637 if err != nil { 638 return err 639 } 640 if skippy < 0 { 641 return ErrInvalidLengthKv 642 } 643 if (iNdEx + skippy) < 0 { 644 return ErrInvalidLengthKv 645 } 646 if (iNdEx + skippy) > l { 647 return io.ErrUnexpectedEOF 648 } 649 iNdEx += skippy 650 } 651 } 652 653 if iNdEx > l { 654 return io.ErrUnexpectedEOF 655 } 656 return nil 657} 658func skipKv(dAtA []byte) (n int, err error) { 659 l := len(dAtA) 660 iNdEx := 0 661 for iNdEx < l { 662 var wire uint64 663 for shift := uint(0); ; shift += 7 { 664 if shift >= 64 { 665 return 0, ErrIntOverflowKv 666 } 667 if iNdEx >= l { 668 return 0, io.ErrUnexpectedEOF 669 } 670 b := dAtA[iNdEx] 671 iNdEx++ 672 wire |= (uint64(b) & 0x7F) << shift 673 if b < 0x80 { 674 break 675 } 676 } 677 wireType := int(wire & 0x7) 678 switch wireType { 679 case 0: 680 for shift := uint(0); ; shift += 7 { 681 if shift >= 64 { 682 return 0, ErrIntOverflowKv 683 } 684 if iNdEx >= l { 685 return 0, io.ErrUnexpectedEOF 686 } 687 iNdEx++ 688 if dAtA[iNdEx-1] < 0x80 { 689 break 690 } 691 } 692 return iNdEx, nil 693 case 1: 694 iNdEx += 8 695 return iNdEx, nil 696 case 2: 697 var length int 698 for shift := uint(0); ; shift += 7 { 699 if shift >= 64 { 700 return 0, ErrIntOverflowKv 701 } 702 if iNdEx >= l { 703 return 0, io.ErrUnexpectedEOF 704 } 705 b := dAtA[iNdEx] 706 iNdEx++ 707 length |= (int(b) & 0x7F) << shift 708 if b < 0x80 { 709 break 710 } 711 } 712 if length < 0 { 713 return 0, ErrInvalidLengthKv 714 } 715 iNdEx += length 716 if iNdEx < 0 { 717 return 0, ErrInvalidLengthKv 718 } 719 return iNdEx, nil 720 case 3: 721 for { 722 var innerWire uint64 723 var start int = iNdEx 724 for shift := uint(0); ; shift += 7 { 725 if shift >= 64 { 726 return 0, ErrIntOverflowKv 727 } 728 if iNdEx >= l { 729 return 0, io.ErrUnexpectedEOF 730 } 731 b := dAtA[iNdEx] 732 iNdEx++ 733 innerWire |= (uint64(b) & 0x7F) << shift 734 if b < 0x80 { 735 break 736 } 737 } 738 innerWireType := int(innerWire & 0x7) 739 if innerWireType == 4 { 740 break 741 } 742 next, err := skipKv(dAtA[start:]) 743 if err != nil { 744 return 0, err 745 } 746 iNdEx = start + next 747 if iNdEx < 0 { 748 return 0, ErrInvalidLengthKv 749 } 750 } 751 return iNdEx, nil 752 case 4: 753 return iNdEx, nil 754 case 5: 755 iNdEx += 4 756 return iNdEx, nil 757 default: 758 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 759 } 760 } 761 panic("unreachable") 762} 763 764var ( 765 ErrInvalidLengthKv = fmt.Errorf("proto: negative length found during unmarshaling") 766 ErrIntOverflowKv = fmt.Errorf("proto: integer overflow") 767) 768