1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: binary.proto 3 4/* 5 Package binary is a generated protocol buffer package. 6 7 It is generated from these files: 8 binary.proto 9 10 It has these top-level messages: 11 Header 12 BucketHeader 13 BucketFooter 14 FloatPoints 15 IntegerPoints 16 UnsignedPoints 17 BooleanPoints 18 StringPoints 19 SeriesHeader 20 SeriesFooter 21*/ 22package binary 23 24import proto "github.com/gogo/protobuf/proto" 25import fmt "fmt" 26import math "math" 27import _ "github.com/gogo/protobuf/gogoproto" 28 29import time "time" 30 31import io "io" 32 33// Reference imports to suppress errors if they are not otherwise used. 34var _ = proto.Marshal 35var _ = fmt.Errorf 36var _ = math.Inf 37var _ = time.Kitchen 38 39// This is a compile-time assertion to ensure that this generated file 40// is compatible with the proto package it is being compiled against. 41// A compilation error at this line likely means your copy of the 42// proto package needs to be updated. 43const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 44 45type FieldType int32 46 47const ( 48 FloatFieldType FieldType = 0 49 IntegerFieldType FieldType = 1 50 UnsignedFieldType FieldType = 2 51 BooleanFieldType FieldType = 3 52 StringFieldType FieldType = 4 53) 54 55var FieldType_name = map[int32]string{ 56 0: "FLOAT", 57 1: "INTEGER", 58 2: "UNSIGNED", 59 3: "BOOLEAN", 60 4: "STRING", 61} 62var FieldType_value = map[string]int32{ 63 "FLOAT": 0, 64 "INTEGER": 1, 65 "UNSIGNED": 2, 66 "BOOLEAN": 3, 67 "STRING": 4, 68} 69 70func (x FieldType) String() string { 71 return proto.EnumName(FieldType_name, int32(x)) 72} 73func (FieldType) EnumDescriptor() ([]byte, []int) { return fileDescriptorBinary, []int{0} } 74 75type Header_Version int32 76 77const ( 78 Version0 Header_Version = 0 79) 80 81var Header_Version_name = map[int32]string{ 82 0: "VERSION_0", 83} 84var Header_Version_value = map[string]int32{ 85 "VERSION_0": 0, 86} 87 88func (x Header_Version) String() string { 89 return proto.EnumName(Header_Version_name, int32(x)) 90} 91func (Header_Version) EnumDescriptor() ([]byte, []int) { return fileDescriptorBinary, []int{0, 0} } 92 93type Header struct { 94 Version Header_Version `protobuf:"varint,1,opt,name=version,proto3,enum=binary.Header_Version" json:"version,omitempty"` 95 Database string `protobuf:"bytes,2,opt,name=database,proto3" json:"database,omitempty"` 96 RetentionPolicy string `protobuf:"bytes,3,opt,name=retention_policy,json=retentionPolicy,proto3" json:"retention_policy,omitempty"` 97 ShardDuration time.Duration `protobuf:"varint,4,opt,name=shard_duration,json=shardDuration,proto3,stdduration" json:"shard_duration,omitempty"` 98} 99 100func (m *Header) Reset() { *m = Header{} } 101func (m *Header) String() string { return proto.CompactTextString(m) } 102func (*Header) ProtoMessage() {} 103func (*Header) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{0} } 104 105type BucketHeader struct { 106 Start int64 `protobuf:"fixed64,1,opt,name=start,proto3" json:"start,omitempty"` 107 End int64 `protobuf:"fixed64,2,opt,name=end,proto3" json:"end,omitempty"` 108} 109 110func (m *BucketHeader) Reset() { *m = BucketHeader{} } 111func (m *BucketHeader) String() string { return proto.CompactTextString(m) } 112func (*BucketHeader) ProtoMessage() {} 113func (*BucketHeader) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{1} } 114 115type BucketFooter struct { 116} 117 118func (m *BucketFooter) Reset() { *m = BucketFooter{} } 119func (m *BucketFooter) String() string { return proto.CompactTextString(m) } 120func (*BucketFooter) ProtoMessage() {} 121func (*BucketFooter) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{2} } 122 123type FloatPoints struct { 124 Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps" json:"timestamps,omitempty"` 125 Values []float64 `protobuf:"fixed64,2,rep,packed,name=values" json:"values,omitempty"` 126} 127 128func (m *FloatPoints) Reset() { *m = FloatPoints{} } 129func (m *FloatPoints) String() string { return proto.CompactTextString(m) } 130func (*FloatPoints) ProtoMessage() {} 131func (*FloatPoints) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{3} } 132 133type IntegerPoints struct { 134 Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps" json:"timestamps,omitempty"` 135 Values []int64 `protobuf:"varint,2,rep,packed,name=values" json:"values,omitempty"` 136} 137 138func (m *IntegerPoints) Reset() { *m = IntegerPoints{} } 139func (m *IntegerPoints) String() string { return proto.CompactTextString(m) } 140func (*IntegerPoints) ProtoMessage() {} 141func (*IntegerPoints) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{4} } 142 143type UnsignedPoints struct { 144 Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps" json:"timestamps,omitempty"` 145 Values []uint64 `protobuf:"varint,2,rep,packed,name=values" json:"values,omitempty"` 146} 147 148func (m *UnsignedPoints) Reset() { *m = UnsignedPoints{} } 149func (m *UnsignedPoints) String() string { return proto.CompactTextString(m) } 150func (*UnsignedPoints) ProtoMessage() {} 151func (*UnsignedPoints) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{5} } 152 153type BooleanPoints struct { 154 Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps" json:"timestamps,omitempty"` 155 Values []bool `protobuf:"varint,2,rep,packed,name=values" json:"values,omitempty"` 156} 157 158func (m *BooleanPoints) Reset() { *m = BooleanPoints{} } 159func (m *BooleanPoints) String() string { return proto.CompactTextString(m) } 160func (*BooleanPoints) ProtoMessage() {} 161func (*BooleanPoints) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{6} } 162 163type StringPoints struct { 164 Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps" json:"timestamps,omitempty"` 165 Values []string `protobuf:"bytes,2,rep,name=values" json:"values,omitempty"` 166} 167 168func (m *StringPoints) Reset() { *m = StringPoints{} } 169func (m *StringPoints) String() string { return proto.CompactTextString(m) } 170func (*StringPoints) ProtoMessage() {} 171func (*StringPoints) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{7} } 172 173type SeriesHeader struct { 174 FieldType FieldType `protobuf:"varint,1,opt,name=field_type,json=fieldType,proto3,enum=binary.FieldType" json:"field_type,omitempty"` 175 SeriesKey []byte `protobuf:"bytes,2,opt,name=series_key,json=seriesKey,proto3" json:"series_key,omitempty"` 176 Field []byte `protobuf:"bytes,3,opt,name=field,proto3" json:"field,omitempty"` 177} 178 179func (m *SeriesHeader) Reset() { *m = SeriesHeader{} } 180func (m *SeriesHeader) String() string { return proto.CompactTextString(m) } 181func (*SeriesHeader) ProtoMessage() {} 182func (*SeriesHeader) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{8} } 183 184type SeriesFooter struct { 185} 186 187func (m *SeriesFooter) Reset() { *m = SeriesFooter{} } 188func (m *SeriesFooter) String() string { return proto.CompactTextString(m) } 189func (*SeriesFooter) ProtoMessage() {} 190func (*SeriesFooter) Descriptor() ([]byte, []int) { return fileDescriptorBinary, []int{9} } 191 192func init() { 193 proto.RegisterType((*Header)(nil), "binary.Header") 194 proto.RegisterType((*BucketHeader)(nil), "binary.BucketHeader") 195 proto.RegisterType((*BucketFooter)(nil), "binary.BucketFooter") 196 proto.RegisterType((*FloatPoints)(nil), "binary.FloatPoints") 197 proto.RegisterType((*IntegerPoints)(nil), "binary.IntegerPoints") 198 proto.RegisterType((*UnsignedPoints)(nil), "binary.UnsignedPoints") 199 proto.RegisterType((*BooleanPoints)(nil), "binary.BooleanPoints") 200 proto.RegisterType((*StringPoints)(nil), "binary.StringPoints") 201 proto.RegisterType((*SeriesHeader)(nil), "binary.SeriesHeader") 202 proto.RegisterType((*SeriesFooter)(nil), "binary.SeriesFooter") 203 proto.RegisterEnum("binary.FieldType", FieldType_name, FieldType_value) 204 proto.RegisterEnum("binary.Header_Version", Header_Version_name, Header_Version_value) 205} 206func (m *Header) Marshal() (dAtA []byte, err error) { 207 size := m.Size() 208 dAtA = make([]byte, size) 209 n, err := m.MarshalTo(dAtA) 210 if err != nil { 211 return nil, err 212 } 213 return dAtA[:n], nil 214} 215 216func (m *Header) MarshalTo(dAtA []byte) (int, error) { 217 var i int 218 _ = i 219 var l int 220 _ = l 221 if m.Version != 0 { 222 dAtA[i] = 0x8 223 i++ 224 i = encodeVarintBinary(dAtA, i, uint64(m.Version)) 225 } 226 if len(m.Database) > 0 { 227 dAtA[i] = 0x12 228 i++ 229 i = encodeVarintBinary(dAtA, i, uint64(len(m.Database))) 230 i += copy(dAtA[i:], m.Database) 231 } 232 if len(m.RetentionPolicy) > 0 { 233 dAtA[i] = 0x1a 234 i++ 235 i = encodeVarintBinary(dAtA, i, uint64(len(m.RetentionPolicy))) 236 i += copy(dAtA[i:], m.RetentionPolicy) 237 } 238 if m.ShardDuration != 0 { 239 dAtA[i] = 0x20 240 i++ 241 i = encodeVarintBinary(dAtA, i, uint64(m.ShardDuration)) 242 } 243 return i, nil 244} 245 246func (m *BucketHeader) Marshal() (dAtA []byte, err error) { 247 size := m.Size() 248 dAtA = make([]byte, size) 249 n, err := m.MarshalTo(dAtA) 250 if err != nil { 251 return nil, err 252 } 253 return dAtA[:n], nil 254} 255 256func (m *BucketHeader) MarshalTo(dAtA []byte) (int, error) { 257 var i int 258 _ = i 259 var l int 260 _ = l 261 if m.Start != 0 { 262 dAtA[i] = 0x9 263 i++ 264 i = encodeFixed64Binary(dAtA, i, uint64(m.Start)) 265 } 266 if m.End != 0 { 267 dAtA[i] = 0x11 268 i++ 269 i = encodeFixed64Binary(dAtA, i, uint64(m.End)) 270 } 271 return i, nil 272} 273 274func (m *BucketFooter) Marshal() (dAtA []byte, err error) { 275 size := m.Size() 276 dAtA = make([]byte, size) 277 n, err := m.MarshalTo(dAtA) 278 if err != nil { 279 return nil, err 280 } 281 return dAtA[:n], nil 282} 283 284func (m *BucketFooter) MarshalTo(dAtA []byte) (int, error) { 285 var i int 286 _ = i 287 var l int 288 _ = l 289 return i, nil 290} 291 292func (m *FloatPoints) Marshal() (dAtA []byte, err error) { 293 size := m.Size() 294 dAtA = make([]byte, size) 295 n, err := m.MarshalTo(dAtA) 296 if err != nil { 297 return nil, err 298 } 299 return dAtA[:n], nil 300} 301 302func (m *FloatPoints) MarshalTo(dAtA []byte) (int, error) { 303 var i int 304 _ = i 305 var l int 306 _ = l 307 if len(m.Timestamps) > 0 { 308 dAtA[i] = 0xa 309 i++ 310 i = encodeVarintBinary(dAtA, i, uint64(len(m.Timestamps)*8)) 311 for _, num := range m.Timestamps { 312 dAtA[i] = uint8(num) 313 i++ 314 dAtA[i] = uint8(num >> 8) 315 i++ 316 dAtA[i] = uint8(num >> 16) 317 i++ 318 dAtA[i] = uint8(num >> 24) 319 i++ 320 dAtA[i] = uint8(num >> 32) 321 i++ 322 dAtA[i] = uint8(num >> 40) 323 i++ 324 dAtA[i] = uint8(num >> 48) 325 i++ 326 dAtA[i] = uint8(num >> 56) 327 i++ 328 } 329 } 330 if len(m.Values) > 0 { 331 dAtA[i] = 0x12 332 i++ 333 i = encodeVarintBinary(dAtA, i, uint64(len(m.Values)*8)) 334 for _, num := range m.Values { 335 f1 := math.Float64bits(float64(num)) 336 dAtA[i] = uint8(f1) 337 i++ 338 dAtA[i] = uint8(f1 >> 8) 339 i++ 340 dAtA[i] = uint8(f1 >> 16) 341 i++ 342 dAtA[i] = uint8(f1 >> 24) 343 i++ 344 dAtA[i] = uint8(f1 >> 32) 345 i++ 346 dAtA[i] = uint8(f1 >> 40) 347 i++ 348 dAtA[i] = uint8(f1 >> 48) 349 i++ 350 dAtA[i] = uint8(f1 >> 56) 351 i++ 352 } 353 } 354 return i, nil 355} 356 357func (m *IntegerPoints) Marshal() (dAtA []byte, err error) { 358 size := m.Size() 359 dAtA = make([]byte, size) 360 n, err := m.MarshalTo(dAtA) 361 if err != nil { 362 return nil, err 363 } 364 return dAtA[:n], nil 365} 366 367func (m *IntegerPoints) MarshalTo(dAtA []byte) (int, error) { 368 var i int 369 _ = i 370 var l int 371 _ = l 372 if len(m.Timestamps) > 0 { 373 dAtA[i] = 0xa 374 i++ 375 i = encodeVarintBinary(dAtA, i, uint64(len(m.Timestamps)*8)) 376 for _, num := range m.Timestamps { 377 dAtA[i] = uint8(num) 378 i++ 379 dAtA[i] = uint8(num >> 8) 380 i++ 381 dAtA[i] = uint8(num >> 16) 382 i++ 383 dAtA[i] = uint8(num >> 24) 384 i++ 385 dAtA[i] = uint8(num >> 32) 386 i++ 387 dAtA[i] = uint8(num >> 40) 388 i++ 389 dAtA[i] = uint8(num >> 48) 390 i++ 391 dAtA[i] = uint8(num >> 56) 392 i++ 393 } 394 } 395 if len(m.Values) > 0 { 396 dAtA3 := make([]byte, len(m.Values)*10) 397 var j2 int 398 for _, num1 := range m.Values { 399 num := uint64(num1) 400 for num >= 1<<7 { 401 dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80) 402 num >>= 7 403 j2++ 404 } 405 dAtA3[j2] = uint8(num) 406 j2++ 407 } 408 dAtA[i] = 0x12 409 i++ 410 i = encodeVarintBinary(dAtA, i, uint64(j2)) 411 i += copy(dAtA[i:], dAtA3[:j2]) 412 } 413 return i, nil 414} 415 416func (m *UnsignedPoints) Marshal() (dAtA []byte, err error) { 417 size := m.Size() 418 dAtA = make([]byte, size) 419 n, err := m.MarshalTo(dAtA) 420 if err != nil { 421 return nil, err 422 } 423 return dAtA[:n], nil 424} 425 426func (m *UnsignedPoints) MarshalTo(dAtA []byte) (int, error) { 427 var i int 428 _ = i 429 var l int 430 _ = l 431 if len(m.Timestamps) > 0 { 432 dAtA[i] = 0xa 433 i++ 434 i = encodeVarintBinary(dAtA, i, uint64(len(m.Timestamps)*8)) 435 for _, num := range m.Timestamps { 436 dAtA[i] = uint8(num) 437 i++ 438 dAtA[i] = uint8(num >> 8) 439 i++ 440 dAtA[i] = uint8(num >> 16) 441 i++ 442 dAtA[i] = uint8(num >> 24) 443 i++ 444 dAtA[i] = uint8(num >> 32) 445 i++ 446 dAtA[i] = uint8(num >> 40) 447 i++ 448 dAtA[i] = uint8(num >> 48) 449 i++ 450 dAtA[i] = uint8(num >> 56) 451 i++ 452 } 453 } 454 if len(m.Values) > 0 { 455 dAtA5 := make([]byte, len(m.Values)*10) 456 var j4 int 457 for _, num := range m.Values { 458 for num >= 1<<7 { 459 dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80) 460 num >>= 7 461 j4++ 462 } 463 dAtA5[j4] = uint8(num) 464 j4++ 465 } 466 dAtA[i] = 0x12 467 i++ 468 i = encodeVarintBinary(dAtA, i, uint64(j4)) 469 i += copy(dAtA[i:], dAtA5[:j4]) 470 } 471 return i, nil 472} 473 474func (m *BooleanPoints) Marshal() (dAtA []byte, err error) { 475 size := m.Size() 476 dAtA = make([]byte, size) 477 n, err := m.MarshalTo(dAtA) 478 if err != nil { 479 return nil, err 480 } 481 return dAtA[:n], nil 482} 483 484func (m *BooleanPoints) MarshalTo(dAtA []byte) (int, error) { 485 var i int 486 _ = i 487 var l int 488 _ = l 489 if len(m.Timestamps) > 0 { 490 dAtA[i] = 0xa 491 i++ 492 i = encodeVarintBinary(dAtA, i, uint64(len(m.Timestamps)*8)) 493 for _, num := range m.Timestamps { 494 dAtA[i] = uint8(num) 495 i++ 496 dAtA[i] = uint8(num >> 8) 497 i++ 498 dAtA[i] = uint8(num >> 16) 499 i++ 500 dAtA[i] = uint8(num >> 24) 501 i++ 502 dAtA[i] = uint8(num >> 32) 503 i++ 504 dAtA[i] = uint8(num >> 40) 505 i++ 506 dAtA[i] = uint8(num >> 48) 507 i++ 508 dAtA[i] = uint8(num >> 56) 509 i++ 510 } 511 } 512 if len(m.Values) > 0 { 513 dAtA[i] = 0x12 514 i++ 515 i = encodeVarintBinary(dAtA, i, uint64(len(m.Values))) 516 for _, b := range m.Values { 517 if b { 518 dAtA[i] = 1 519 } else { 520 dAtA[i] = 0 521 } 522 i++ 523 } 524 } 525 return i, nil 526} 527 528func (m *StringPoints) Marshal() (dAtA []byte, err error) { 529 size := m.Size() 530 dAtA = make([]byte, size) 531 n, err := m.MarshalTo(dAtA) 532 if err != nil { 533 return nil, err 534 } 535 return dAtA[:n], nil 536} 537 538func (m *StringPoints) MarshalTo(dAtA []byte) (int, error) { 539 var i int 540 _ = i 541 var l int 542 _ = l 543 if len(m.Timestamps) > 0 { 544 dAtA[i] = 0xa 545 i++ 546 i = encodeVarintBinary(dAtA, i, uint64(len(m.Timestamps)*8)) 547 for _, num := range m.Timestamps { 548 dAtA[i] = uint8(num) 549 i++ 550 dAtA[i] = uint8(num >> 8) 551 i++ 552 dAtA[i] = uint8(num >> 16) 553 i++ 554 dAtA[i] = uint8(num >> 24) 555 i++ 556 dAtA[i] = uint8(num >> 32) 557 i++ 558 dAtA[i] = uint8(num >> 40) 559 i++ 560 dAtA[i] = uint8(num >> 48) 561 i++ 562 dAtA[i] = uint8(num >> 56) 563 i++ 564 } 565 } 566 if len(m.Values) > 0 { 567 for _, s := range m.Values { 568 dAtA[i] = 0x12 569 i++ 570 l = len(s) 571 for l >= 1<<7 { 572 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 573 l >>= 7 574 i++ 575 } 576 dAtA[i] = uint8(l) 577 i++ 578 i += copy(dAtA[i:], s) 579 } 580 } 581 return i, nil 582} 583 584func (m *SeriesHeader) Marshal() (dAtA []byte, err error) { 585 size := m.Size() 586 dAtA = make([]byte, size) 587 n, err := m.MarshalTo(dAtA) 588 if err != nil { 589 return nil, err 590 } 591 return dAtA[:n], nil 592} 593 594func (m *SeriesHeader) MarshalTo(dAtA []byte) (int, error) { 595 var i int 596 _ = i 597 var l int 598 _ = l 599 if m.FieldType != 0 { 600 dAtA[i] = 0x8 601 i++ 602 i = encodeVarintBinary(dAtA, i, uint64(m.FieldType)) 603 } 604 if len(m.SeriesKey) > 0 { 605 dAtA[i] = 0x12 606 i++ 607 i = encodeVarintBinary(dAtA, i, uint64(len(m.SeriesKey))) 608 i += copy(dAtA[i:], m.SeriesKey) 609 } 610 if len(m.Field) > 0 { 611 dAtA[i] = 0x1a 612 i++ 613 i = encodeVarintBinary(dAtA, i, uint64(len(m.Field))) 614 i += copy(dAtA[i:], m.Field) 615 } 616 return i, nil 617} 618 619func (m *SeriesFooter) Marshal() (dAtA []byte, err error) { 620 size := m.Size() 621 dAtA = make([]byte, size) 622 n, err := m.MarshalTo(dAtA) 623 if err != nil { 624 return nil, err 625 } 626 return dAtA[:n], nil 627} 628 629func (m *SeriesFooter) MarshalTo(dAtA []byte) (int, error) { 630 var i int 631 _ = i 632 var l int 633 _ = l 634 return i, nil 635} 636 637func encodeFixed64Binary(dAtA []byte, offset int, v uint64) int { 638 dAtA[offset] = uint8(v) 639 dAtA[offset+1] = uint8(v >> 8) 640 dAtA[offset+2] = uint8(v >> 16) 641 dAtA[offset+3] = uint8(v >> 24) 642 dAtA[offset+4] = uint8(v >> 32) 643 dAtA[offset+5] = uint8(v >> 40) 644 dAtA[offset+6] = uint8(v >> 48) 645 dAtA[offset+7] = uint8(v >> 56) 646 return offset + 8 647} 648func encodeFixed32Binary(dAtA []byte, offset int, v uint32) int { 649 dAtA[offset] = uint8(v) 650 dAtA[offset+1] = uint8(v >> 8) 651 dAtA[offset+2] = uint8(v >> 16) 652 dAtA[offset+3] = uint8(v >> 24) 653 return offset + 4 654} 655func encodeVarintBinary(dAtA []byte, offset int, v uint64) int { 656 for v >= 1<<7 { 657 dAtA[offset] = uint8(v&0x7f | 0x80) 658 v >>= 7 659 offset++ 660 } 661 dAtA[offset] = uint8(v) 662 return offset + 1 663} 664func (m *Header) Size() (n int) { 665 var l int 666 _ = l 667 if m.Version != 0 { 668 n += 1 + sovBinary(uint64(m.Version)) 669 } 670 l = len(m.Database) 671 if l > 0 { 672 n += 1 + l + sovBinary(uint64(l)) 673 } 674 l = len(m.RetentionPolicy) 675 if l > 0 { 676 n += 1 + l + sovBinary(uint64(l)) 677 } 678 if m.ShardDuration != 0 { 679 n += 1 + sovBinary(uint64(m.ShardDuration)) 680 } 681 return n 682} 683 684func (m *BucketHeader) Size() (n int) { 685 var l int 686 _ = l 687 if m.Start != 0 { 688 n += 9 689 } 690 if m.End != 0 { 691 n += 9 692 } 693 return n 694} 695 696func (m *BucketFooter) Size() (n int) { 697 var l int 698 _ = l 699 return n 700} 701 702func (m *FloatPoints) Size() (n int) { 703 var l int 704 _ = l 705 if len(m.Timestamps) > 0 { 706 n += 1 + sovBinary(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8 707 } 708 if len(m.Values) > 0 { 709 n += 1 + sovBinary(uint64(len(m.Values)*8)) + len(m.Values)*8 710 } 711 return n 712} 713 714func (m *IntegerPoints) Size() (n int) { 715 var l int 716 _ = l 717 if len(m.Timestamps) > 0 { 718 n += 1 + sovBinary(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8 719 } 720 if len(m.Values) > 0 { 721 l = 0 722 for _, e := range m.Values { 723 l += sovBinary(uint64(e)) 724 } 725 n += 1 + sovBinary(uint64(l)) + l 726 } 727 return n 728} 729 730func (m *UnsignedPoints) Size() (n int) { 731 var l int 732 _ = l 733 if len(m.Timestamps) > 0 { 734 n += 1 + sovBinary(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8 735 } 736 if len(m.Values) > 0 { 737 l = 0 738 for _, e := range m.Values { 739 l += sovBinary(uint64(e)) 740 } 741 n += 1 + sovBinary(uint64(l)) + l 742 } 743 return n 744} 745 746func (m *BooleanPoints) Size() (n int) { 747 var l int 748 _ = l 749 if len(m.Timestamps) > 0 { 750 n += 1 + sovBinary(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8 751 } 752 if len(m.Values) > 0 { 753 n += 1 + sovBinary(uint64(len(m.Values))) + len(m.Values)*1 754 } 755 return n 756} 757 758func (m *StringPoints) Size() (n int) { 759 var l int 760 _ = l 761 if len(m.Timestamps) > 0 { 762 n += 1 + sovBinary(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8 763 } 764 if len(m.Values) > 0 { 765 for _, s := range m.Values { 766 l = len(s) 767 n += 1 + l + sovBinary(uint64(l)) 768 } 769 } 770 return n 771} 772 773func (m *SeriesHeader) Size() (n int) { 774 var l int 775 _ = l 776 if m.FieldType != 0 { 777 n += 1 + sovBinary(uint64(m.FieldType)) 778 } 779 l = len(m.SeriesKey) 780 if l > 0 { 781 n += 1 + l + sovBinary(uint64(l)) 782 } 783 l = len(m.Field) 784 if l > 0 { 785 n += 1 + l + sovBinary(uint64(l)) 786 } 787 return n 788} 789 790func (m *SeriesFooter) Size() (n int) { 791 var l int 792 _ = l 793 return n 794} 795 796func sovBinary(x uint64) (n int) { 797 for { 798 n++ 799 x >>= 7 800 if x == 0 { 801 break 802 } 803 } 804 return n 805} 806func sozBinary(x uint64) (n int) { 807 return sovBinary(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 808} 809func (m *Header) Unmarshal(dAtA []byte) error { 810 l := len(dAtA) 811 iNdEx := 0 812 for iNdEx < l { 813 preIndex := iNdEx 814 var wire uint64 815 for shift := uint(0); ; shift += 7 { 816 if shift >= 64 { 817 return ErrIntOverflowBinary 818 } 819 if iNdEx >= l { 820 return io.ErrUnexpectedEOF 821 } 822 b := dAtA[iNdEx] 823 iNdEx++ 824 wire |= (uint64(b) & 0x7F) << shift 825 if b < 0x80 { 826 break 827 } 828 } 829 fieldNum := int32(wire >> 3) 830 wireType := int(wire & 0x7) 831 if wireType == 4 { 832 return fmt.Errorf("proto: Header: wiretype end group for non-group") 833 } 834 if fieldNum <= 0 { 835 return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire) 836 } 837 switch fieldNum { 838 case 1: 839 if wireType != 0 { 840 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) 841 } 842 m.Version = 0 843 for shift := uint(0); ; shift += 7 { 844 if shift >= 64 { 845 return ErrIntOverflowBinary 846 } 847 if iNdEx >= l { 848 return io.ErrUnexpectedEOF 849 } 850 b := dAtA[iNdEx] 851 iNdEx++ 852 m.Version |= (Header_Version(b) & 0x7F) << shift 853 if b < 0x80 { 854 break 855 } 856 } 857 case 2: 858 if wireType != 2 { 859 return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType) 860 } 861 var stringLen uint64 862 for shift := uint(0); ; shift += 7 { 863 if shift >= 64 { 864 return ErrIntOverflowBinary 865 } 866 if iNdEx >= l { 867 return io.ErrUnexpectedEOF 868 } 869 b := dAtA[iNdEx] 870 iNdEx++ 871 stringLen |= (uint64(b) & 0x7F) << shift 872 if b < 0x80 { 873 break 874 } 875 } 876 intStringLen := int(stringLen) 877 if intStringLen < 0 { 878 return ErrInvalidLengthBinary 879 } 880 postIndex := iNdEx + intStringLen 881 if postIndex > l { 882 return io.ErrUnexpectedEOF 883 } 884 m.Database = string(dAtA[iNdEx:postIndex]) 885 iNdEx = postIndex 886 case 3: 887 if wireType != 2 { 888 return fmt.Errorf("proto: wrong wireType = %d for field RetentionPolicy", wireType) 889 } 890 var stringLen uint64 891 for shift := uint(0); ; shift += 7 { 892 if shift >= 64 { 893 return ErrIntOverflowBinary 894 } 895 if iNdEx >= l { 896 return io.ErrUnexpectedEOF 897 } 898 b := dAtA[iNdEx] 899 iNdEx++ 900 stringLen |= (uint64(b) & 0x7F) << shift 901 if b < 0x80 { 902 break 903 } 904 } 905 intStringLen := int(stringLen) 906 if intStringLen < 0 { 907 return ErrInvalidLengthBinary 908 } 909 postIndex := iNdEx + intStringLen 910 if postIndex > l { 911 return io.ErrUnexpectedEOF 912 } 913 m.RetentionPolicy = string(dAtA[iNdEx:postIndex]) 914 iNdEx = postIndex 915 case 4: 916 if wireType != 0 { 917 return fmt.Errorf("proto: wrong wireType = %d for field ShardDuration", wireType) 918 } 919 m.ShardDuration = 0 920 for shift := uint(0); ; shift += 7 { 921 if shift >= 64 { 922 return ErrIntOverflowBinary 923 } 924 if iNdEx >= l { 925 return io.ErrUnexpectedEOF 926 } 927 b := dAtA[iNdEx] 928 iNdEx++ 929 m.ShardDuration |= (time.Duration(b) & 0x7F) << shift 930 if b < 0x80 { 931 break 932 } 933 } 934 default: 935 iNdEx = preIndex 936 skippy, err := skipBinary(dAtA[iNdEx:]) 937 if err != nil { 938 return err 939 } 940 if skippy < 0 { 941 return ErrInvalidLengthBinary 942 } 943 if (iNdEx + skippy) > l { 944 return io.ErrUnexpectedEOF 945 } 946 iNdEx += skippy 947 } 948 } 949 950 if iNdEx > l { 951 return io.ErrUnexpectedEOF 952 } 953 return nil 954} 955func (m *BucketHeader) Unmarshal(dAtA []byte) error { 956 l := len(dAtA) 957 iNdEx := 0 958 for iNdEx < l { 959 preIndex := iNdEx 960 var wire uint64 961 for shift := uint(0); ; shift += 7 { 962 if shift >= 64 { 963 return ErrIntOverflowBinary 964 } 965 if iNdEx >= l { 966 return io.ErrUnexpectedEOF 967 } 968 b := dAtA[iNdEx] 969 iNdEx++ 970 wire |= (uint64(b) & 0x7F) << shift 971 if b < 0x80 { 972 break 973 } 974 } 975 fieldNum := int32(wire >> 3) 976 wireType := int(wire & 0x7) 977 if wireType == 4 { 978 return fmt.Errorf("proto: BucketHeader: wiretype end group for non-group") 979 } 980 if fieldNum <= 0 { 981 return fmt.Errorf("proto: BucketHeader: illegal tag %d (wire type %d)", fieldNum, wire) 982 } 983 switch fieldNum { 984 case 1: 985 if wireType != 1 { 986 return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType) 987 } 988 m.Start = 0 989 if (iNdEx + 8) > l { 990 return io.ErrUnexpectedEOF 991 } 992 iNdEx += 8 993 m.Start = int64(dAtA[iNdEx-8]) 994 m.Start |= int64(dAtA[iNdEx-7]) << 8 995 m.Start |= int64(dAtA[iNdEx-6]) << 16 996 m.Start |= int64(dAtA[iNdEx-5]) << 24 997 m.Start |= int64(dAtA[iNdEx-4]) << 32 998 m.Start |= int64(dAtA[iNdEx-3]) << 40 999 m.Start |= int64(dAtA[iNdEx-2]) << 48 1000 m.Start |= int64(dAtA[iNdEx-1]) << 56 1001 case 2: 1002 if wireType != 1 { 1003 return fmt.Errorf("proto: wrong wireType = %d for field End", wireType) 1004 } 1005 m.End = 0 1006 if (iNdEx + 8) > l { 1007 return io.ErrUnexpectedEOF 1008 } 1009 iNdEx += 8 1010 m.End = int64(dAtA[iNdEx-8]) 1011 m.End |= int64(dAtA[iNdEx-7]) << 8 1012 m.End |= int64(dAtA[iNdEx-6]) << 16 1013 m.End |= int64(dAtA[iNdEx-5]) << 24 1014 m.End |= int64(dAtA[iNdEx-4]) << 32 1015 m.End |= int64(dAtA[iNdEx-3]) << 40 1016 m.End |= int64(dAtA[iNdEx-2]) << 48 1017 m.End |= int64(dAtA[iNdEx-1]) << 56 1018 default: 1019 iNdEx = preIndex 1020 skippy, err := skipBinary(dAtA[iNdEx:]) 1021 if err != nil { 1022 return err 1023 } 1024 if skippy < 0 { 1025 return ErrInvalidLengthBinary 1026 } 1027 if (iNdEx + skippy) > l { 1028 return io.ErrUnexpectedEOF 1029 } 1030 iNdEx += skippy 1031 } 1032 } 1033 1034 if iNdEx > l { 1035 return io.ErrUnexpectedEOF 1036 } 1037 return nil 1038} 1039func (m *BucketFooter) Unmarshal(dAtA []byte) error { 1040 l := len(dAtA) 1041 iNdEx := 0 1042 for iNdEx < l { 1043 preIndex := iNdEx 1044 var wire uint64 1045 for shift := uint(0); ; shift += 7 { 1046 if shift >= 64 { 1047 return ErrIntOverflowBinary 1048 } 1049 if iNdEx >= l { 1050 return io.ErrUnexpectedEOF 1051 } 1052 b := dAtA[iNdEx] 1053 iNdEx++ 1054 wire |= (uint64(b) & 0x7F) << shift 1055 if b < 0x80 { 1056 break 1057 } 1058 } 1059 fieldNum := int32(wire >> 3) 1060 wireType := int(wire & 0x7) 1061 if wireType == 4 { 1062 return fmt.Errorf("proto: BucketFooter: wiretype end group for non-group") 1063 } 1064 if fieldNum <= 0 { 1065 return fmt.Errorf("proto: BucketFooter: illegal tag %d (wire type %d)", fieldNum, wire) 1066 } 1067 switch fieldNum { 1068 default: 1069 iNdEx = preIndex 1070 skippy, err := skipBinary(dAtA[iNdEx:]) 1071 if err != nil { 1072 return err 1073 } 1074 if skippy < 0 { 1075 return ErrInvalidLengthBinary 1076 } 1077 if (iNdEx + skippy) > l { 1078 return io.ErrUnexpectedEOF 1079 } 1080 iNdEx += skippy 1081 } 1082 } 1083 1084 if iNdEx > l { 1085 return io.ErrUnexpectedEOF 1086 } 1087 return nil 1088} 1089func (m *FloatPoints) Unmarshal(dAtA []byte) error { 1090 l := len(dAtA) 1091 iNdEx := 0 1092 for iNdEx < l { 1093 preIndex := iNdEx 1094 var wire uint64 1095 for shift := uint(0); ; shift += 7 { 1096 if shift >= 64 { 1097 return ErrIntOverflowBinary 1098 } 1099 if iNdEx >= l { 1100 return io.ErrUnexpectedEOF 1101 } 1102 b := dAtA[iNdEx] 1103 iNdEx++ 1104 wire |= (uint64(b) & 0x7F) << shift 1105 if b < 0x80 { 1106 break 1107 } 1108 } 1109 fieldNum := int32(wire >> 3) 1110 wireType := int(wire & 0x7) 1111 if wireType == 4 { 1112 return fmt.Errorf("proto: FloatPoints: wiretype end group for non-group") 1113 } 1114 if fieldNum <= 0 { 1115 return fmt.Errorf("proto: FloatPoints: illegal tag %d (wire type %d)", fieldNum, wire) 1116 } 1117 switch fieldNum { 1118 case 1: 1119 if wireType == 1 { 1120 var v int64 1121 if (iNdEx + 8) > l { 1122 return io.ErrUnexpectedEOF 1123 } 1124 iNdEx += 8 1125 v = int64(dAtA[iNdEx-8]) 1126 v |= int64(dAtA[iNdEx-7]) << 8 1127 v |= int64(dAtA[iNdEx-6]) << 16 1128 v |= int64(dAtA[iNdEx-5]) << 24 1129 v |= int64(dAtA[iNdEx-4]) << 32 1130 v |= int64(dAtA[iNdEx-3]) << 40 1131 v |= int64(dAtA[iNdEx-2]) << 48 1132 v |= int64(dAtA[iNdEx-1]) << 56 1133 m.Timestamps = append(m.Timestamps, v) 1134 } else if wireType == 2 { 1135 var packedLen int 1136 for shift := uint(0); ; shift += 7 { 1137 if shift >= 64 { 1138 return ErrIntOverflowBinary 1139 } 1140 if iNdEx >= l { 1141 return io.ErrUnexpectedEOF 1142 } 1143 b := dAtA[iNdEx] 1144 iNdEx++ 1145 packedLen |= (int(b) & 0x7F) << shift 1146 if b < 0x80 { 1147 break 1148 } 1149 } 1150 if packedLen < 0 { 1151 return ErrInvalidLengthBinary 1152 } 1153 postIndex := iNdEx + packedLen 1154 if postIndex > l { 1155 return io.ErrUnexpectedEOF 1156 } 1157 for iNdEx < postIndex { 1158 var v int64 1159 if (iNdEx + 8) > l { 1160 return io.ErrUnexpectedEOF 1161 } 1162 iNdEx += 8 1163 v = int64(dAtA[iNdEx-8]) 1164 v |= int64(dAtA[iNdEx-7]) << 8 1165 v |= int64(dAtA[iNdEx-6]) << 16 1166 v |= int64(dAtA[iNdEx-5]) << 24 1167 v |= int64(dAtA[iNdEx-4]) << 32 1168 v |= int64(dAtA[iNdEx-3]) << 40 1169 v |= int64(dAtA[iNdEx-2]) << 48 1170 v |= int64(dAtA[iNdEx-1]) << 56 1171 m.Timestamps = append(m.Timestamps, v) 1172 } 1173 } else { 1174 return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType) 1175 } 1176 case 2: 1177 if wireType == 1 { 1178 var v uint64 1179 if (iNdEx + 8) > l { 1180 return io.ErrUnexpectedEOF 1181 } 1182 iNdEx += 8 1183 v = uint64(dAtA[iNdEx-8]) 1184 v |= uint64(dAtA[iNdEx-7]) << 8 1185 v |= uint64(dAtA[iNdEx-6]) << 16 1186 v |= uint64(dAtA[iNdEx-5]) << 24 1187 v |= uint64(dAtA[iNdEx-4]) << 32 1188 v |= uint64(dAtA[iNdEx-3]) << 40 1189 v |= uint64(dAtA[iNdEx-2]) << 48 1190 v |= uint64(dAtA[iNdEx-1]) << 56 1191 v2 := float64(math.Float64frombits(v)) 1192 m.Values = append(m.Values, v2) 1193 } else if wireType == 2 { 1194 var packedLen int 1195 for shift := uint(0); ; shift += 7 { 1196 if shift >= 64 { 1197 return ErrIntOverflowBinary 1198 } 1199 if iNdEx >= l { 1200 return io.ErrUnexpectedEOF 1201 } 1202 b := dAtA[iNdEx] 1203 iNdEx++ 1204 packedLen |= (int(b) & 0x7F) << shift 1205 if b < 0x80 { 1206 break 1207 } 1208 } 1209 if packedLen < 0 { 1210 return ErrInvalidLengthBinary 1211 } 1212 postIndex := iNdEx + packedLen 1213 if postIndex > l { 1214 return io.ErrUnexpectedEOF 1215 } 1216 for iNdEx < postIndex { 1217 var v uint64 1218 if (iNdEx + 8) > l { 1219 return io.ErrUnexpectedEOF 1220 } 1221 iNdEx += 8 1222 v = uint64(dAtA[iNdEx-8]) 1223 v |= uint64(dAtA[iNdEx-7]) << 8 1224 v |= uint64(dAtA[iNdEx-6]) << 16 1225 v |= uint64(dAtA[iNdEx-5]) << 24 1226 v |= uint64(dAtA[iNdEx-4]) << 32 1227 v |= uint64(dAtA[iNdEx-3]) << 40 1228 v |= uint64(dAtA[iNdEx-2]) << 48 1229 v |= uint64(dAtA[iNdEx-1]) << 56 1230 v2 := float64(math.Float64frombits(v)) 1231 m.Values = append(m.Values, v2) 1232 } 1233 } else { 1234 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 1235 } 1236 default: 1237 iNdEx = preIndex 1238 skippy, err := skipBinary(dAtA[iNdEx:]) 1239 if err != nil { 1240 return err 1241 } 1242 if skippy < 0 { 1243 return ErrInvalidLengthBinary 1244 } 1245 if (iNdEx + skippy) > l { 1246 return io.ErrUnexpectedEOF 1247 } 1248 iNdEx += skippy 1249 } 1250 } 1251 1252 if iNdEx > l { 1253 return io.ErrUnexpectedEOF 1254 } 1255 return nil 1256} 1257func (m *IntegerPoints) Unmarshal(dAtA []byte) error { 1258 l := len(dAtA) 1259 iNdEx := 0 1260 for iNdEx < l { 1261 preIndex := iNdEx 1262 var wire uint64 1263 for shift := uint(0); ; shift += 7 { 1264 if shift >= 64 { 1265 return ErrIntOverflowBinary 1266 } 1267 if iNdEx >= l { 1268 return io.ErrUnexpectedEOF 1269 } 1270 b := dAtA[iNdEx] 1271 iNdEx++ 1272 wire |= (uint64(b) & 0x7F) << shift 1273 if b < 0x80 { 1274 break 1275 } 1276 } 1277 fieldNum := int32(wire >> 3) 1278 wireType := int(wire & 0x7) 1279 if wireType == 4 { 1280 return fmt.Errorf("proto: IntegerPoints: wiretype end group for non-group") 1281 } 1282 if fieldNum <= 0 { 1283 return fmt.Errorf("proto: IntegerPoints: illegal tag %d (wire type %d)", fieldNum, wire) 1284 } 1285 switch fieldNum { 1286 case 1: 1287 if wireType == 1 { 1288 var v int64 1289 if (iNdEx + 8) > l { 1290 return io.ErrUnexpectedEOF 1291 } 1292 iNdEx += 8 1293 v = int64(dAtA[iNdEx-8]) 1294 v |= int64(dAtA[iNdEx-7]) << 8 1295 v |= int64(dAtA[iNdEx-6]) << 16 1296 v |= int64(dAtA[iNdEx-5]) << 24 1297 v |= int64(dAtA[iNdEx-4]) << 32 1298 v |= int64(dAtA[iNdEx-3]) << 40 1299 v |= int64(dAtA[iNdEx-2]) << 48 1300 v |= int64(dAtA[iNdEx-1]) << 56 1301 m.Timestamps = append(m.Timestamps, v) 1302 } else if wireType == 2 { 1303 var packedLen int 1304 for shift := uint(0); ; shift += 7 { 1305 if shift >= 64 { 1306 return ErrIntOverflowBinary 1307 } 1308 if iNdEx >= l { 1309 return io.ErrUnexpectedEOF 1310 } 1311 b := dAtA[iNdEx] 1312 iNdEx++ 1313 packedLen |= (int(b) & 0x7F) << shift 1314 if b < 0x80 { 1315 break 1316 } 1317 } 1318 if packedLen < 0 { 1319 return ErrInvalidLengthBinary 1320 } 1321 postIndex := iNdEx + packedLen 1322 if postIndex > l { 1323 return io.ErrUnexpectedEOF 1324 } 1325 for iNdEx < postIndex { 1326 var v int64 1327 if (iNdEx + 8) > l { 1328 return io.ErrUnexpectedEOF 1329 } 1330 iNdEx += 8 1331 v = int64(dAtA[iNdEx-8]) 1332 v |= int64(dAtA[iNdEx-7]) << 8 1333 v |= int64(dAtA[iNdEx-6]) << 16 1334 v |= int64(dAtA[iNdEx-5]) << 24 1335 v |= int64(dAtA[iNdEx-4]) << 32 1336 v |= int64(dAtA[iNdEx-3]) << 40 1337 v |= int64(dAtA[iNdEx-2]) << 48 1338 v |= int64(dAtA[iNdEx-1]) << 56 1339 m.Timestamps = append(m.Timestamps, v) 1340 } 1341 } else { 1342 return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType) 1343 } 1344 case 2: 1345 if wireType == 0 { 1346 var v int64 1347 for shift := uint(0); ; shift += 7 { 1348 if shift >= 64 { 1349 return ErrIntOverflowBinary 1350 } 1351 if iNdEx >= l { 1352 return io.ErrUnexpectedEOF 1353 } 1354 b := dAtA[iNdEx] 1355 iNdEx++ 1356 v |= (int64(b) & 0x7F) << shift 1357 if b < 0x80 { 1358 break 1359 } 1360 } 1361 m.Values = append(m.Values, v) 1362 } else if wireType == 2 { 1363 var packedLen int 1364 for shift := uint(0); ; shift += 7 { 1365 if shift >= 64 { 1366 return ErrIntOverflowBinary 1367 } 1368 if iNdEx >= l { 1369 return io.ErrUnexpectedEOF 1370 } 1371 b := dAtA[iNdEx] 1372 iNdEx++ 1373 packedLen |= (int(b) & 0x7F) << shift 1374 if b < 0x80 { 1375 break 1376 } 1377 } 1378 if packedLen < 0 { 1379 return ErrInvalidLengthBinary 1380 } 1381 postIndex := iNdEx + packedLen 1382 if postIndex > l { 1383 return io.ErrUnexpectedEOF 1384 } 1385 for iNdEx < postIndex { 1386 var v int64 1387 for shift := uint(0); ; shift += 7 { 1388 if shift >= 64 { 1389 return ErrIntOverflowBinary 1390 } 1391 if iNdEx >= l { 1392 return io.ErrUnexpectedEOF 1393 } 1394 b := dAtA[iNdEx] 1395 iNdEx++ 1396 v |= (int64(b) & 0x7F) << shift 1397 if b < 0x80 { 1398 break 1399 } 1400 } 1401 m.Values = append(m.Values, v) 1402 } 1403 } else { 1404 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 1405 } 1406 default: 1407 iNdEx = preIndex 1408 skippy, err := skipBinary(dAtA[iNdEx:]) 1409 if err != nil { 1410 return err 1411 } 1412 if skippy < 0 { 1413 return ErrInvalidLengthBinary 1414 } 1415 if (iNdEx + skippy) > l { 1416 return io.ErrUnexpectedEOF 1417 } 1418 iNdEx += skippy 1419 } 1420 } 1421 1422 if iNdEx > l { 1423 return io.ErrUnexpectedEOF 1424 } 1425 return nil 1426} 1427func (m *UnsignedPoints) Unmarshal(dAtA []byte) error { 1428 l := len(dAtA) 1429 iNdEx := 0 1430 for iNdEx < l { 1431 preIndex := iNdEx 1432 var wire uint64 1433 for shift := uint(0); ; shift += 7 { 1434 if shift >= 64 { 1435 return ErrIntOverflowBinary 1436 } 1437 if iNdEx >= l { 1438 return io.ErrUnexpectedEOF 1439 } 1440 b := dAtA[iNdEx] 1441 iNdEx++ 1442 wire |= (uint64(b) & 0x7F) << shift 1443 if b < 0x80 { 1444 break 1445 } 1446 } 1447 fieldNum := int32(wire >> 3) 1448 wireType := int(wire & 0x7) 1449 if wireType == 4 { 1450 return fmt.Errorf("proto: UnsignedPoints: wiretype end group for non-group") 1451 } 1452 if fieldNum <= 0 { 1453 return fmt.Errorf("proto: UnsignedPoints: illegal tag %d (wire type %d)", fieldNum, wire) 1454 } 1455 switch fieldNum { 1456 case 1: 1457 if wireType == 1 { 1458 var v int64 1459 if (iNdEx + 8) > l { 1460 return io.ErrUnexpectedEOF 1461 } 1462 iNdEx += 8 1463 v = int64(dAtA[iNdEx-8]) 1464 v |= int64(dAtA[iNdEx-7]) << 8 1465 v |= int64(dAtA[iNdEx-6]) << 16 1466 v |= int64(dAtA[iNdEx-5]) << 24 1467 v |= int64(dAtA[iNdEx-4]) << 32 1468 v |= int64(dAtA[iNdEx-3]) << 40 1469 v |= int64(dAtA[iNdEx-2]) << 48 1470 v |= int64(dAtA[iNdEx-1]) << 56 1471 m.Timestamps = append(m.Timestamps, v) 1472 } else if wireType == 2 { 1473 var packedLen int 1474 for shift := uint(0); ; shift += 7 { 1475 if shift >= 64 { 1476 return ErrIntOverflowBinary 1477 } 1478 if iNdEx >= l { 1479 return io.ErrUnexpectedEOF 1480 } 1481 b := dAtA[iNdEx] 1482 iNdEx++ 1483 packedLen |= (int(b) & 0x7F) << shift 1484 if b < 0x80 { 1485 break 1486 } 1487 } 1488 if packedLen < 0 { 1489 return ErrInvalidLengthBinary 1490 } 1491 postIndex := iNdEx + packedLen 1492 if postIndex > l { 1493 return io.ErrUnexpectedEOF 1494 } 1495 for iNdEx < postIndex { 1496 var v int64 1497 if (iNdEx + 8) > l { 1498 return io.ErrUnexpectedEOF 1499 } 1500 iNdEx += 8 1501 v = int64(dAtA[iNdEx-8]) 1502 v |= int64(dAtA[iNdEx-7]) << 8 1503 v |= int64(dAtA[iNdEx-6]) << 16 1504 v |= int64(dAtA[iNdEx-5]) << 24 1505 v |= int64(dAtA[iNdEx-4]) << 32 1506 v |= int64(dAtA[iNdEx-3]) << 40 1507 v |= int64(dAtA[iNdEx-2]) << 48 1508 v |= int64(dAtA[iNdEx-1]) << 56 1509 m.Timestamps = append(m.Timestamps, v) 1510 } 1511 } else { 1512 return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType) 1513 } 1514 case 2: 1515 if wireType == 0 { 1516 var v uint64 1517 for shift := uint(0); ; shift += 7 { 1518 if shift >= 64 { 1519 return ErrIntOverflowBinary 1520 } 1521 if iNdEx >= l { 1522 return io.ErrUnexpectedEOF 1523 } 1524 b := dAtA[iNdEx] 1525 iNdEx++ 1526 v |= (uint64(b) & 0x7F) << shift 1527 if b < 0x80 { 1528 break 1529 } 1530 } 1531 m.Values = append(m.Values, v) 1532 } else if wireType == 2 { 1533 var packedLen int 1534 for shift := uint(0); ; shift += 7 { 1535 if shift >= 64 { 1536 return ErrIntOverflowBinary 1537 } 1538 if iNdEx >= l { 1539 return io.ErrUnexpectedEOF 1540 } 1541 b := dAtA[iNdEx] 1542 iNdEx++ 1543 packedLen |= (int(b) & 0x7F) << shift 1544 if b < 0x80 { 1545 break 1546 } 1547 } 1548 if packedLen < 0 { 1549 return ErrInvalidLengthBinary 1550 } 1551 postIndex := iNdEx + packedLen 1552 if postIndex > l { 1553 return io.ErrUnexpectedEOF 1554 } 1555 for iNdEx < postIndex { 1556 var v uint64 1557 for shift := uint(0); ; shift += 7 { 1558 if shift >= 64 { 1559 return ErrIntOverflowBinary 1560 } 1561 if iNdEx >= l { 1562 return io.ErrUnexpectedEOF 1563 } 1564 b := dAtA[iNdEx] 1565 iNdEx++ 1566 v |= (uint64(b) & 0x7F) << shift 1567 if b < 0x80 { 1568 break 1569 } 1570 } 1571 m.Values = append(m.Values, v) 1572 } 1573 } else { 1574 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 1575 } 1576 default: 1577 iNdEx = preIndex 1578 skippy, err := skipBinary(dAtA[iNdEx:]) 1579 if err != nil { 1580 return err 1581 } 1582 if skippy < 0 { 1583 return ErrInvalidLengthBinary 1584 } 1585 if (iNdEx + skippy) > l { 1586 return io.ErrUnexpectedEOF 1587 } 1588 iNdEx += skippy 1589 } 1590 } 1591 1592 if iNdEx > l { 1593 return io.ErrUnexpectedEOF 1594 } 1595 return nil 1596} 1597func (m *BooleanPoints) Unmarshal(dAtA []byte) error { 1598 l := len(dAtA) 1599 iNdEx := 0 1600 for iNdEx < l { 1601 preIndex := iNdEx 1602 var wire uint64 1603 for shift := uint(0); ; shift += 7 { 1604 if shift >= 64 { 1605 return ErrIntOverflowBinary 1606 } 1607 if iNdEx >= l { 1608 return io.ErrUnexpectedEOF 1609 } 1610 b := dAtA[iNdEx] 1611 iNdEx++ 1612 wire |= (uint64(b) & 0x7F) << shift 1613 if b < 0x80 { 1614 break 1615 } 1616 } 1617 fieldNum := int32(wire >> 3) 1618 wireType := int(wire & 0x7) 1619 if wireType == 4 { 1620 return fmt.Errorf("proto: BooleanPoints: wiretype end group for non-group") 1621 } 1622 if fieldNum <= 0 { 1623 return fmt.Errorf("proto: BooleanPoints: illegal tag %d (wire type %d)", fieldNum, wire) 1624 } 1625 switch fieldNum { 1626 case 1: 1627 if wireType == 1 { 1628 var v int64 1629 if (iNdEx + 8) > l { 1630 return io.ErrUnexpectedEOF 1631 } 1632 iNdEx += 8 1633 v = int64(dAtA[iNdEx-8]) 1634 v |= int64(dAtA[iNdEx-7]) << 8 1635 v |= int64(dAtA[iNdEx-6]) << 16 1636 v |= int64(dAtA[iNdEx-5]) << 24 1637 v |= int64(dAtA[iNdEx-4]) << 32 1638 v |= int64(dAtA[iNdEx-3]) << 40 1639 v |= int64(dAtA[iNdEx-2]) << 48 1640 v |= int64(dAtA[iNdEx-1]) << 56 1641 m.Timestamps = append(m.Timestamps, v) 1642 } else if wireType == 2 { 1643 var packedLen int 1644 for shift := uint(0); ; shift += 7 { 1645 if shift >= 64 { 1646 return ErrIntOverflowBinary 1647 } 1648 if iNdEx >= l { 1649 return io.ErrUnexpectedEOF 1650 } 1651 b := dAtA[iNdEx] 1652 iNdEx++ 1653 packedLen |= (int(b) & 0x7F) << shift 1654 if b < 0x80 { 1655 break 1656 } 1657 } 1658 if packedLen < 0 { 1659 return ErrInvalidLengthBinary 1660 } 1661 postIndex := iNdEx + packedLen 1662 if postIndex > l { 1663 return io.ErrUnexpectedEOF 1664 } 1665 for iNdEx < postIndex { 1666 var v int64 1667 if (iNdEx + 8) > l { 1668 return io.ErrUnexpectedEOF 1669 } 1670 iNdEx += 8 1671 v = int64(dAtA[iNdEx-8]) 1672 v |= int64(dAtA[iNdEx-7]) << 8 1673 v |= int64(dAtA[iNdEx-6]) << 16 1674 v |= int64(dAtA[iNdEx-5]) << 24 1675 v |= int64(dAtA[iNdEx-4]) << 32 1676 v |= int64(dAtA[iNdEx-3]) << 40 1677 v |= int64(dAtA[iNdEx-2]) << 48 1678 v |= int64(dAtA[iNdEx-1]) << 56 1679 m.Timestamps = append(m.Timestamps, v) 1680 } 1681 } else { 1682 return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType) 1683 } 1684 case 2: 1685 if wireType == 0 { 1686 var v int 1687 for shift := uint(0); ; shift += 7 { 1688 if shift >= 64 { 1689 return ErrIntOverflowBinary 1690 } 1691 if iNdEx >= l { 1692 return io.ErrUnexpectedEOF 1693 } 1694 b := dAtA[iNdEx] 1695 iNdEx++ 1696 v |= (int(b) & 0x7F) << shift 1697 if b < 0x80 { 1698 break 1699 } 1700 } 1701 m.Values = append(m.Values, bool(v != 0)) 1702 } else if wireType == 2 { 1703 var packedLen int 1704 for shift := uint(0); ; shift += 7 { 1705 if shift >= 64 { 1706 return ErrIntOverflowBinary 1707 } 1708 if iNdEx >= l { 1709 return io.ErrUnexpectedEOF 1710 } 1711 b := dAtA[iNdEx] 1712 iNdEx++ 1713 packedLen |= (int(b) & 0x7F) << shift 1714 if b < 0x80 { 1715 break 1716 } 1717 } 1718 if packedLen < 0 { 1719 return ErrInvalidLengthBinary 1720 } 1721 postIndex := iNdEx + packedLen 1722 if postIndex > l { 1723 return io.ErrUnexpectedEOF 1724 } 1725 for iNdEx < postIndex { 1726 var v int 1727 for shift := uint(0); ; shift += 7 { 1728 if shift >= 64 { 1729 return ErrIntOverflowBinary 1730 } 1731 if iNdEx >= l { 1732 return io.ErrUnexpectedEOF 1733 } 1734 b := dAtA[iNdEx] 1735 iNdEx++ 1736 v |= (int(b) & 0x7F) << shift 1737 if b < 0x80 { 1738 break 1739 } 1740 } 1741 m.Values = append(m.Values, bool(v != 0)) 1742 } 1743 } else { 1744 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 1745 } 1746 default: 1747 iNdEx = preIndex 1748 skippy, err := skipBinary(dAtA[iNdEx:]) 1749 if err != nil { 1750 return err 1751 } 1752 if skippy < 0 { 1753 return ErrInvalidLengthBinary 1754 } 1755 if (iNdEx + skippy) > l { 1756 return io.ErrUnexpectedEOF 1757 } 1758 iNdEx += skippy 1759 } 1760 } 1761 1762 if iNdEx > l { 1763 return io.ErrUnexpectedEOF 1764 } 1765 return nil 1766} 1767func (m *StringPoints) Unmarshal(dAtA []byte) error { 1768 l := len(dAtA) 1769 iNdEx := 0 1770 for iNdEx < l { 1771 preIndex := iNdEx 1772 var wire uint64 1773 for shift := uint(0); ; shift += 7 { 1774 if shift >= 64 { 1775 return ErrIntOverflowBinary 1776 } 1777 if iNdEx >= l { 1778 return io.ErrUnexpectedEOF 1779 } 1780 b := dAtA[iNdEx] 1781 iNdEx++ 1782 wire |= (uint64(b) & 0x7F) << shift 1783 if b < 0x80 { 1784 break 1785 } 1786 } 1787 fieldNum := int32(wire >> 3) 1788 wireType := int(wire & 0x7) 1789 if wireType == 4 { 1790 return fmt.Errorf("proto: StringPoints: wiretype end group for non-group") 1791 } 1792 if fieldNum <= 0 { 1793 return fmt.Errorf("proto: StringPoints: illegal tag %d (wire type %d)", fieldNum, wire) 1794 } 1795 switch fieldNum { 1796 case 1: 1797 if wireType == 1 { 1798 var v int64 1799 if (iNdEx + 8) > l { 1800 return io.ErrUnexpectedEOF 1801 } 1802 iNdEx += 8 1803 v = int64(dAtA[iNdEx-8]) 1804 v |= int64(dAtA[iNdEx-7]) << 8 1805 v |= int64(dAtA[iNdEx-6]) << 16 1806 v |= int64(dAtA[iNdEx-5]) << 24 1807 v |= int64(dAtA[iNdEx-4]) << 32 1808 v |= int64(dAtA[iNdEx-3]) << 40 1809 v |= int64(dAtA[iNdEx-2]) << 48 1810 v |= int64(dAtA[iNdEx-1]) << 56 1811 m.Timestamps = append(m.Timestamps, v) 1812 } else if wireType == 2 { 1813 var packedLen int 1814 for shift := uint(0); ; shift += 7 { 1815 if shift >= 64 { 1816 return ErrIntOverflowBinary 1817 } 1818 if iNdEx >= l { 1819 return io.ErrUnexpectedEOF 1820 } 1821 b := dAtA[iNdEx] 1822 iNdEx++ 1823 packedLen |= (int(b) & 0x7F) << shift 1824 if b < 0x80 { 1825 break 1826 } 1827 } 1828 if packedLen < 0 { 1829 return ErrInvalidLengthBinary 1830 } 1831 postIndex := iNdEx + packedLen 1832 if postIndex > l { 1833 return io.ErrUnexpectedEOF 1834 } 1835 for iNdEx < postIndex { 1836 var v int64 1837 if (iNdEx + 8) > l { 1838 return io.ErrUnexpectedEOF 1839 } 1840 iNdEx += 8 1841 v = int64(dAtA[iNdEx-8]) 1842 v |= int64(dAtA[iNdEx-7]) << 8 1843 v |= int64(dAtA[iNdEx-6]) << 16 1844 v |= int64(dAtA[iNdEx-5]) << 24 1845 v |= int64(dAtA[iNdEx-4]) << 32 1846 v |= int64(dAtA[iNdEx-3]) << 40 1847 v |= int64(dAtA[iNdEx-2]) << 48 1848 v |= int64(dAtA[iNdEx-1]) << 56 1849 m.Timestamps = append(m.Timestamps, v) 1850 } 1851 } else { 1852 return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType) 1853 } 1854 case 2: 1855 if wireType != 2 { 1856 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 1857 } 1858 var stringLen uint64 1859 for shift := uint(0); ; shift += 7 { 1860 if shift >= 64 { 1861 return ErrIntOverflowBinary 1862 } 1863 if iNdEx >= l { 1864 return io.ErrUnexpectedEOF 1865 } 1866 b := dAtA[iNdEx] 1867 iNdEx++ 1868 stringLen |= (uint64(b) & 0x7F) << shift 1869 if b < 0x80 { 1870 break 1871 } 1872 } 1873 intStringLen := int(stringLen) 1874 if intStringLen < 0 { 1875 return ErrInvalidLengthBinary 1876 } 1877 postIndex := iNdEx + intStringLen 1878 if postIndex > l { 1879 return io.ErrUnexpectedEOF 1880 } 1881 m.Values = append(m.Values, string(dAtA[iNdEx:postIndex])) 1882 iNdEx = postIndex 1883 default: 1884 iNdEx = preIndex 1885 skippy, err := skipBinary(dAtA[iNdEx:]) 1886 if err != nil { 1887 return err 1888 } 1889 if skippy < 0 { 1890 return ErrInvalidLengthBinary 1891 } 1892 if (iNdEx + skippy) > l { 1893 return io.ErrUnexpectedEOF 1894 } 1895 iNdEx += skippy 1896 } 1897 } 1898 1899 if iNdEx > l { 1900 return io.ErrUnexpectedEOF 1901 } 1902 return nil 1903} 1904func (m *SeriesHeader) Unmarshal(dAtA []byte) error { 1905 l := len(dAtA) 1906 iNdEx := 0 1907 for iNdEx < l { 1908 preIndex := iNdEx 1909 var wire uint64 1910 for shift := uint(0); ; shift += 7 { 1911 if shift >= 64 { 1912 return ErrIntOverflowBinary 1913 } 1914 if iNdEx >= l { 1915 return io.ErrUnexpectedEOF 1916 } 1917 b := dAtA[iNdEx] 1918 iNdEx++ 1919 wire |= (uint64(b) & 0x7F) << shift 1920 if b < 0x80 { 1921 break 1922 } 1923 } 1924 fieldNum := int32(wire >> 3) 1925 wireType := int(wire & 0x7) 1926 if wireType == 4 { 1927 return fmt.Errorf("proto: SeriesHeader: wiretype end group for non-group") 1928 } 1929 if fieldNum <= 0 { 1930 return fmt.Errorf("proto: SeriesHeader: illegal tag %d (wire type %d)", fieldNum, wire) 1931 } 1932 switch fieldNum { 1933 case 1: 1934 if wireType != 0 { 1935 return fmt.Errorf("proto: wrong wireType = %d for field FieldType", wireType) 1936 } 1937 m.FieldType = 0 1938 for shift := uint(0); ; shift += 7 { 1939 if shift >= 64 { 1940 return ErrIntOverflowBinary 1941 } 1942 if iNdEx >= l { 1943 return io.ErrUnexpectedEOF 1944 } 1945 b := dAtA[iNdEx] 1946 iNdEx++ 1947 m.FieldType |= (FieldType(b) & 0x7F) << shift 1948 if b < 0x80 { 1949 break 1950 } 1951 } 1952 case 2: 1953 if wireType != 2 { 1954 return fmt.Errorf("proto: wrong wireType = %d for field SeriesKey", wireType) 1955 } 1956 var byteLen int 1957 for shift := uint(0); ; shift += 7 { 1958 if shift >= 64 { 1959 return ErrIntOverflowBinary 1960 } 1961 if iNdEx >= l { 1962 return io.ErrUnexpectedEOF 1963 } 1964 b := dAtA[iNdEx] 1965 iNdEx++ 1966 byteLen |= (int(b) & 0x7F) << shift 1967 if b < 0x80 { 1968 break 1969 } 1970 } 1971 if byteLen < 0 { 1972 return ErrInvalidLengthBinary 1973 } 1974 postIndex := iNdEx + byteLen 1975 if postIndex > l { 1976 return io.ErrUnexpectedEOF 1977 } 1978 m.SeriesKey = append(m.SeriesKey[:0], dAtA[iNdEx:postIndex]...) 1979 if m.SeriesKey == nil { 1980 m.SeriesKey = []byte{} 1981 } 1982 iNdEx = postIndex 1983 case 3: 1984 if wireType != 2 { 1985 return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType) 1986 } 1987 var byteLen int 1988 for shift := uint(0); ; shift += 7 { 1989 if shift >= 64 { 1990 return ErrIntOverflowBinary 1991 } 1992 if iNdEx >= l { 1993 return io.ErrUnexpectedEOF 1994 } 1995 b := dAtA[iNdEx] 1996 iNdEx++ 1997 byteLen |= (int(b) & 0x7F) << shift 1998 if b < 0x80 { 1999 break 2000 } 2001 } 2002 if byteLen < 0 { 2003 return ErrInvalidLengthBinary 2004 } 2005 postIndex := iNdEx + byteLen 2006 if postIndex > l { 2007 return io.ErrUnexpectedEOF 2008 } 2009 m.Field = append(m.Field[:0], dAtA[iNdEx:postIndex]...) 2010 if m.Field == nil { 2011 m.Field = []byte{} 2012 } 2013 iNdEx = postIndex 2014 default: 2015 iNdEx = preIndex 2016 skippy, err := skipBinary(dAtA[iNdEx:]) 2017 if err != nil { 2018 return err 2019 } 2020 if skippy < 0 { 2021 return ErrInvalidLengthBinary 2022 } 2023 if (iNdEx + skippy) > l { 2024 return io.ErrUnexpectedEOF 2025 } 2026 iNdEx += skippy 2027 } 2028 } 2029 2030 if iNdEx > l { 2031 return io.ErrUnexpectedEOF 2032 } 2033 return nil 2034} 2035func (m *SeriesFooter) Unmarshal(dAtA []byte) error { 2036 l := len(dAtA) 2037 iNdEx := 0 2038 for iNdEx < l { 2039 preIndex := iNdEx 2040 var wire uint64 2041 for shift := uint(0); ; shift += 7 { 2042 if shift >= 64 { 2043 return ErrIntOverflowBinary 2044 } 2045 if iNdEx >= l { 2046 return io.ErrUnexpectedEOF 2047 } 2048 b := dAtA[iNdEx] 2049 iNdEx++ 2050 wire |= (uint64(b) & 0x7F) << shift 2051 if b < 0x80 { 2052 break 2053 } 2054 } 2055 fieldNum := int32(wire >> 3) 2056 wireType := int(wire & 0x7) 2057 if wireType == 4 { 2058 return fmt.Errorf("proto: SeriesFooter: wiretype end group for non-group") 2059 } 2060 if fieldNum <= 0 { 2061 return fmt.Errorf("proto: SeriesFooter: illegal tag %d (wire type %d)", fieldNum, wire) 2062 } 2063 switch fieldNum { 2064 default: 2065 iNdEx = preIndex 2066 skippy, err := skipBinary(dAtA[iNdEx:]) 2067 if err != nil { 2068 return err 2069 } 2070 if skippy < 0 { 2071 return ErrInvalidLengthBinary 2072 } 2073 if (iNdEx + skippy) > l { 2074 return io.ErrUnexpectedEOF 2075 } 2076 iNdEx += skippy 2077 } 2078 } 2079 2080 if iNdEx > l { 2081 return io.ErrUnexpectedEOF 2082 } 2083 return nil 2084} 2085func skipBinary(dAtA []byte) (n int, err error) { 2086 l := len(dAtA) 2087 iNdEx := 0 2088 for iNdEx < l { 2089 var wire uint64 2090 for shift := uint(0); ; shift += 7 { 2091 if shift >= 64 { 2092 return 0, ErrIntOverflowBinary 2093 } 2094 if iNdEx >= l { 2095 return 0, io.ErrUnexpectedEOF 2096 } 2097 b := dAtA[iNdEx] 2098 iNdEx++ 2099 wire |= (uint64(b) & 0x7F) << shift 2100 if b < 0x80 { 2101 break 2102 } 2103 } 2104 wireType := int(wire & 0x7) 2105 switch wireType { 2106 case 0: 2107 for shift := uint(0); ; shift += 7 { 2108 if shift >= 64 { 2109 return 0, ErrIntOverflowBinary 2110 } 2111 if iNdEx >= l { 2112 return 0, io.ErrUnexpectedEOF 2113 } 2114 iNdEx++ 2115 if dAtA[iNdEx-1] < 0x80 { 2116 break 2117 } 2118 } 2119 return iNdEx, nil 2120 case 1: 2121 iNdEx += 8 2122 return iNdEx, nil 2123 case 2: 2124 var length int 2125 for shift := uint(0); ; shift += 7 { 2126 if shift >= 64 { 2127 return 0, ErrIntOverflowBinary 2128 } 2129 if iNdEx >= l { 2130 return 0, io.ErrUnexpectedEOF 2131 } 2132 b := dAtA[iNdEx] 2133 iNdEx++ 2134 length |= (int(b) & 0x7F) << shift 2135 if b < 0x80 { 2136 break 2137 } 2138 } 2139 iNdEx += length 2140 if length < 0 { 2141 return 0, ErrInvalidLengthBinary 2142 } 2143 return iNdEx, nil 2144 case 3: 2145 for { 2146 var innerWire uint64 2147 var start int = iNdEx 2148 for shift := uint(0); ; shift += 7 { 2149 if shift >= 64 { 2150 return 0, ErrIntOverflowBinary 2151 } 2152 if iNdEx >= l { 2153 return 0, io.ErrUnexpectedEOF 2154 } 2155 b := dAtA[iNdEx] 2156 iNdEx++ 2157 innerWire |= (uint64(b) & 0x7F) << shift 2158 if b < 0x80 { 2159 break 2160 } 2161 } 2162 innerWireType := int(innerWire & 0x7) 2163 if innerWireType == 4 { 2164 break 2165 } 2166 next, err := skipBinary(dAtA[start:]) 2167 if err != nil { 2168 return 0, err 2169 } 2170 iNdEx = start + next 2171 } 2172 return iNdEx, nil 2173 case 4: 2174 return iNdEx, nil 2175 case 5: 2176 iNdEx += 4 2177 return iNdEx, nil 2178 default: 2179 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 2180 } 2181 } 2182 panic("unreachable") 2183} 2184 2185var ( 2186 ErrInvalidLengthBinary = fmt.Errorf("proto: negative length found during unmarshaling") 2187 ErrIntOverflowBinary = fmt.Errorf("proto: integer overflow") 2188) 2189 2190func init() { proto.RegisterFile("binary.proto", fileDescriptorBinary) } 2191 2192var fileDescriptorBinary = []byte{ 2193 // 584 bytes of a gzipped FileDescriptorProto 2194 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x53, 0xcf, 0x4e, 0xdb, 0x4c, 2195 0x1c, 0xcc, 0xe2, 0x10, 0x92, 0xdf, 0x67, 0xc2, 0xe2, 0x8f, 0xa2, 0xc8, 0x55, 0x8d, 0x9b, 0x5e, 2196 0xd2, 0x7f, 0x01, 0xb5, 0x52, 0xef, 0x44, 0x24, 0x21, 0x2a, 0x72, 0xd0, 0x26, 0x70, 0x8d, 0x36, 2197 0x78, 0x31, 0x16, 0xc1, 0x1b, 0xad, 0xd7, 0x48, 0x7e, 0x83, 0x2a, 0xa7, 0x1e, 0x7b, 0xc9, 0xa9, 2198 0xaf, 0xd1, 0x07, 0xe0, 0xd8, 0x07, 0xa8, 0xd4, 0x96, 0xbe, 0x48, 0x95, 0x5d, 0xc7, 0xd0, 0x6b, 2199 0x6e, 0x3b, 0xbf, 0x99, 0x9d, 0xdd, 0xf5, 0x8c, 0xc1, 0x1c, 0x87, 0x11, 0x15, 0x69, 0x73, 0x2a, 2200 0xb8, 0xe4, 0x56, 0x49, 0x23, 0xfb, 0x6d, 0x10, 0xca, 0xab, 0x64, 0xdc, 0xbc, 0xe0, 0x37, 0xfb, 2201 0x01, 0x0f, 0xf8, 0xbe, 0xa2, 0xc7, 0xc9, 0xa5, 0x42, 0x0a, 0xa8, 0x95, 0xde, 0x56, 0xff, 0x81, 2202 0xa0, 0x74, 0xcc, 0xa8, 0xcf, 0x84, 0x75, 0x00, 0x1b, 0xb7, 0x4c, 0xc4, 0x21, 0x8f, 0x6a, 0xc8, 2203 0x45, 0x8d, 0xea, 0xbb, 0xdd, 0x66, 0x76, 0x82, 0x16, 0x34, 0xcf, 0x35, 0x4b, 0x96, 0x32, 0xcb, 2204 0x86, 0xb2, 0x4f, 0x25, 0x1d, 0xd3, 0x98, 0xd5, 0xd6, 0x5c, 0xd4, 0xa8, 0x90, 0x1c, 0x5b, 0x2f, 2205 0x01, 0x0b, 0x26, 0x59, 0x24, 0x43, 0x1e, 0x8d, 0xa6, 0x7c, 0x12, 0x5e, 0xa4, 0x35, 0x43, 0x69, 2206 0xb6, 0xf2, 0xf9, 0xa9, 0x1a, 0x5b, 0xaf, 0xa1, 0x1a, 0x5f, 0x51, 0xe1, 0x8f, 0xfc, 0x44, 0xd0, 2207 0xc5, 0xbc, 0x56, 0x74, 0x51, 0xc3, 0x68, 0x15, 0xbf, 0xfc, 0xdc, 0x43, 0x64, 0x53, 0x71, 0x47, 2208 0x19, 0x55, 0x7f, 0x03, 0x1b, 0xd9, 0x3d, 0xac, 0xa7, 0x50, 0x39, 0x6f, 0x93, 0x41, 0xaf, 0xef, 2209 0x8d, 0x0e, 0x70, 0xc1, 0x36, 0x67, 0x73, 0xb7, 0x9c, 0x71, 0x07, 0x76, 0xf1, 0xd3, 0x57, 0xa7, 2210 0x50, 0xff, 0x00, 0x66, 0x2b, 0xb9, 0xb8, 0x66, 0x32, 0x7b, 0xe3, 0x0e, 0xac, 0xc7, 0x92, 0x0a, 2211 0xa9, 0x5e, 0x88, 0x89, 0x06, 0x16, 0x06, 0x83, 0x45, 0xbe, 0x7a, 0x02, 0x26, 0x8b, 0x65, 0xbd, 2212 0xba, 0xdc, 0xd7, 0xe1, 0x5c, 0x32, 0x51, 0x6f, 0xc3, 0x7f, 0x9d, 0x09, 0xa7, 0xf2, 0x94, 0x87, 2213 0x91, 0x8c, 0x2d, 0x07, 0x40, 0x86, 0x37, 0x2c, 0x96, 0xf4, 0x66, 0x1a, 0xd7, 0x90, 0x6b, 0x34, 2214 0x30, 0x79, 0x34, 0xb1, 0x76, 0xa1, 0x74, 0x4b, 0x27, 0x09, 0x8b, 0x6b, 0x6b, 0xae, 0xd1, 0x40, 2215 0x24, 0x43, 0xf5, 0x2e, 0x6c, 0xf6, 0x22, 0xc9, 0x02, 0x26, 0x56, 0x32, 0x32, 0x72, 0xa3, 0x63, 2216 0xa8, 0x9e, 0x45, 0x71, 0x18, 0x44, 0xcc, 0x5f, 0xc9, 0xa9, 0xf8, 0xf8, 0x4a, 0x2d, 0xce, 0x27, 2217 0x8c, 0x46, 0x2b, 0x19, 0x95, 0x73, 0xa3, 0x0e, 0x98, 0x03, 0x29, 0xc2, 0x28, 0x58, 0xc9, 0xa7, 2218 0x92, 0xfb, 0x24, 0x60, 0x0e, 0x98, 0x08, 0x59, 0x9c, 0xd7, 0x12, 0x2e, 0x43, 0x36, 0xf1, 0x47, 2219 0x32, 0x9d, 0xb2, 0xac, 0x99, 0xdb, 0xcb, 0x66, 0x76, 0x16, 0xcc, 0x30, 0x9d, 0x32, 0x52, 0xb9, 2220 0x5c, 0x2e, 0xad, 0x67, 0x00, 0xb1, 0x72, 0x18, 0x5d, 0xb3, 0x54, 0xa5, 0x6a, 0x92, 0x8a, 0x9e, 2221 0x7c, 0x64, 0xe9, 0xa2, 0x03, 0x4a, 0xab, 0xea, 0x68, 0x12, 0x0d, 0x16, 0x89, 0xeb, 0x63, 0x75, 2222 0xe2, 0xaf, 0xbe, 0x21, 0xa8, 0x74, 0x1e, 0x59, 0xae, 0x77, 0x4e, 0xfa, 0x87, 0x43, 0x5c, 0xb0, 2223 0xad, 0xd9, 0xdc, 0xad, 0xaa, 0x32, 0x3c, 0xd0, 0xcf, 0x61, 0xa3, 0xe7, 0x0d, 0xdb, 0xdd, 0x36, 2224 0xc1, 0xc8, 0xde, 0x99, 0xcd, 0x5d, 0x9c, 0xc5, 0xfc, 0x20, 0x79, 0x01, 0xe5, 0x33, 0x6f, 0xd0, 2225 0xeb, 0x7a, 0xed, 0x23, 0xbc, 0x66, 0x3f, 0x99, 0xcd, 0xdd, 0xed, 0x65, 0x82, 0xff, 0xf8, 0xb4, 2226 0xfa, 0xfd, 0x93, 0xf6, 0xa1, 0x87, 0x0d, 0xed, 0x93, 0x65, 0xf3, 0x20, 0xd9, 0x83, 0xd2, 0x60, 2227 0x48, 0x7a, 0x5e, 0x17, 0x17, 0xed, 0xff, 0x67, 0x73, 0x77, 0x4b, 0x7f, 0xf4, 0x5c, 0xa0, 0x8b, 2228 0xdf, 0xda, 0xb9, 0xfb, 0xed, 0x14, 0xee, 0xee, 0x1d, 0xf4, 0xfd, 0xde, 0x41, 0xbf, 0xee, 0x1d, 2229 0xf4, 0xf9, 0x8f, 0x53, 0x18, 0x97, 0xd4, 0x4f, 0xff, 0xfe, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 2230 0xd5, 0x6e, 0x9c, 0xfe, 0x3b, 0x04, 0x00, 0x00, 2231} 2232