1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: storage_common.proto 3 4package datatypes 5 6import ( 7 context "context" 8 encoding_binary "encoding/binary" 9 fmt "fmt" 10 _ "github.com/gogo/protobuf/gogoproto" 11 proto "github.com/gogo/protobuf/proto" 12 types "github.com/gogo/protobuf/types" 13 grpc "google.golang.org/grpc" 14 io "io" 15 math "math" 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package 28 29type ReadGroupRequest_Group int32 30 31const ( 32 // GroupNone returns all series as a single group. 33 // The single GroupFrame.TagKeys will be the union of all tag keys. 34 GroupNone ReadGroupRequest_Group = 0 35 // GroupBy returns a group for each unique value of the specified GroupKeys. 36 GroupBy ReadGroupRequest_Group = 2 37) 38 39var ReadGroupRequest_Group_name = map[int32]string{ 40 0: "GROUP_NONE", 41 2: "GROUP_BY", 42} 43 44var ReadGroupRequest_Group_value = map[string]int32{ 45 "GROUP_NONE": 0, 46 "GROUP_BY": 2, 47} 48 49func (x ReadGroupRequest_Group) String() string { 50 return proto.EnumName(ReadGroupRequest_Group_name, int32(x)) 51} 52 53func (ReadGroupRequest_Group) EnumDescriptor() ([]byte, []int) { 54 return fileDescriptor_715e4bf4cdf1f73d, []int{1, 0} 55} 56 57// TODO(jlapacik): This field is only used in unit tests. 58// Specifically the two tests in group_resultset_test.go. 59// This field should be removed and the tests that depend 60// on it refactored. 61type ReadGroupRequest_HintFlags int32 62 63const ( 64 HintNone ReadGroupRequest_HintFlags = 0 65 HintNoPoints ReadGroupRequest_HintFlags = 1 66 HintNoSeries ReadGroupRequest_HintFlags = 2 67 // HintSchemaAllTime performs schema queries without using time ranges 68 HintSchemaAllTime ReadGroupRequest_HintFlags = 4 69) 70 71var ReadGroupRequest_HintFlags_name = map[int32]string{ 72 0: "HINT_NONE", 73 1: "HINT_NO_POINTS", 74 2: "HINT_NO_SERIES", 75 4: "HINT_SCHEMA_ALL_TIME", 76} 77 78var ReadGroupRequest_HintFlags_value = map[string]int32{ 79 "HINT_NONE": 0, 80 "HINT_NO_POINTS": 1, 81 "HINT_NO_SERIES": 2, 82 "HINT_SCHEMA_ALL_TIME": 4, 83} 84 85func (x ReadGroupRequest_HintFlags) String() string { 86 return proto.EnumName(ReadGroupRequest_HintFlags_name, int32(x)) 87} 88 89func (ReadGroupRequest_HintFlags) EnumDescriptor() ([]byte, []int) { 90 return fileDescriptor_715e4bf4cdf1f73d, []int{1, 1} 91} 92 93type Aggregate_AggregateType int32 94 95const ( 96 AggregateTypeNone Aggregate_AggregateType = 0 97 AggregateTypeSum Aggregate_AggregateType = 1 98 AggregateTypeCount Aggregate_AggregateType = 2 99) 100 101var Aggregate_AggregateType_name = map[int32]string{ 102 0: "NONE", 103 1: "SUM", 104 2: "COUNT", 105} 106 107var Aggregate_AggregateType_value = map[string]int32{ 108 "NONE": 0, 109 "SUM": 1, 110 "COUNT": 2, 111} 112 113func (x Aggregate_AggregateType) String() string { 114 return proto.EnumName(Aggregate_AggregateType_name, int32(x)) 115} 116 117func (Aggregate_AggregateType) EnumDescriptor() ([]byte, []int) { 118 return fileDescriptor_715e4bf4cdf1f73d, []int{2, 0} 119} 120 121type ReadResponse_FrameType int32 122 123const ( 124 FrameTypeSeries ReadResponse_FrameType = 0 125 FrameTypePoints ReadResponse_FrameType = 1 126) 127 128var ReadResponse_FrameType_name = map[int32]string{ 129 0: "SERIES", 130 1: "POINTS", 131} 132 133var ReadResponse_FrameType_value = map[string]int32{ 134 "SERIES": 0, 135 "POINTS": 1, 136} 137 138func (x ReadResponse_FrameType) String() string { 139 return proto.EnumName(ReadResponse_FrameType_name, int32(x)) 140} 141 142func (ReadResponse_FrameType) EnumDescriptor() ([]byte, []int) { 143 return fileDescriptor_715e4bf4cdf1f73d, []int{4, 0} 144} 145 146type ReadResponse_DataType int32 147 148const ( 149 DataTypeFloat ReadResponse_DataType = 0 150 DataTypeInteger ReadResponse_DataType = 1 151 DataTypeUnsigned ReadResponse_DataType = 2 152 DataTypeBoolean ReadResponse_DataType = 3 153 DataTypeString ReadResponse_DataType = 4 154) 155 156var ReadResponse_DataType_name = map[int32]string{ 157 0: "FLOAT", 158 1: "INTEGER", 159 2: "UNSIGNED", 160 3: "BOOLEAN", 161 4: "STRING", 162} 163 164var ReadResponse_DataType_value = map[string]int32{ 165 "FLOAT": 0, 166 "INTEGER": 1, 167 "UNSIGNED": 2, 168 "BOOLEAN": 3, 169 "STRING": 4, 170} 171 172func (x ReadResponse_DataType) String() string { 173 return proto.EnumName(ReadResponse_DataType_name, int32(x)) 174} 175 176func (ReadResponse_DataType) EnumDescriptor() ([]byte, []int) { 177 return fileDescriptor_715e4bf4cdf1f73d, []int{4, 1} 178} 179 180type ReadFilterRequest struct { 181 ReadSource *types.Any `protobuf:"bytes,1,opt,name=read_source,json=readSource,proto3" json:"read_source,omitempty"` 182 Range TimestampRange `protobuf:"bytes,2,opt,name=range,proto3" json:"range"` 183 Predicate *Predicate `protobuf:"bytes,3,opt,name=predicate,proto3" json:"predicate,omitempty"` 184} 185 186func (m *ReadFilterRequest) Reset() { *m = ReadFilterRequest{} } 187func (m *ReadFilterRequest) String() string { return proto.CompactTextString(m) } 188func (*ReadFilterRequest) ProtoMessage() {} 189func (*ReadFilterRequest) Descriptor() ([]byte, []int) { 190 return fileDescriptor_715e4bf4cdf1f73d, []int{0} 191} 192func (m *ReadFilterRequest) XXX_Unmarshal(b []byte) error { 193 return m.Unmarshal(b) 194} 195func (m *ReadFilterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 196 if deterministic { 197 return xxx_messageInfo_ReadFilterRequest.Marshal(b, m, deterministic) 198 } else { 199 b = b[:cap(b)] 200 n, err := m.MarshalTo(b) 201 if err != nil { 202 return nil, err 203 } 204 return b[:n], nil 205 } 206} 207func (m *ReadFilterRequest) XXX_Merge(src proto.Message) { 208 xxx_messageInfo_ReadFilterRequest.Merge(m, src) 209} 210func (m *ReadFilterRequest) XXX_Size() int { 211 return m.Size() 212} 213func (m *ReadFilterRequest) XXX_DiscardUnknown() { 214 xxx_messageInfo_ReadFilterRequest.DiscardUnknown(m) 215} 216 217var xxx_messageInfo_ReadFilterRequest proto.InternalMessageInfo 218 219type ReadGroupRequest struct { 220 ReadSource *types.Any `protobuf:"bytes,1,opt,name=read_source,json=readSource,proto3" json:"read_source,omitempty"` 221 Range TimestampRange `protobuf:"bytes,2,opt,name=range,proto3" json:"range"` 222 Predicate *Predicate `protobuf:"bytes,3,opt,name=predicate,proto3" json:"predicate,omitempty"` 223 // GroupKeys specifies a list of tag keys used to order the data. 224 // It is dependent on the Group property to determine its behavior. 225 GroupKeys []string `protobuf:"bytes,4,rep,name=group_keys,json=groupKeys,proto3" json:"group_keys,omitempty"` 226 Group ReadGroupRequest_Group `protobuf:"varint,5,opt,name=group,proto3,enum=influxdata.platform.storage.ReadGroupRequest_Group" json:"group,omitempty"` 227 Aggregate *Aggregate `protobuf:"bytes,6,opt,name=aggregate,proto3" json:"aggregate,omitempty"` 228 Hints HintFlags `protobuf:"fixed32,7,opt,name=hints,proto3,casttype=HintFlags" json:"hints,omitempty"` 229} 230 231func (m *ReadGroupRequest) Reset() { *m = ReadGroupRequest{} } 232func (m *ReadGroupRequest) String() string { return proto.CompactTextString(m) } 233func (*ReadGroupRequest) ProtoMessage() {} 234func (*ReadGroupRequest) Descriptor() ([]byte, []int) { 235 return fileDescriptor_715e4bf4cdf1f73d, []int{1} 236} 237func (m *ReadGroupRequest) XXX_Unmarshal(b []byte) error { 238 return m.Unmarshal(b) 239} 240func (m *ReadGroupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 241 if deterministic { 242 return xxx_messageInfo_ReadGroupRequest.Marshal(b, m, deterministic) 243 } else { 244 b = b[:cap(b)] 245 n, err := m.MarshalTo(b) 246 if err != nil { 247 return nil, err 248 } 249 return b[:n], nil 250 } 251} 252func (m *ReadGroupRequest) XXX_Merge(src proto.Message) { 253 xxx_messageInfo_ReadGroupRequest.Merge(m, src) 254} 255func (m *ReadGroupRequest) XXX_Size() int { 256 return m.Size() 257} 258func (m *ReadGroupRequest) XXX_DiscardUnknown() { 259 xxx_messageInfo_ReadGroupRequest.DiscardUnknown(m) 260} 261 262var xxx_messageInfo_ReadGroupRequest proto.InternalMessageInfo 263 264type Aggregate struct { 265 Type Aggregate_AggregateType `protobuf:"varint,1,opt,name=type,proto3,enum=influxdata.platform.storage.Aggregate_AggregateType" json:"type,omitempty"` 266} 267 268func (m *Aggregate) Reset() { *m = Aggregate{} } 269func (m *Aggregate) String() string { return proto.CompactTextString(m) } 270func (*Aggregate) ProtoMessage() {} 271func (*Aggregate) Descriptor() ([]byte, []int) { 272 return fileDescriptor_715e4bf4cdf1f73d, []int{2} 273} 274func (m *Aggregate) XXX_Unmarshal(b []byte) error { 275 return m.Unmarshal(b) 276} 277func (m *Aggregate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 278 if deterministic { 279 return xxx_messageInfo_Aggregate.Marshal(b, m, deterministic) 280 } else { 281 b = b[:cap(b)] 282 n, err := m.MarshalTo(b) 283 if err != nil { 284 return nil, err 285 } 286 return b[:n], nil 287 } 288} 289func (m *Aggregate) XXX_Merge(src proto.Message) { 290 xxx_messageInfo_Aggregate.Merge(m, src) 291} 292func (m *Aggregate) XXX_Size() int { 293 return m.Size() 294} 295func (m *Aggregate) XXX_DiscardUnknown() { 296 xxx_messageInfo_Aggregate.DiscardUnknown(m) 297} 298 299var xxx_messageInfo_Aggregate proto.InternalMessageInfo 300 301type Tag struct { 302 Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` 303 Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` 304} 305 306func (m *Tag) Reset() { *m = Tag{} } 307func (m *Tag) String() string { return proto.CompactTextString(m) } 308func (*Tag) ProtoMessage() {} 309func (*Tag) Descriptor() ([]byte, []int) { 310 return fileDescriptor_715e4bf4cdf1f73d, []int{3} 311} 312func (m *Tag) XXX_Unmarshal(b []byte) error { 313 return m.Unmarshal(b) 314} 315func (m *Tag) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 316 if deterministic { 317 return xxx_messageInfo_Tag.Marshal(b, m, deterministic) 318 } else { 319 b = b[:cap(b)] 320 n, err := m.MarshalTo(b) 321 if err != nil { 322 return nil, err 323 } 324 return b[:n], nil 325 } 326} 327func (m *Tag) XXX_Merge(src proto.Message) { 328 xxx_messageInfo_Tag.Merge(m, src) 329} 330func (m *Tag) XXX_Size() int { 331 return m.Size() 332} 333func (m *Tag) XXX_DiscardUnknown() { 334 xxx_messageInfo_Tag.DiscardUnknown(m) 335} 336 337var xxx_messageInfo_Tag proto.InternalMessageInfo 338 339// Response message for ReadFilter and ReadGroup 340type ReadResponse struct { 341 Frames []ReadResponse_Frame `protobuf:"bytes,1,rep,name=frames,proto3" json:"frames"` 342} 343 344func (m *ReadResponse) Reset() { *m = ReadResponse{} } 345func (m *ReadResponse) String() string { return proto.CompactTextString(m) } 346func (*ReadResponse) ProtoMessage() {} 347func (*ReadResponse) Descriptor() ([]byte, []int) { 348 return fileDescriptor_715e4bf4cdf1f73d, []int{4} 349} 350func (m *ReadResponse) XXX_Unmarshal(b []byte) error { 351 return m.Unmarshal(b) 352} 353func (m *ReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 354 if deterministic { 355 return xxx_messageInfo_ReadResponse.Marshal(b, m, deterministic) 356 } else { 357 b = b[:cap(b)] 358 n, err := m.MarshalTo(b) 359 if err != nil { 360 return nil, err 361 } 362 return b[:n], nil 363 } 364} 365func (m *ReadResponse) XXX_Merge(src proto.Message) { 366 xxx_messageInfo_ReadResponse.Merge(m, src) 367} 368func (m *ReadResponse) XXX_Size() int { 369 return m.Size() 370} 371func (m *ReadResponse) XXX_DiscardUnknown() { 372 xxx_messageInfo_ReadResponse.DiscardUnknown(m) 373} 374 375var xxx_messageInfo_ReadResponse proto.InternalMessageInfo 376 377type ReadResponse_Frame struct { 378 // Types that are valid to be assigned to Data: 379 // *ReadResponse_Frame_Group 380 // *ReadResponse_Frame_Series 381 // *ReadResponse_Frame_FloatPoints 382 // *ReadResponse_Frame_IntegerPoints 383 // *ReadResponse_Frame_UnsignedPoints 384 // *ReadResponse_Frame_BooleanPoints 385 // *ReadResponse_Frame_StringPoints 386 Data isReadResponse_Frame_Data `protobuf_oneof:"data"` 387} 388 389func (m *ReadResponse_Frame) Reset() { *m = ReadResponse_Frame{} } 390func (m *ReadResponse_Frame) String() string { return proto.CompactTextString(m) } 391func (*ReadResponse_Frame) ProtoMessage() {} 392func (*ReadResponse_Frame) Descriptor() ([]byte, []int) { 393 return fileDescriptor_715e4bf4cdf1f73d, []int{4, 0} 394} 395func (m *ReadResponse_Frame) XXX_Unmarshal(b []byte) error { 396 return m.Unmarshal(b) 397} 398func (m *ReadResponse_Frame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 399 if deterministic { 400 return xxx_messageInfo_ReadResponse_Frame.Marshal(b, m, deterministic) 401 } else { 402 b = b[:cap(b)] 403 n, err := m.MarshalTo(b) 404 if err != nil { 405 return nil, err 406 } 407 return b[:n], nil 408 } 409} 410func (m *ReadResponse_Frame) XXX_Merge(src proto.Message) { 411 xxx_messageInfo_ReadResponse_Frame.Merge(m, src) 412} 413func (m *ReadResponse_Frame) XXX_Size() int { 414 return m.Size() 415} 416func (m *ReadResponse_Frame) XXX_DiscardUnknown() { 417 xxx_messageInfo_ReadResponse_Frame.DiscardUnknown(m) 418} 419 420var xxx_messageInfo_ReadResponse_Frame proto.InternalMessageInfo 421 422type isReadResponse_Frame_Data interface { 423 isReadResponse_Frame_Data() 424 MarshalTo([]byte) (int, error) 425 Size() int 426} 427 428type ReadResponse_Frame_Group struct { 429 Group *ReadResponse_GroupFrame `protobuf:"bytes,7,opt,name=group,proto3,oneof"` 430} 431type ReadResponse_Frame_Series struct { 432 Series *ReadResponse_SeriesFrame `protobuf:"bytes,1,opt,name=series,proto3,oneof"` 433} 434type ReadResponse_Frame_FloatPoints struct { 435 FloatPoints *ReadResponse_FloatPointsFrame `protobuf:"bytes,2,opt,name=float_points,json=floatPoints,proto3,oneof"` 436} 437type ReadResponse_Frame_IntegerPoints struct { 438 IntegerPoints *ReadResponse_IntegerPointsFrame `protobuf:"bytes,3,opt,name=integer_points,json=integerPoints,proto3,oneof"` 439} 440type ReadResponse_Frame_UnsignedPoints struct { 441 UnsignedPoints *ReadResponse_UnsignedPointsFrame `protobuf:"bytes,4,opt,name=unsigned_points,json=unsignedPoints,proto3,oneof"` 442} 443type ReadResponse_Frame_BooleanPoints struct { 444 BooleanPoints *ReadResponse_BooleanPointsFrame `protobuf:"bytes,5,opt,name=boolean_points,json=booleanPoints,proto3,oneof"` 445} 446type ReadResponse_Frame_StringPoints struct { 447 StringPoints *ReadResponse_StringPointsFrame `protobuf:"bytes,6,opt,name=string_points,json=stringPoints,proto3,oneof"` 448} 449 450func (*ReadResponse_Frame_Group) isReadResponse_Frame_Data() {} 451func (*ReadResponse_Frame_Series) isReadResponse_Frame_Data() {} 452func (*ReadResponse_Frame_FloatPoints) isReadResponse_Frame_Data() {} 453func (*ReadResponse_Frame_IntegerPoints) isReadResponse_Frame_Data() {} 454func (*ReadResponse_Frame_UnsignedPoints) isReadResponse_Frame_Data() {} 455func (*ReadResponse_Frame_BooleanPoints) isReadResponse_Frame_Data() {} 456func (*ReadResponse_Frame_StringPoints) isReadResponse_Frame_Data() {} 457 458func (m *ReadResponse_Frame) GetData() isReadResponse_Frame_Data { 459 if m != nil { 460 return m.Data 461 } 462 return nil 463} 464 465func (m *ReadResponse_Frame) GetGroup() *ReadResponse_GroupFrame { 466 if x, ok := m.GetData().(*ReadResponse_Frame_Group); ok { 467 return x.Group 468 } 469 return nil 470} 471 472func (m *ReadResponse_Frame) GetSeries() *ReadResponse_SeriesFrame { 473 if x, ok := m.GetData().(*ReadResponse_Frame_Series); ok { 474 return x.Series 475 } 476 return nil 477} 478 479func (m *ReadResponse_Frame) GetFloatPoints() *ReadResponse_FloatPointsFrame { 480 if x, ok := m.GetData().(*ReadResponse_Frame_FloatPoints); ok { 481 return x.FloatPoints 482 } 483 return nil 484} 485 486func (m *ReadResponse_Frame) GetIntegerPoints() *ReadResponse_IntegerPointsFrame { 487 if x, ok := m.GetData().(*ReadResponse_Frame_IntegerPoints); ok { 488 return x.IntegerPoints 489 } 490 return nil 491} 492 493func (m *ReadResponse_Frame) GetUnsignedPoints() *ReadResponse_UnsignedPointsFrame { 494 if x, ok := m.GetData().(*ReadResponse_Frame_UnsignedPoints); ok { 495 return x.UnsignedPoints 496 } 497 return nil 498} 499 500func (m *ReadResponse_Frame) GetBooleanPoints() *ReadResponse_BooleanPointsFrame { 501 if x, ok := m.GetData().(*ReadResponse_Frame_BooleanPoints); ok { 502 return x.BooleanPoints 503 } 504 return nil 505} 506 507func (m *ReadResponse_Frame) GetStringPoints() *ReadResponse_StringPointsFrame { 508 if x, ok := m.GetData().(*ReadResponse_Frame_StringPoints); ok { 509 return x.StringPoints 510 } 511 return nil 512} 513 514// XXX_OneofFuncs is for the internal use of the proto package. 515func (*ReadResponse_Frame) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { 516 return _ReadResponse_Frame_OneofMarshaler, _ReadResponse_Frame_OneofUnmarshaler, _ReadResponse_Frame_OneofSizer, []interface{}{ 517 (*ReadResponse_Frame_Group)(nil), 518 (*ReadResponse_Frame_Series)(nil), 519 (*ReadResponse_Frame_FloatPoints)(nil), 520 (*ReadResponse_Frame_IntegerPoints)(nil), 521 (*ReadResponse_Frame_UnsignedPoints)(nil), 522 (*ReadResponse_Frame_BooleanPoints)(nil), 523 (*ReadResponse_Frame_StringPoints)(nil), 524 } 525} 526 527func _ReadResponse_Frame_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { 528 m := msg.(*ReadResponse_Frame) 529 // data 530 switch x := m.Data.(type) { 531 case *ReadResponse_Frame_Group: 532 _ = b.EncodeVarint(7<<3 | proto.WireBytes) 533 if err := b.EncodeMessage(x.Group); err != nil { 534 return err 535 } 536 case *ReadResponse_Frame_Series: 537 _ = b.EncodeVarint(1<<3 | proto.WireBytes) 538 if err := b.EncodeMessage(x.Series); err != nil { 539 return err 540 } 541 case *ReadResponse_Frame_FloatPoints: 542 _ = b.EncodeVarint(2<<3 | proto.WireBytes) 543 if err := b.EncodeMessage(x.FloatPoints); err != nil { 544 return err 545 } 546 case *ReadResponse_Frame_IntegerPoints: 547 _ = b.EncodeVarint(3<<3 | proto.WireBytes) 548 if err := b.EncodeMessage(x.IntegerPoints); err != nil { 549 return err 550 } 551 case *ReadResponse_Frame_UnsignedPoints: 552 _ = b.EncodeVarint(4<<3 | proto.WireBytes) 553 if err := b.EncodeMessage(x.UnsignedPoints); err != nil { 554 return err 555 } 556 case *ReadResponse_Frame_BooleanPoints: 557 _ = b.EncodeVarint(5<<3 | proto.WireBytes) 558 if err := b.EncodeMessage(x.BooleanPoints); err != nil { 559 return err 560 } 561 case *ReadResponse_Frame_StringPoints: 562 _ = b.EncodeVarint(6<<3 | proto.WireBytes) 563 if err := b.EncodeMessage(x.StringPoints); err != nil { 564 return err 565 } 566 case nil: 567 default: 568 return fmt.Errorf("ReadResponse_Frame.Data has unexpected type %T", x) 569 } 570 return nil 571} 572 573func _ReadResponse_Frame_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { 574 m := msg.(*ReadResponse_Frame) 575 switch tag { 576 case 7: // data.group 577 if wire != proto.WireBytes { 578 return true, proto.ErrInternalBadWireType 579 } 580 msg := new(ReadResponse_GroupFrame) 581 err := b.DecodeMessage(msg) 582 m.Data = &ReadResponse_Frame_Group{msg} 583 return true, err 584 case 1: // data.series 585 if wire != proto.WireBytes { 586 return true, proto.ErrInternalBadWireType 587 } 588 msg := new(ReadResponse_SeriesFrame) 589 err := b.DecodeMessage(msg) 590 m.Data = &ReadResponse_Frame_Series{msg} 591 return true, err 592 case 2: // data.float_points 593 if wire != proto.WireBytes { 594 return true, proto.ErrInternalBadWireType 595 } 596 msg := new(ReadResponse_FloatPointsFrame) 597 err := b.DecodeMessage(msg) 598 m.Data = &ReadResponse_Frame_FloatPoints{msg} 599 return true, err 600 case 3: // data.integer_points 601 if wire != proto.WireBytes { 602 return true, proto.ErrInternalBadWireType 603 } 604 msg := new(ReadResponse_IntegerPointsFrame) 605 err := b.DecodeMessage(msg) 606 m.Data = &ReadResponse_Frame_IntegerPoints{msg} 607 return true, err 608 case 4: // data.unsigned_points 609 if wire != proto.WireBytes { 610 return true, proto.ErrInternalBadWireType 611 } 612 msg := new(ReadResponse_UnsignedPointsFrame) 613 err := b.DecodeMessage(msg) 614 m.Data = &ReadResponse_Frame_UnsignedPoints{msg} 615 return true, err 616 case 5: // data.boolean_points 617 if wire != proto.WireBytes { 618 return true, proto.ErrInternalBadWireType 619 } 620 msg := new(ReadResponse_BooleanPointsFrame) 621 err := b.DecodeMessage(msg) 622 m.Data = &ReadResponse_Frame_BooleanPoints{msg} 623 return true, err 624 case 6: // data.string_points 625 if wire != proto.WireBytes { 626 return true, proto.ErrInternalBadWireType 627 } 628 msg := new(ReadResponse_StringPointsFrame) 629 err := b.DecodeMessage(msg) 630 m.Data = &ReadResponse_Frame_StringPoints{msg} 631 return true, err 632 default: 633 return false, nil 634 } 635} 636 637func _ReadResponse_Frame_OneofSizer(msg proto.Message) (n int) { 638 m := msg.(*ReadResponse_Frame) 639 // data 640 switch x := m.Data.(type) { 641 case *ReadResponse_Frame_Group: 642 s := proto.Size(x.Group) 643 n += 1 // tag and wire 644 n += proto.SizeVarint(uint64(s)) 645 n += s 646 case *ReadResponse_Frame_Series: 647 s := proto.Size(x.Series) 648 n += 1 // tag and wire 649 n += proto.SizeVarint(uint64(s)) 650 n += s 651 case *ReadResponse_Frame_FloatPoints: 652 s := proto.Size(x.FloatPoints) 653 n += 1 // tag and wire 654 n += proto.SizeVarint(uint64(s)) 655 n += s 656 case *ReadResponse_Frame_IntegerPoints: 657 s := proto.Size(x.IntegerPoints) 658 n += 1 // tag and wire 659 n += proto.SizeVarint(uint64(s)) 660 n += s 661 case *ReadResponse_Frame_UnsignedPoints: 662 s := proto.Size(x.UnsignedPoints) 663 n += 1 // tag and wire 664 n += proto.SizeVarint(uint64(s)) 665 n += s 666 case *ReadResponse_Frame_BooleanPoints: 667 s := proto.Size(x.BooleanPoints) 668 n += 1 // tag and wire 669 n += proto.SizeVarint(uint64(s)) 670 n += s 671 case *ReadResponse_Frame_StringPoints: 672 s := proto.Size(x.StringPoints) 673 n += 1 // tag and wire 674 n += proto.SizeVarint(uint64(s)) 675 n += s 676 case nil: 677 default: 678 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) 679 } 680 return n 681} 682 683type ReadResponse_GroupFrame struct { 684 // TagKeys 685 TagKeys [][]byte `protobuf:"bytes,1,rep,name=tag_keys,json=tagKeys,proto3" json:"tag_keys,omitempty"` 686 // PartitionKeyVals is the values of the partition key for this group, order matching ReadGroupRequest.GroupKeys 687 PartitionKeyVals [][]byte `protobuf:"bytes,2,rep,name=partition_key_vals,json=partitionKeyVals,proto3" json:"partition_key_vals,omitempty"` 688} 689 690func (m *ReadResponse_GroupFrame) Reset() { *m = ReadResponse_GroupFrame{} } 691func (m *ReadResponse_GroupFrame) String() string { return proto.CompactTextString(m) } 692func (*ReadResponse_GroupFrame) ProtoMessage() {} 693func (*ReadResponse_GroupFrame) Descriptor() ([]byte, []int) { 694 return fileDescriptor_715e4bf4cdf1f73d, []int{4, 1} 695} 696func (m *ReadResponse_GroupFrame) XXX_Unmarshal(b []byte) error { 697 return m.Unmarshal(b) 698} 699func (m *ReadResponse_GroupFrame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 700 if deterministic { 701 return xxx_messageInfo_ReadResponse_GroupFrame.Marshal(b, m, deterministic) 702 } else { 703 b = b[:cap(b)] 704 n, err := m.MarshalTo(b) 705 if err != nil { 706 return nil, err 707 } 708 return b[:n], nil 709 } 710} 711func (m *ReadResponse_GroupFrame) XXX_Merge(src proto.Message) { 712 xxx_messageInfo_ReadResponse_GroupFrame.Merge(m, src) 713} 714func (m *ReadResponse_GroupFrame) XXX_Size() int { 715 return m.Size() 716} 717func (m *ReadResponse_GroupFrame) XXX_DiscardUnknown() { 718 xxx_messageInfo_ReadResponse_GroupFrame.DiscardUnknown(m) 719} 720 721var xxx_messageInfo_ReadResponse_GroupFrame proto.InternalMessageInfo 722 723type ReadResponse_SeriesFrame struct { 724 Tags []Tag `protobuf:"bytes,1,rep,name=tags,proto3" json:"tags"` 725 DataType ReadResponse_DataType `protobuf:"varint,2,opt,name=data_type,json=dataType,proto3,enum=influxdata.platform.storage.ReadResponse_DataType" json:"data_type,omitempty"` 726} 727 728func (m *ReadResponse_SeriesFrame) Reset() { *m = ReadResponse_SeriesFrame{} } 729func (m *ReadResponse_SeriesFrame) String() string { return proto.CompactTextString(m) } 730func (*ReadResponse_SeriesFrame) ProtoMessage() {} 731func (*ReadResponse_SeriesFrame) Descriptor() ([]byte, []int) { 732 return fileDescriptor_715e4bf4cdf1f73d, []int{4, 2} 733} 734func (m *ReadResponse_SeriesFrame) XXX_Unmarshal(b []byte) error { 735 return m.Unmarshal(b) 736} 737func (m *ReadResponse_SeriesFrame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 738 if deterministic { 739 return xxx_messageInfo_ReadResponse_SeriesFrame.Marshal(b, m, deterministic) 740 } else { 741 b = b[:cap(b)] 742 n, err := m.MarshalTo(b) 743 if err != nil { 744 return nil, err 745 } 746 return b[:n], nil 747 } 748} 749func (m *ReadResponse_SeriesFrame) XXX_Merge(src proto.Message) { 750 xxx_messageInfo_ReadResponse_SeriesFrame.Merge(m, src) 751} 752func (m *ReadResponse_SeriesFrame) XXX_Size() int { 753 return m.Size() 754} 755func (m *ReadResponse_SeriesFrame) XXX_DiscardUnknown() { 756 xxx_messageInfo_ReadResponse_SeriesFrame.DiscardUnknown(m) 757} 758 759var xxx_messageInfo_ReadResponse_SeriesFrame proto.InternalMessageInfo 760 761type ReadResponse_FloatPointsFrame struct { 762 Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps,proto3" json:"timestamps,omitempty"` 763 Values []float64 `protobuf:"fixed64,2,rep,packed,name=values,proto3" json:"values,omitempty"` 764} 765 766func (m *ReadResponse_FloatPointsFrame) Reset() { *m = ReadResponse_FloatPointsFrame{} } 767func (m *ReadResponse_FloatPointsFrame) String() string { return proto.CompactTextString(m) } 768func (*ReadResponse_FloatPointsFrame) ProtoMessage() {} 769func (*ReadResponse_FloatPointsFrame) Descriptor() ([]byte, []int) { 770 return fileDescriptor_715e4bf4cdf1f73d, []int{4, 3} 771} 772func (m *ReadResponse_FloatPointsFrame) XXX_Unmarshal(b []byte) error { 773 return m.Unmarshal(b) 774} 775func (m *ReadResponse_FloatPointsFrame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 776 if deterministic { 777 return xxx_messageInfo_ReadResponse_FloatPointsFrame.Marshal(b, m, deterministic) 778 } else { 779 b = b[:cap(b)] 780 n, err := m.MarshalTo(b) 781 if err != nil { 782 return nil, err 783 } 784 return b[:n], nil 785 } 786} 787func (m *ReadResponse_FloatPointsFrame) XXX_Merge(src proto.Message) { 788 xxx_messageInfo_ReadResponse_FloatPointsFrame.Merge(m, src) 789} 790func (m *ReadResponse_FloatPointsFrame) XXX_Size() int { 791 return m.Size() 792} 793func (m *ReadResponse_FloatPointsFrame) XXX_DiscardUnknown() { 794 xxx_messageInfo_ReadResponse_FloatPointsFrame.DiscardUnknown(m) 795} 796 797var xxx_messageInfo_ReadResponse_FloatPointsFrame proto.InternalMessageInfo 798 799type ReadResponse_IntegerPointsFrame struct { 800 Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps,proto3" json:"timestamps,omitempty"` 801 Values []int64 `protobuf:"varint,2,rep,packed,name=values,proto3" json:"values,omitempty"` 802} 803 804func (m *ReadResponse_IntegerPointsFrame) Reset() { *m = ReadResponse_IntegerPointsFrame{} } 805func (m *ReadResponse_IntegerPointsFrame) String() string { return proto.CompactTextString(m) } 806func (*ReadResponse_IntegerPointsFrame) ProtoMessage() {} 807func (*ReadResponse_IntegerPointsFrame) Descriptor() ([]byte, []int) { 808 return fileDescriptor_715e4bf4cdf1f73d, []int{4, 4} 809} 810func (m *ReadResponse_IntegerPointsFrame) XXX_Unmarshal(b []byte) error { 811 return m.Unmarshal(b) 812} 813func (m *ReadResponse_IntegerPointsFrame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 814 if deterministic { 815 return xxx_messageInfo_ReadResponse_IntegerPointsFrame.Marshal(b, m, deterministic) 816 } else { 817 b = b[:cap(b)] 818 n, err := m.MarshalTo(b) 819 if err != nil { 820 return nil, err 821 } 822 return b[:n], nil 823 } 824} 825func (m *ReadResponse_IntegerPointsFrame) XXX_Merge(src proto.Message) { 826 xxx_messageInfo_ReadResponse_IntegerPointsFrame.Merge(m, src) 827} 828func (m *ReadResponse_IntegerPointsFrame) XXX_Size() int { 829 return m.Size() 830} 831func (m *ReadResponse_IntegerPointsFrame) XXX_DiscardUnknown() { 832 xxx_messageInfo_ReadResponse_IntegerPointsFrame.DiscardUnknown(m) 833} 834 835var xxx_messageInfo_ReadResponse_IntegerPointsFrame proto.InternalMessageInfo 836 837type ReadResponse_UnsignedPointsFrame struct { 838 Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps,proto3" json:"timestamps,omitempty"` 839 Values []uint64 `protobuf:"varint,2,rep,packed,name=values,proto3" json:"values,omitempty"` 840} 841 842func (m *ReadResponse_UnsignedPointsFrame) Reset() { *m = ReadResponse_UnsignedPointsFrame{} } 843func (m *ReadResponse_UnsignedPointsFrame) String() string { return proto.CompactTextString(m) } 844func (*ReadResponse_UnsignedPointsFrame) ProtoMessage() {} 845func (*ReadResponse_UnsignedPointsFrame) Descriptor() ([]byte, []int) { 846 return fileDescriptor_715e4bf4cdf1f73d, []int{4, 5} 847} 848func (m *ReadResponse_UnsignedPointsFrame) XXX_Unmarshal(b []byte) error { 849 return m.Unmarshal(b) 850} 851func (m *ReadResponse_UnsignedPointsFrame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 852 if deterministic { 853 return xxx_messageInfo_ReadResponse_UnsignedPointsFrame.Marshal(b, m, deterministic) 854 } else { 855 b = b[:cap(b)] 856 n, err := m.MarshalTo(b) 857 if err != nil { 858 return nil, err 859 } 860 return b[:n], nil 861 } 862} 863func (m *ReadResponse_UnsignedPointsFrame) XXX_Merge(src proto.Message) { 864 xxx_messageInfo_ReadResponse_UnsignedPointsFrame.Merge(m, src) 865} 866func (m *ReadResponse_UnsignedPointsFrame) XXX_Size() int { 867 return m.Size() 868} 869func (m *ReadResponse_UnsignedPointsFrame) XXX_DiscardUnknown() { 870 xxx_messageInfo_ReadResponse_UnsignedPointsFrame.DiscardUnknown(m) 871} 872 873var xxx_messageInfo_ReadResponse_UnsignedPointsFrame proto.InternalMessageInfo 874 875type ReadResponse_BooleanPointsFrame struct { 876 Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps,proto3" json:"timestamps,omitempty"` 877 Values []bool `protobuf:"varint,2,rep,packed,name=values,proto3" json:"values,omitempty"` 878} 879 880func (m *ReadResponse_BooleanPointsFrame) Reset() { *m = ReadResponse_BooleanPointsFrame{} } 881func (m *ReadResponse_BooleanPointsFrame) String() string { return proto.CompactTextString(m) } 882func (*ReadResponse_BooleanPointsFrame) ProtoMessage() {} 883func (*ReadResponse_BooleanPointsFrame) Descriptor() ([]byte, []int) { 884 return fileDescriptor_715e4bf4cdf1f73d, []int{4, 6} 885} 886func (m *ReadResponse_BooleanPointsFrame) XXX_Unmarshal(b []byte) error { 887 return m.Unmarshal(b) 888} 889func (m *ReadResponse_BooleanPointsFrame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 890 if deterministic { 891 return xxx_messageInfo_ReadResponse_BooleanPointsFrame.Marshal(b, m, deterministic) 892 } else { 893 b = b[:cap(b)] 894 n, err := m.MarshalTo(b) 895 if err != nil { 896 return nil, err 897 } 898 return b[:n], nil 899 } 900} 901func (m *ReadResponse_BooleanPointsFrame) XXX_Merge(src proto.Message) { 902 xxx_messageInfo_ReadResponse_BooleanPointsFrame.Merge(m, src) 903} 904func (m *ReadResponse_BooleanPointsFrame) XXX_Size() int { 905 return m.Size() 906} 907func (m *ReadResponse_BooleanPointsFrame) XXX_DiscardUnknown() { 908 xxx_messageInfo_ReadResponse_BooleanPointsFrame.DiscardUnknown(m) 909} 910 911var xxx_messageInfo_ReadResponse_BooleanPointsFrame proto.InternalMessageInfo 912 913type ReadResponse_StringPointsFrame struct { 914 Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps,proto3" json:"timestamps,omitempty"` 915 Values []string `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"` 916} 917 918func (m *ReadResponse_StringPointsFrame) Reset() { *m = ReadResponse_StringPointsFrame{} } 919func (m *ReadResponse_StringPointsFrame) String() string { return proto.CompactTextString(m) } 920func (*ReadResponse_StringPointsFrame) ProtoMessage() {} 921func (*ReadResponse_StringPointsFrame) Descriptor() ([]byte, []int) { 922 return fileDescriptor_715e4bf4cdf1f73d, []int{4, 7} 923} 924func (m *ReadResponse_StringPointsFrame) XXX_Unmarshal(b []byte) error { 925 return m.Unmarshal(b) 926} 927func (m *ReadResponse_StringPointsFrame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 928 if deterministic { 929 return xxx_messageInfo_ReadResponse_StringPointsFrame.Marshal(b, m, deterministic) 930 } else { 931 b = b[:cap(b)] 932 n, err := m.MarshalTo(b) 933 if err != nil { 934 return nil, err 935 } 936 return b[:n], nil 937 } 938} 939func (m *ReadResponse_StringPointsFrame) XXX_Merge(src proto.Message) { 940 xxx_messageInfo_ReadResponse_StringPointsFrame.Merge(m, src) 941} 942func (m *ReadResponse_StringPointsFrame) XXX_Size() int { 943 return m.Size() 944} 945func (m *ReadResponse_StringPointsFrame) XXX_DiscardUnknown() { 946 xxx_messageInfo_ReadResponse_StringPointsFrame.DiscardUnknown(m) 947} 948 949var xxx_messageInfo_ReadResponse_StringPointsFrame proto.InternalMessageInfo 950 951type CapabilitiesResponse struct { 952 Caps map[string]string `protobuf:"bytes,1,rep,name=caps,proto3" json:"caps,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` 953} 954 955func (m *CapabilitiesResponse) Reset() { *m = CapabilitiesResponse{} } 956func (m *CapabilitiesResponse) String() string { return proto.CompactTextString(m) } 957func (*CapabilitiesResponse) ProtoMessage() {} 958func (*CapabilitiesResponse) Descriptor() ([]byte, []int) { 959 return fileDescriptor_715e4bf4cdf1f73d, []int{5} 960} 961func (m *CapabilitiesResponse) XXX_Unmarshal(b []byte) error { 962 return m.Unmarshal(b) 963} 964func (m *CapabilitiesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 965 if deterministic { 966 return xxx_messageInfo_CapabilitiesResponse.Marshal(b, m, deterministic) 967 } else { 968 b = b[:cap(b)] 969 n, err := m.MarshalTo(b) 970 if err != nil { 971 return nil, err 972 } 973 return b[:n], nil 974 } 975} 976func (m *CapabilitiesResponse) XXX_Merge(src proto.Message) { 977 xxx_messageInfo_CapabilitiesResponse.Merge(m, src) 978} 979func (m *CapabilitiesResponse) XXX_Size() int { 980 return m.Size() 981} 982func (m *CapabilitiesResponse) XXX_DiscardUnknown() { 983 xxx_messageInfo_CapabilitiesResponse.DiscardUnknown(m) 984} 985 986var xxx_messageInfo_CapabilitiesResponse proto.InternalMessageInfo 987 988// Specifies a continuous range of nanosecond timestamps. 989type TimestampRange struct { 990 // Start defines the inclusive lower bound. 991 Start int64 `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"` 992 // End defines the exclusive upper bound. 993 End int64 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"` 994} 995 996func (m *TimestampRange) Reset() { *m = TimestampRange{} } 997func (m *TimestampRange) String() string { return proto.CompactTextString(m) } 998func (*TimestampRange) ProtoMessage() {} 999func (*TimestampRange) Descriptor() ([]byte, []int) { 1000 return fileDescriptor_715e4bf4cdf1f73d, []int{6} 1001} 1002func (m *TimestampRange) XXX_Unmarshal(b []byte) error { 1003 return m.Unmarshal(b) 1004} 1005func (m *TimestampRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1006 if deterministic { 1007 return xxx_messageInfo_TimestampRange.Marshal(b, m, deterministic) 1008 } else { 1009 b = b[:cap(b)] 1010 n, err := m.MarshalTo(b) 1011 if err != nil { 1012 return nil, err 1013 } 1014 return b[:n], nil 1015 } 1016} 1017func (m *TimestampRange) XXX_Merge(src proto.Message) { 1018 xxx_messageInfo_TimestampRange.Merge(m, src) 1019} 1020func (m *TimestampRange) XXX_Size() int { 1021 return m.Size() 1022} 1023func (m *TimestampRange) XXX_DiscardUnknown() { 1024 xxx_messageInfo_TimestampRange.DiscardUnknown(m) 1025} 1026 1027var xxx_messageInfo_TimestampRange proto.InternalMessageInfo 1028 1029// TagKeysRequest is the request message for Storage.TagKeys. 1030type TagKeysRequest struct { 1031 TagsSource *types.Any `protobuf:"bytes,1,opt,name=tags_source,json=tagsSource,proto3" json:"tags_source,omitempty"` 1032 Range TimestampRange `protobuf:"bytes,2,opt,name=range,proto3" json:"range"` 1033 Predicate *Predicate `protobuf:"bytes,3,opt,name=predicate,proto3" json:"predicate,omitempty"` 1034} 1035 1036func (m *TagKeysRequest) Reset() { *m = TagKeysRequest{} } 1037func (m *TagKeysRequest) String() string { return proto.CompactTextString(m) } 1038func (*TagKeysRequest) ProtoMessage() {} 1039func (*TagKeysRequest) Descriptor() ([]byte, []int) { 1040 return fileDescriptor_715e4bf4cdf1f73d, []int{7} 1041} 1042func (m *TagKeysRequest) XXX_Unmarshal(b []byte) error { 1043 return m.Unmarshal(b) 1044} 1045func (m *TagKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1046 if deterministic { 1047 return xxx_messageInfo_TagKeysRequest.Marshal(b, m, deterministic) 1048 } else { 1049 b = b[:cap(b)] 1050 n, err := m.MarshalTo(b) 1051 if err != nil { 1052 return nil, err 1053 } 1054 return b[:n], nil 1055 } 1056} 1057func (m *TagKeysRequest) XXX_Merge(src proto.Message) { 1058 xxx_messageInfo_TagKeysRequest.Merge(m, src) 1059} 1060func (m *TagKeysRequest) XXX_Size() int { 1061 return m.Size() 1062} 1063func (m *TagKeysRequest) XXX_DiscardUnknown() { 1064 xxx_messageInfo_TagKeysRequest.DiscardUnknown(m) 1065} 1066 1067var xxx_messageInfo_TagKeysRequest proto.InternalMessageInfo 1068 1069// TagValuesRequest is the request message for Storage.TagValues. 1070type TagValuesRequest struct { 1071 TagsSource *types.Any `protobuf:"bytes,1,opt,name=tags_source,json=tagsSource,proto3" json:"tags_source,omitempty"` 1072 Range TimestampRange `protobuf:"bytes,2,opt,name=range,proto3" json:"range"` 1073 Predicate *Predicate `protobuf:"bytes,3,opt,name=predicate,proto3" json:"predicate,omitempty"` 1074 TagKey string `protobuf:"bytes,4,opt,name=tag_key,json=tagKey,proto3" json:"tag_key,omitempty"` 1075} 1076 1077func (m *TagValuesRequest) Reset() { *m = TagValuesRequest{} } 1078func (m *TagValuesRequest) String() string { return proto.CompactTextString(m) } 1079func (*TagValuesRequest) ProtoMessage() {} 1080func (*TagValuesRequest) Descriptor() ([]byte, []int) { 1081 return fileDescriptor_715e4bf4cdf1f73d, []int{8} 1082} 1083func (m *TagValuesRequest) XXX_Unmarshal(b []byte) error { 1084 return m.Unmarshal(b) 1085} 1086func (m *TagValuesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1087 if deterministic { 1088 return xxx_messageInfo_TagValuesRequest.Marshal(b, m, deterministic) 1089 } else { 1090 b = b[:cap(b)] 1091 n, err := m.MarshalTo(b) 1092 if err != nil { 1093 return nil, err 1094 } 1095 return b[:n], nil 1096 } 1097} 1098func (m *TagValuesRequest) XXX_Merge(src proto.Message) { 1099 xxx_messageInfo_TagValuesRequest.Merge(m, src) 1100} 1101func (m *TagValuesRequest) XXX_Size() int { 1102 return m.Size() 1103} 1104func (m *TagValuesRequest) XXX_DiscardUnknown() { 1105 xxx_messageInfo_TagValuesRequest.DiscardUnknown(m) 1106} 1107 1108var xxx_messageInfo_TagValuesRequest proto.InternalMessageInfo 1109 1110// Response message for Storage.TagKeys and Storage.TagValues. 1111type StringValuesResponse struct { 1112 Values [][]byte `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"` 1113} 1114 1115func (m *StringValuesResponse) Reset() { *m = StringValuesResponse{} } 1116func (m *StringValuesResponse) String() string { return proto.CompactTextString(m) } 1117func (*StringValuesResponse) ProtoMessage() {} 1118func (*StringValuesResponse) Descriptor() ([]byte, []int) { 1119 return fileDescriptor_715e4bf4cdf1f73d, []int{9} 1120} 1121func (m *StringValuesResponse) XXX_Unmarshal(b []byte) error { 1122 return m.Unmarshal(b) 1123} 1124func (m *StringValuesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1125 if deterministic { 1126 return xxx_messageInfo_StringValuesResponse.Marshal(b, m, deterministic) 1127 } else { 1128 b = b[:cap(b)] 1129 n, err := m.MarshalTo(b) 1130 if err != nil { 1131 return nil, err 1132 } 1133 return b[:n], nil 1134 } 1135} 1136func (m *StringValuesResponse) XXX_Merge(src proto.Message) { 1137 xxx_messageInfo_StringValuesResponse.Merge(m, src) 1138} 1139func (m *StringValuesResponse) XXX_Size() int { 1140 return m.Size() 1141} 1142func (m *StringValuesResponse) XXX_DiscardUnknown() { 1143 xxx_messageInfo_StringValuesResponse.DiscardUnknown(m) 1144} 1145 1146var xxx_messageInfo_StringValuesResponse proto.InternalMessageInfo 1147 1148func init() { 1149 proto.RegisterEnum("influxdata.platform.storage.ReadGroupRequest_Group", ReadGroupRequest_Group_name, ReadGroupRequest_Group_value) 1150 proto.RegisterEnum("influxdata.platform.storage.ReadGroupRequest_HintFlags", ReadGroupRequest_HintFlags_name, ReadGroupRequest_HintFlags_value) 1151 proto.RegisterEnum("influxdata.platform.storage.Aggregate_AggregateType", Aggregate_AggregateType_name, Aggregate_AggregateType_value) 1152 proto.RegisterEnum("influxdata.platform.storage.ReadResponse_FrameType", ReadResponse_FrameType_name, ReadResponse_FrameType_value) 1153 proto.RegisterEnum("influxdata.platform.storage.ReadResponse_DataType", ReadResponse_DataType_name, ReadResponse_DataType_value) 1154 proto.RegisterType((*ReadFilterRequest)(nil), "influxdata.platform.storage.ReadFilterRequest") 1155 proto.RegisterType((*ReadGroupRequest)(nil), "influxdata.platform.storage.ReadGroupRequest") 1156 proto.RegisterType((*Aggregate)(nil), "influxdata.platform.storage.Aggregate") 1157 proto.RegisterType((*Tag)(nil), "influxdata.platform.storage.Tag") 1158 proto.RegisterType((*ReadResponse)(nil), "influxdata.platform.storage.ReadResponse") 1159 proto.RegisterType((*ReadResponse_Frame)(nil), "influxdata.platform.storage.ReadResponse.Frame") 1160 proto.RegisterType((*ReadResponse_GroupFrame)(nil), "influxdata.platform.storage.ReadResponse.GroupFrame") 1161 proto.RegisterType((*ReadResponse_SeriesFrame)(nil), "influxdata.platform.storage.ReadResponse.SeriesFrame") 1162 proto.RegisterType((*ReadResponse_FloatPointsFrame)(nil), "influxdata.platform.storage.ReadResponse.FloatPointsFrame") 1163 proto.RegisterType((*ReadResponse_IntegerPointsFrame)(nil), "influxdata.platform.storage.ReadResponse.IntegerPointsFrame") 1164 proto.RegisterType((*ReadResponse_UnsignedPointsFrame)(nil), "influxdata.platform.storage.ReadResponse.UnsignedPointsFrame") 1165 proto.RegisterType((*ReadResponse_BooleanPointsFrame)(nil), "influxdata.platform.storage.ReadResponse.BooleanPointsFrame") 1166 proto.RegisterType((*ReadResponse_StringPointsFrame)(nil), "influxdata.platform.storage.ReadResponse.StringPointsFrame") 1167 proto.RegisterType((*CapabilitiesResponse)(nil), "influxdata.platform.storage.CapabilitiesResponse") 1168 proto.RegisterMapType((map[string]string)(nil), "influxdata.platform.storage.CapabilitiesResponse.CapsEntry") 1169 proto.RegisterType((*TimestampRange)(nil), "influxdata.platform.storage.TimestampRange") 1170 proto.RegisterType((*TagKeysRequest)(nil), "influxdata.platform.storage.TagKeysRequest") 1171 proto.RegisterType((*TagValuesRequest)(nil), "influxdata.platform.storage.TagValuesRequest") 1172 proto.RegisterType((*StringValuesResponse)(nil), "influxdata.platform.storage.StringValuesResponse") 1173} 1174 1175func init() { proto.RegisterFile("storage_common.proto", fileDescriptor_715e4bf4cdf1f73d) } 1176 1177var fileDescriptor_715e4bf4cdf1f73d = []byte{ 1178 // 1498 bytes of a gzipped FileDescriptorProto 1179 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x57, 0xcb, 0x6f, 0xdb, 0xc8, 1180 0x19, 0x17, 0xf5, 0x34, 0x3f, 0xc9, 0x32, 0x3d, 0x51, 0x5d, 0x87, 0x69, 0x24, 0x56, 0x28, 0x52, 1181 0x17, 0x49, 0xe4, 0xd4, 0x49, 0xd1, 0x20, 0x6d, 0x0f, 0x96, 0x23, 0x5b, 0x6a, 0x6c, 0xc9, 0xa0, 1182 0xe4, 0x00, 0xe9, 0x45, 0x18, 0xdb, 0x63, 0x86, 0x88, 0x44, 0xb2, 0x24, 0x15, 0x58, 0x40, 0x2f, 1183 0xbd, 0x05, 0x3a, 0xb5, 0x97, 0x1e, 0x0a, 0x08, 0x58, 0x60, 0x8f, 0x7b, 0xdf, 0xbf, 0x21, 0x87, 1184 0x05, 0x36, 0xc7, 0x3d, 0x09, 0xbb, 0x0a, 0xb0, 0xc0, 0xfe, 0x0b, 0x7b, 0x5a, 0xcc, 0x0c, 0x47, 1185 0xa2, 0x6c, 0xc3, 0x96, 0xf6, 0xb4, 0xc8, 0x6d, 0xe6, 0x7b, 0xfc, 0xbe, 0x07, 0xbf, 0xc7, 0x10, 1186 0x72, 0x9e, 0x6f, 0xbb, 0xd8, 0x20, 0xed, 0x13, 0xbb, 0xdb, 0xb5, 0xad, 0x92, 0xe3, 0xda, 0xbe, 1187 0x8d, 0xee, 0x98, 0xd6, 0x59, 0xa7, 0x77, 0x7e, 0x8a, 0x7d, 0x5c, 0x72, 0x3a, 0xd8, 0x3f, 0xb3, 1188 0xdd, 0x6e, 0x29, 0x90, 0x54, 0x73, 0x86, 0x6d, 0xd8, 0x4c, 0x6e, 0x93, 0x9e, 0xb8, 0x8a, 0x7a, 1189 0xc7, 0xb0, 0x6d, 0xa3, 0x43, 0x36, 0xd9, 0xed, 0xb8, 0x77, 0xb6, 0x49, 0xba, 0x8e, 0xdf, 0x0f, 1190 0x98, 0xb7, 0x2f, 0x32, 0xb1, 0x25, 0x58, 0x2b, 0x8e, 0x4b, 0x4e, 0xcd, 0x13, 0xec, 0x13, 0x4e, 1191 0x28, 0xfe, 0x20, 0xc1, 0xaa, 0x4e, 0xf0, 0xe9, 0xae, 0xd9, 0xf1, 0x89, 0xab, 0x93, 0x7f, 0xf6, 1192 0x88, 0xe7, 0xa3, 0x0a, 0xa4, 0x5d, 0x82, 0x4f, 0xdb, 0x9e, 0xdd, 0x73, 0x4f, 0xc8, 0xba, 0xa4, 1193 0x49, 0x1b, 0xe9, 0xad, 0x5c, 0x89, 0xe3, 0x96, 0x04, 0x6e, 0x69, 0xdb, 0xea, 0x97, 0xb3, 0xe3, 1194 0x51, 0x01, 0x28, 0x42, 0x93, 0xc9, 0xea, 0xe0, 0x4e, 0xce, 0x68, 0x0f, 0x12, 0x2e, 0xb6, 0x0c, 1195 0xb2, 0x1e, 0x65, 0x00, 0xf7, 0x4b, 0xd7, 0x04, 0x5a, 0x6a, 0x99, 0x5d, 0xe2, 0xf9, 0xb8, 0xeb, 1196 0xe8, 0x54, 0xa5, 0x1c, 0x7f, 0x3f, 0x2a, 0x44, 0x74, 0xae, 0x8f, 0x9e, 0x83, 0x3c, 0x71, 0x7c, 1197 0x3d, 0xc6, 0xc0, 0xee, 0x5d, 0x0b, 0x76, 0x28, 0xa4, 0xf5, 0xa9, 0x62, 0xf1, 0xab, 0x04, 0x28, 1198 0xd4, 0xd3, 0x3d, 0xd7, 0xee, 0x39, 0x9f, 0x74, 0xa8, 0xe8, 0x01, 0x80, 0x41, 0xa3, 0x6c, 0xbf, 1199 0x21, 0x7d, 0x6f, 0x3d, 0xae, 0xc5, 0x36, 0xe4, 0xf2, 0xf2, 0x78, 0x54, 0x90, 0x59, 0xec, 0x2f, 1200 0x48, 0xdf, 0xd3, 0x65, 0x43, 0x1c, 0x51, 0x0d, 0x12, 0xec, 0xb2, 0x9e, 0xd0, 0xa4, 0x8d, 0xec, 1201 0xd6, 0xe3, 0x6b, 0xed, 0x5d, 0xcc, 0x60, 0x89, 0x5f, 0x38, 0x02, 0x75, 0x1f, 0x1b, 0x86, 0x4b, 1202 0x0c, 0xea, 0x7e, 0x72, 0x0e, 0xf7, 0xb7, 0x85, 0xb4, 0x3e, 0x55, 0x44, 0x0f, 0x20, 0xf1, 0xda, 1203 0xb4, 0x7c, 0x6f, 0x3d, 0xa5, 0x49, 0x1b, 0xa9, 0xf2, 0xda, 0x78, 0x54, 0x48, 0x54, 0x29, 0xe1, 1204 0xc7, 0x51, 0x41, 0xa6, 0x87, 0xdd, 0x0e, 0x36, 0x3c, 0x9d, 0x0b, 0x15, 0xf7, 0x20, 0xc1, 0x7c, 1205 0x40, 0x77, 0x01, 0xf6, 0xf4, 0xc6, 0xd1, 0x61, 0xbb, 0xde, 0xa8, 0x57, 0x94, 0x88, 0xba, 0x3c, 1206 0x18, 0x6a, 0x3c, 0xe2, 0xba, 0x6d, 0x11, 0x74, 0x1b, 0x96, 0x38, 0xbb, 0xfc, 0x4a, 0x89, 0xaa, 1207 0xe9, 0xc1, 0x50, 0x4b, 0x31, 0x66, 0xb9, 0xaf, 0xc6, 0xdf, 0x7d, 0x9e, 0x8f, 0x14, 0xbf, 0x90, 1208 0x60, 0x8a, 0x8e, 0xee, 0x80, 0x5c, 0xad, 0xd5, 0x5b, 0x02, 0x2c, 0x33, 0x18, 0x6a, 0x4b, 0x94, 1209 0xcb, 0xb0, 0x7e, 0x07, 0xd9, 0x80, 0xd9, 0x3e, 0x6c, 0xd4, 0xea, 0xad, 0xa6, 0x22, 0xa9, 0xca, 1210 0x60, 0xa8, 0x65, 0xb8, 0xc4, 0xa1, 0x4d, 0x3d, 0x0b, 0x4b, 0x35, 0x2b, 0x7a, 0xad, 0xd2, 0x54, 1211 0xa2, 0x61, 0xa9, 0x26, 0x71, 0x4d, 0xe2, 0xa1, 0x4d, 0xc8, 0x31, 0xa9, 0xe6, 0x4e, 0xb5, 0x72, 1212 0xb0, 0xdd, 0xde, 0xde, 0xdf, 0x6f, 0xb7, 0x6a, 0x07, 0x15, 0x25, 0xae, 0xfe, 0x6a, 0x30, 0xd4, 1213 0x56, 0xa9, 0x6c, 0xf3, 0xe4, 0x35, 0xe9, 0xe2, 0xed, 0x4e, 0x87, 0x96, 0x4e, 0xe0, 0xed, 0xd7, 1214 0x12, 0xc8, 0x93, 0xec, 0xa1, 0x2a, 0xc4, 0xfd, 0xbe, 0xc3, 0x0b, 0x38, 0xbb, 0xf5, 0x64, 0xbe, 1215 0x9c, 0x4f, 0x4f, 0xad, 0xbe, 0x43, 0x74, 0x86, 0x50, 0x3c, 0x87, 0xe5, 0x19, 0x32, 0x2a, 0x40, 1216 0x3c, 0xc8, 0x01, 0xf3, 0x67, 0x86, 0xc9, 0x92, 0x71, 0x17, 0x62, 0xcd, 0xa3, 0x03, 0x45, 0x52, 1217 0x73, 0x83, 0xa1, 0xa6, 0xcc, 0xf0, 0x9b, 0xbd, 0x2e, 0xfa, 0x2d, 0x24, 0x76, 0x1a, 0x47, 0xf5, 1218 0x96, 0x12, 0x55, 0xd7, 0x06, 0x43, 0x0d, 0xcd, 0x08, 0xec, 0xd8, 0x3d, 0xcb, 0x0f, 0x22, 0x7a, 1219 0x08, 0xb1, 0x16, 0x36, 0x90, 0x02, 0xb1, 0x37, 0xa4, 0xcf, 0x22, 0xc9, 0xe8, 0xf4, 0x88, 0x72, 1220 0x90, 0x78, 0x8b, 0x3b, 0x3d, 0xde, 0x5d, 0x19, 0x9d, 0x5f, 0x8a, 0xff, 0xcd, 0x42, 0x86, 0x56, 1221 0xa3, 0x4e, 0x3c, 0xc7, 0xb6, 0x3c, 0x82, 0x0e, 0x20, 0x79, 0xe6, 0xe2, 0x2e, 0xf1, 0xd6, 0x25, 1222 0x2d, 0xb6, 0x91, 0xde, 0xda, 0xbc, 0xb1, 0x90, 0x85, 0x6a, 0x69, 0x97, 0xea, 0x05, 0x9d, 0x18, 1223 0x80, 0xa8, 0xef, 0x92, 0x90, 0x60, 0x74, 0xb4, 0x2f, 0x1a, 0x24, 0xc5, 0x2a, 0xfa, 0xc9, 0xfc, 1224 0xb8, 0xac, 0xc0, 0x18, 0x48, 0x35, 0x22, 0x7a, 0xa4, 0x01, 0x49, 0x8f, 0x7d, 0xf9, 0x60, 0xda, 1225 0xfc, 0x69, 0x7e, 0x38, 0x5e, 0x31, 0x02, 0x2f, 0x80, 0x41, 0x0e, 0x64, 0xce, 0x3a, 0x36, 0xf6, 1226 0xdb, 0x0e, 0x2b, 0xbb, 0x60, 0x06, 0x3d, 0x5b, 0x20, 0x7a, 0xaa, 0xcd, 0x6b, 0x96, 0x27, 0x62, 1227 0x65, 0x3c, 0x2a, 0xa4, 0x43, 0xd4, 0x6a, 0x44, 0x4f, 0x9f, 0x4d, 0xaf, 0xe8, 0x1c, 0xb2, 0xa6, 1228 0xe5, 0x13, 0x83, 0xb8, 0xc2, 0x26, 0x1f, 0x55, 0x7f, 0x9d, 0xdf, 0x66, 0x8d, 0xeb, 0x87, 0xad, 1229 0xae, 0x8e, 0x47, 0x85, 0xe5, 0x19, 0x7a, 0x35, 0xa2, 0x2f, 0x9b, 0x61, 0x02, 0xfa, 0x17, 0xac, 1230 0xf4, 0x2c, 0xcf, 0x34, 0x2c, 0x72, 0x2a, 0x4c, 0xc7, 0x99, 0xe9, 0xbf, 0xcd, 0x6f, 0xfa, 0x28, 1231 0x00, 0x08, 0xdb, 0x46, 0xe3, 0x51, 0x21, 0x3b, 0xcb, 0xa8, 0x46, 0xf4, 0x6c, 0x6f, 0x86, 0x42, 1232 0xe3, 0x3e, 0xb6, 0xed, 0x0e, 0xc1, 0x96, 0x30, 0x9e, 0x58, 0x34, 0xee, 0x32, 0xd7, 0xbf, 0x14, 1233 0xf7, 0x0c, 0x9d, 0xc6, 0x7d, 0x1c, 0x26, 0x20, 0x1f, 0x96, 0x3d, 0xdf, 0x35, 0x2d, 0x43, 0x18, 1234 0xe6, 0xc3, 0xf5, 0x2f, 0x0b, 0xd4, 0x0e, 0x53, 0x0f, 0xdb, 0x55, 0xc6, 0xa3, 0x42, 0x26, 0x4c, 1235 0xae, 0x46, 0xf4, 0x8c, 0x17, 0xba, 0x97, 0x93, 0x10, 0xa7, 0xc8, 0xea, 0x39, 0xc0, 0xb4, 0x92, 1236 0xd1, 0x3d, 0x58, 0xf2, 0xb1, 0xc1, 0x77, 0x0b, 0xed, 0xb4, 0x4c, 0x39, 0x3d, 0x1e, 0x15, 0x52, 1237 0x2d, 0x6c, 0xb0, 0xcd, 0x92, 0xf2, 0xf9, 0x01, 0x95, 0x01, 0x39, 0xd8, 0xf5, 0x4d, 0xdf, 0xb4, 1238 0x2d, 0x2a, 0xdd, 0x7e, 0x8b, 0x3b, 0xb4, 0x3a, 0xa9, 0x46, 0x6e, 0x3c, 0x2a, 0x28, 0x87, 0x82, 1239 0xfb, 0x82, 0xf4, 0x5f, 0xe2, 0x8e, 0xa7, 0x2b, 0xce, 0x05, 0x8a, 0xfa, 0x7f, 0x09, 0xd2, 0xa1, 1240 0xaa, 0x47, 0xcf, 0x20, 0xee, 0x63, 0x43, 0x74, 0xb8, 0x76, 0xfd, 0x9e, 0xc5, 0x46, 0xd0, 0xd2, 1241 0x4c, 0x07, 0x35, 0x40, 0xa6, 0x82, 0x6d, 0x36, 0x28, 0xa3, 0x6c, 0x50, 0x6e, 0xcd, 0x9f, 0xbf, 1242 0xe7, 0xd8, 0xc7, 0x6c, 0x4c, 0x2e, 0x9d, 0x06, 0x27, 0xf5, 0xef, 0xa0, 0x5c, 0x6c, 0x1d, 0x94, 1243 0x07, 0xf0, 0xc5, 0x7e, 0xe7, 0x6e, 0x2a, 0x7a, 0x88, 0x82, 0xd6, 0x20, 0xc9, 0xc6, 0x17, 0x4f, 1244 0x84, 0xa4, 0x07, 0x37, 0x75, 0x1f, 0xd0, 0xe5, 0x96, 0x58, 0x10, 0x2d, 0x36, 0x41, 0x3b, 0x80, 1245 0x5b, 0x57, 0x54, 0xf9, 0x82, 0x70, 0xf1, 0xb0, 0x73, 0x97, 0xeb, 0x76, 0x41, 0xb4, 0xa5, 0x09, 1246 0xda, 0x0b, 0x58, 0xbd, 0x54, 0x8c, 0x0b, 0x82, 0xc9, 0x02, 0xac, 0xd8, 0x04, 0x99, 0x01, 0x04, 1247 0xab, 0x2a, 0x19, 0x2c, 0xda, 0x88, 0x7a, 0x6b, 0x30, 0xd4, 0x56, 0x26, 0xac, 0x60, 0xd7, 0x16, 1248 0x20, 0x39, 0xd9, 0xd7, 0xb3, 0x02, 0xdc, 0x97, 0x60, 0x13, 0x7d, 0x29, 0xc1, 0x92, 0xf8, 0xde, 1249 0xe8, 0x37, 0x90, 0xd8, 0xdd, 0x6f, 0x6c, 0xb7, 0x94, 0x88, 0xba, 0x3a, 0x18, 0x6a, 0xcb, 0x82, 1250 0xc1, 0x3e, 0x3d, 0xd2, 0x20, 0x55, 0xab, 0xb7, 0x2a, 0x7b, 0x15, 0x5d, 0x40, 0x0a, 0x7e, 0xf0, 1251 0x39, 0x51, 0x11, 0x96, 0x8e, 0xea, 0xcd, 0xda, 0x5e, 0xbd, 0xf2, 0x5c, 0x89, 0xf2, 0x1d, 0x29, 1252 0x44, 0xc4, 0x37, 0xa2, 0x28, 0xe5, 0x46, 0x63, 0xbf, 0xb2, 0x5d, 0x57, 0x62, 0xb3, 0x28, 0x41, 1253 0xde, 0x51, 0x1e, 0x92, 0xcd, 0x96, 0x5e, 0xab, 0xef, 0x29, 0x71, 0x15, 0x0d, 0x86, 0x5a, 0x56, 1254 0x08, 0xf0, 0x54, 0x06, 0x8e, 0x7f, 0x26, 0x41, 0x6e, 0x07, 0x3b, 0xf8, 0xd8, 0xec, 0x98, 0xbe, 1255 0x49, 0xbc, 0xc9, 0x6e, 0x6c, 0x40, 0xfc, 0x04, 0x3b, 0xa2, 0x6f, 0xae, 0x1f, 0x1b, 0x57, 0x01, 1256 0x50, 0xa2, 0x57, 0xb1, 0x7c, 0xb7, 0xaf, 0x33, 0x20, 0xf5, 0xcf, 0x20, 0x4f, 0x48, 0xe1, 0x95, 1257 0x2d, 0x5f, 0xb1, 0xb2, 0xe5, 0x60, 0x65, 0x3f, 0x8b, 0x3e, 0x95, 0x8a, 0x4f, 0x21, 0x3b, 0xfb, 1258 0x00, 0xa6, 0xb2, 0x9e, 0x8f, 0x5d, 0x9f, 0xe9, 0xc7, 0x74, 0x7e, 0xa1, 0x98, 0xc4, 0x3a, 0x65, 1259 0xfa, 0x31, 0x9d, 0x1e, 0x8b, 0xdf, 0x4b, 0x90, 0x15, 0x43, 0x66, 0xfa, 0x7c, 0xa7, 0xad, 0x3d, 1260 0xf7, 0xf3, 0xbd, 0x85, 0x0d, 0x4f, 0x3c, 0xdf, 0xfd, 0xc9, 0xf9, 0x97, 0xf6, 0xa7, 0xf2, 0xef, 1261 0x28, 0x28, 0x2d, 0x6c, 0xbc, 0x64, 0x15, 0xfe, 0x49, 0x87, 0x8a, 0x7e, 0x0d, 0xa9, 0x60, 0x97, 1262 0xb0, 0x3d, 0x2e, 0xeb, 0x49, 0xbe, 0x3d, 0x8a, 0x25, 0xc8, 0xf1, 0xca, 0x16, 0x59, 0x08, 0x0a, 1263 0x79, 0x3a, 0x07, 0xd8, 0xea, 0x11, 0x73, 0x60, 0xeb, 0x7f, 0x71, 0x48, 0x35, 0xb9, 0x25, 0x64, 1264 0x02, 0x4c, 0x7f, 0x6a, 0x51, 0xe9, 0xc6, 0x19, 0x3f, 0xf3, 0xf7, 0xab, 0xfe, 0x61, 0xee, 0x9d, 1265 0xf0, 0x48, 0x42, 0x06, 0xc8, 0x93, 0x3f, 0x22, 0xf4, 0x70, 0xa1, 0x3f, 0xa7, 0xc5, 0x0c, 0xbd, 1266 0x01, 0xb1, 0x60, 0xd1, 0xfd, 0x9b, 0xb6, 0x5e, 0xa8, 0x43, 0xd4, 0x3f, 0x5e, 0x2b, 0x7c, 0x55, 1267 0x8a, 0x1f, 0x49, 0xc8, 0x06, 0x79, 0x52, 0x7f, 0x37, 0x44, 0x75, 0xb1, 0x4e, 0x7f, 0x9e, 0xc1, 1268 0x57, 0x90, 0x09, 0x4f, 0x1d, 0xb4, 0x76, 0xa9, 0xae, 0x2b, 0x5d, 0xc7, 0xef, 0xdf, 0x00, 0x7e, 1269 0xd5, 0xe0, 0x2a, 0xff, 0xfe, 0xfd, 0x77, 0xf9, 0xc8, 0xfb, 0x71, 0x5e, 0xfa, 0x30, 0xce, 0x4b, 1270 0xdf, 0x8e, 0xf3, 0xd2, 0x7f, 0x3e, 0xe6, 0x23, 0x1f, 0x3e, 0xe6, 0x23, 0xdf, 0x7c, 0xcc, 0x47, 1271 0xfe, 0xc1, 0x5e, 0x04, 0xf4, 0x41, 0xe0, 0x1d, 0x27, 0x99, 0xad, 0xc7, 0x3f, 0x05, 0x00, 0x00, 1272 0xff, 0xff, 0x7f, 0x0e, 0xbb, 0xbb, 0xa6, 0x11, 0x00, 0x00, 1273} 1274 1275// Reference imports to suppress errors if they are not otherwise used. 1276var _ context.Context 1277var _ grpc.ClientConn 1278 1279// This is a compile-time assertion to ensure that this generated file 1280// is compatible with the grpc package it is being compiled against. 1281const _ = grpc.SupportPackageIsVersion4 1282 1283// StorageClient is the client API for Storage service. 1284// 1285// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. 1286type StorageClient interface { 1287 // ReadFilter performs a filter operation at storage 1288 ReadFilter(ctx context.Context, in *ReadFilterRequest, opts ...grpc.CallOption) (Storage_ReadFilterClient, error) 1289 // ReadGroup performs a group operation at storage 1290 ReadGroup(ctx context.Context, in *ReadGroupRequest, opts ...grpc.CallOption) (Storage_ReadGroupClient, error) 1291 // TagKeys performs a read operation for tag keys 1292 TagKeys(ctx context.Context, in *TagKeysRequest, opts ...grpc.CallOption) (Storage_TagKeysClient, error) 1293 // TagValues performs a read operation for tag values 1294 TagValues(ctx context.Context, in *TagValuesRequest, opts ...grpc.CallOption) (Storage_TagValuesClient, error) 1295 // Capabilities returns a map of keys and values identifying the capabilities supported by the storage engine 1296 Capabilities(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*CapabilitiesResponse, error) 1297} 1298 1299type storageClient struct { 1300 cc *grpc.ClientConn 1301} 1302 1303func NewStorageClient(cc *grpc.ClientConn) StorageClient { 1304 return &storageClient{cc} 1305} 1306 1307func (c *storageClient) ReadFilter(ctx context.Context, in *ReadFilterRequest, opts ...grpc.CallOption) (Storage_ReadFilterClient, error) { 1308 stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[0], "/influxdata.platform.storage.Storage/ReadFilter", opts...) 1309 if err != nil { 1310 return nil, err 1311 } 1312 x := &storageReadFilterClient{stream} 1313 if err := x.ClientStream.SendMsg(in); err != nil { 1314 return nil, err 1315 } 1316 if err := x.ClientStream.CloseSend(); err != nil { 1317 return nil, err 1318 } 1319 return x, nil 1320} 1321 1322type Storage_ReadFilterClient interface { 1323 Recv() (*ReadResponse, error) 1324 grpc.ClientStream 1325} 1326 1327type storageReadFilterClient struct { 1328 grpc.ClientStream 1329} 1330 1331func (x *storageReadFilterClient) Recv() (*ReadResponse, error) { 1332 m := new(ReadResponse) 1333 if err := x.ClientStream.RecvMsg(m); err != nil { 1334 return nil, err 1335 } 1336 return m, nil 1337} 1338 1339func (c *storageClient) ReadGroup(ctx context.Context, in *ReadGroupRequest, opts ...grpc.CallOption) (Storage_ReadGroupClient, error) { 1340 stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[1], "/influxdata.platform.storage.Storage/ReadGroup", opts...) 1341 if err != nil { 1342 return nil, err 1343 } 1344 x := &storageReadGroupClient{stream} 1345 if err := x.ClientStream.SendMsg(in); err != nil { 1346 return nil, err 1347 } 1348 if err := x.ClientStream.CloseSend(); err != nil { 1349 return nil, err 1350 } 1351 return x, nil 1352} 1353 1354type Storage_ReadGroupClient interface { 1355 Recv() (*ReadResponse, error) 1356 grpc.ClientStream 1357} 1358 1359type storageReadGroupClient struct { 1360 grpc.ClientStream 1361} 1362 1363func (x *storageReadGroupClient) Recv() (*ReadResponse, error) { 1364 m := new(ReadResponse) 1365 if err := x.ClientStream.RecvMsg(m); err != nil { 1366 return nil, err 1367 } 1368 return m, nil 1369} 1370 1371func (c *storageClient) TagKeys(ctx context.Context, in *TagKeysRequest, opts ...grpc.CallOption) (Storage_TagKeysClient, error) { 1372 stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[2], "/influxdata.platform.storage.Storage/TagKeys", opts...) 1373 if err != nil { 1374 return nil, err 1375 } 1376 x := &storageTagKeysClient{stream} 1377 if err := x.ClientStream.SendMsg(in); err != nil { 1378 return nil, err 1379 } 1380 if err := x.ClientStream.CloseSend(); err != nil { 1381 return nil, err 1382 } 1383 return x, nil 1384} 1385 1386type Storage_TagKeysClient interface { 1387 Recv() (*StringValuesResponse, error) 1388 grpc.ClientStream 1389} 1390 1391type storageTagKeysClient struct { 1392 grpc.ClientStream 1393} 1394 1395func (x *storageTagKeysClient) Recv() (*StringValuesResponse, error) { 1396 m := new(StringValuesResponse) 1397 if err := x.ClientStream.RecvMsg(m); err != nil { 1398 return nil, err 1399 } 1400 return m, nil 1401} 1402 1403func (c *storageClient) TagValues(ctx context.Context, in *TagValuesRequest, opts ...grpc.CallOption) (Storage_TagValuesClient, error) { 1404 stream, err := c.cc.NewStream(ctx, &_Storage_serviceDesc.Streams[3], "/influxdata.platform.storage.Storage/TagValues", opts...) 1405 if err != nil { 1406 return nil, err 1407 } 1408 x := &storageTagValuesClient{stream} 1409 if err := x.ClientStream.SendMsg(in); err != nil { 1410 return nil, err 1411 } 1412 if err := x.ClientStream.CloseSend(); err != nil { 1413 return nil, err 1414 } 1415 return x, nil 1416} 1417 1418type Storage_TagValuesClient interface { 1419 Recv() (*StringValuesResponse, error) 1420 grpc.ClientStream 1421} 1422 1423type storageTagValuesClient struct { 1424 grpc.ClientStream 1425} 1426 1427func (x *storageTagValuesClient) Recv() (*StringValuesResponse, error) { 1428 m := new(StringValuesResponse) 1429 if err := x.ClientStream.RecvMsg(m); err != nil { 1430 return nil, err 1431 } 1432 return m, nil 1433} 1434 1435func (c *storageClient) Capabilities(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*CapabilitiesResponse, error) { 1436 out := new(CapabilitiesResponse) 1437 err := c.cc.Invoke(ctx, "/influxdata.platform.storage.Storage/Capabilities", in, out, opts...) 1438 if err != nil { 1439 return nil, err 1440 } 1441 return out, nil 1442} 1443 1444// StorageServer is the server API for Storage service. 1445type StorageServer interface { 1446 // ReadFilter performs a filter operation at storage 1447 ReadFilter(*ReadFilterRequest, Storage_ReadFilterServer) error 1448 // ReadGroup performs a group operation at storage 1449 ReadGroup(*ReadGroupRequest, Storage_ReadGroupServer) error 1450 // TagKeys performs a read operation for tag keys 1451 TagKeys(*TagKeysRequest, Storage_TagKeysServer) error 1452 // TagValues performs a read operation for tag values 1453 TagValues(*TagValuesRequest, Storage_TagValuesServer) error 1454 // Capabilities returns a map of keys and values identifying the capabilities supported by the storage engine 1455 Capabilities(context.Context, *types.Empty) (*CapabilitiesResponse, error) 1456} 1457 1458func RegisterStorageServer(s *grpc.Server, srv StorageServer) { 1459 s.RegisterService(&_Storage_serviceDesc, srv) 1460} 1461 1462func _Storage_ReadFilter_Handler(srv interface{}, stream grpc.ServerStream) error { 1463 m := new(ReadFilterRequest) 1464 if err := stream.RecvMsg(m); err != nil { 1465 return err 1466 } 1467 return srv.(StorageServer).ReadFilter(m, &storageReadFilterServer{stream}) 1468} 1469 1470type Storage_ReadFilterServer interface { 1471 Send(*ReadResponse) error 1472 grpc.ServerStream 1473} 1474 1475type storageReadFilterServer struct { 1476 grpc.ServerStream 1477} 1478 1479func (x *storageReadFilterServer) Send(m *ReadResponse) error { 1480 return x.ServerStream.SendMsg(m) 1481} 1482 1483func _Storage_ReadGroup_Handler(srv interface{}, stream grpc.ServerStream) error { 1484 m := new(ReadGroupRequest) 1485 if err := stream.RecvMsg(m); err != nil { 1486 return err 1487 } 1488 return srv.(StorageServer).ReadGroup(m, &storageReadGroupServer{stream}) 1489} 1490 1491type Storage_ReadGroupServer interface { 1492 Send(*ReadResponse) error 1493 grpc.ServerStream 1494} 1495 1496type storageReadGroupServer struct { 1497 grpc.ServerStream 1498} 1499 1500func (x *storageReadGroupServer) Send(m *ReadResponse) error { 1501 return x.ServerStream.SendMsg(m) 1502} 1503 1504func _Storage_TagKeys_Handler(srv interface{}, stream grpc.ServerStream) error { 1505 m := new(TagKeysRequest) 1506 if err := stream.RecvMsg(m); err != nil { 1507 return err 1508 } 1509 return srv.(StorageServer).TagKeys(m, &storageTagKeysServer{stream}) 1510} 1511 1512type Storage_TagKeysServer interface { 1513 Send(*StringValuesResponse) error 1514 grpc.ServerStream 1515} 1516 1517type storageTagKeysServer struct { 1518 grpc.ServerStream 1519} 1520 1521func (x *storageTagKeysServer) Send(m *StringValuesResponse) error { 1522 return x.ServerStream.SendMsg(m) 1523} 1524 1525func _Storage_TagValues_Handler(srv interface{}, stream grpc.ServerStream) error { 1526 m := new(TagValuesRequest) 1527 if err := stream.RecvMsg(m); err != nil { 1528 return err 1529 } 1530 return srv.(StorageServer).TagValues(m, &storageTagValuesServer{stream}) 1531} 1532 1533type Storage_TagValuesServer interface { 1534 Send(*StringValuesResponse) error 1535 grpc.ServerStream 1536} 1537 1538type storageTagValuesServer struct { 1539 grpc.ServerStream 1540} 1541 1542func (x *storageTagValuesServer) Send(m *StringValuesResponse) error { 1543 return x.ServerStream.SendMsg(m) 1544} 1545 1546func _Storage_Capabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 1547 in := new(types.Empty) 1548 if err := dec(in); err != nil { 1549 return nil, err 1550 } 1551 if interceptor == nil { 1552 return srv.(StorageServer).Capabilities(ctx, in) 1553 } 1554 info := &grpc.UnaryServerInfo{ 1555 Server: srv, 1556 FullMethod: "/influxdata.platform.storage.Storage/Capabilities", 1557 } 1558 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 1559 return srv.(StorageServer).Capabilities(ctx, req.(*types.Empty)) 1560 } 1561 return interceptor(ctx, in, info, handler) 1562} 1563 1564var _Storage_serviceDesc = grpc.ServiceDesc{ 1565 ServiceName: "influxdata.platform.storage.Storage", 1566 HandlerType: (*StorageServer)(nil), 1567 Methods: []grpc.MethodDesc{ 1568 { 1569 MethodName: "Capabilities", 1570 Handler: _Storage_Capabilities_Handler, 1571 }, 1572 }, 1573 Streams: []grpc.StreamDesc{ 1574 { 1575 StreamName: "ReadFilter", 1576 Handler: _Storage_ReadFilter_Handler, 1577 ServerStreams: true, 1578 }, 1579 { 1580 StreamName: "ReadGroup", 1581 Handler: _Storage_ReadGroup_Handler, 1582 ServerStreams: true, 1583 }, 1584 { 1585 StreamName: "TagKeys", 1586 Handler: _Storage_TagKeys_Handler, 1587 ServerStreams: true, 1588 }, 1589 { 1590 StreamName: "TagValues", 1591 Handler: _Storage_TagValues_Handler, 1592 ServerStreams: true, 1593 }, 1594 }, 1595 Metadata: "storage_common.proto", 1596} 1597 1598func (m *ReadFilterRequest) Marshal() (dAtA []byte, err error) { 1599 size := m.Size() 1600 dAtA = make([]byte, size) 1601 n, err := m.MarshalTo(dAtA) 1602 if err != nil { 1603 return nil, err 1604 } 1605 return dAtA[:n], nil 1606} 1607 1608func (m *ReadFilterRequest) MarshalTo(dAtA []byte) (int, error) { 1609 var i int 1610 _ = i 1611 var l int 1612 _ = l 1613 if m.ReadSource != nil { 1614 dAtA[i] = 0xa 1615 i++ 1616 i = encodeVarintStorageCommon(dAtA, i, uint64(m.ReadSource.Size())) 1617 n1, err := m.ReadSource.MarshalTo(dAtA[i:]) 1618 if err != nil { 1619 return 0, err 1620 } 1621 i += n1 1622 } 1623 dAtA[i] = 0x12 1624 i++ 1625 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Range.Size())) 1626 n2, err := m.Range.MarshalTo(dAtA[i:]) 1627 if err != nil { 1628 return 0, err 1629 } 1630 i += n2 1631 if m.Predicate != nil { 1632 dAtA[i] = 0x1a 1633 i++ 1634 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Predicate.Size())) 1635 n3, err := m.Predicate.MarshalTo(dAtA[i:]) 1636 if err != nil { 1637 return 0, err 1638 } 1639 i += n3 1640 } 1641 return i, nil 1642} 1643 1644func (m *ReadGroupRequest) Marshal() (dAtA []byte, err error) { 1645 size := m.Size() 1646 dAtA = make([]byte, size) 1647 n, err := m.MarshalTo(dAtA) 1648 if err != nil { 1649 return nil, err 1650 } 1651 return dAtA[:n], nil 1652} 1653 1654func (m *ReadGroupRequest) MarshalTo(dAtA []byte) (int, error) { 1655 var i int 1656 _ = i 1657 var l int 1658 _ = l 1659 if m.ReadSource != nil { 1660 dAtA[i] = 0xa 1661 i++ 1662 i = encodeVarintStorageCommon(dAtA, i, uint64(m.ReadSource.Size())) 1663 n4, err := m.ReadSource.MarshalTo(dAtA[i:]) 1664 if err != nil { 1665 return 0, err 1666 } 1667 i += n4 1668 } 1669 dAtA[i] = 0x12 1670 i++ 1671 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Range.Size())) 1672 n5, err := m.Range.MarshalTo(dAtA[i:]) 1673 if err != nil { 1674 return 0, err 1675 } 1676 i += n5 1677 if m.Predicate != nil { 1678 dAtA[i] = 0x1a 1679 i++ 1680 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Predicate.Size())) 1681 n6, err := m.Predicate.MarshalTo(dAtA[i:]) 1682 if err != nil { 1683 return 0, err 1684 } 1685 i += n6 1686 } 1687 if len(m.GroupKeys) > 0 { 1688 for _, s := range m.GroupKeys { 1689 dAtA[i] = 0x22 1690 i++ 1691 l = len(s) 1692 for l >= 1<<7 { 1693 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 1694 l >>= 7 1695 i++ 1696 } 1697 dAtA[i] = uint8(l) 1698 i++ 1699 i += copy(dAtA[i:], s) 1700 } 1701 } 1702 if m.Group != 0 { 1703 dAtA[i] = 0x28 1704 i++ 1705 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Group)) 1706 } 1707 if m.Aggregate != nil { 1708 dAtA[i] = 0x32 1709 i++ 1710 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Aggregate.Size())) 1711 n7, err := m.Aggregate.MarshalTo(dAtA[i:]) 1712 if err != nil { 1713 return 0, err 1714 } 1715 i += n7 1716 } 1717 if m.Hints != 0 { 1718 dAtA[i] = 0x3d 1719 i++ 1720 encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Hints)) 1721 i += 4 1722 } 1723 return i, nil 1724} 1725 1726func (m *Aggregate) Marshal() (dAtA []byte, err error) { 1727 size := m.Size() 1728 dAtA = make([]byte, size) 1729 n, err := m.MarshalTo(dAtA) 1730 if err != nil { 1731 return nil, err 1732 } 1733 return dAtA[:n], nil 1734} 1735 1736func (m *Aggregate) MarshalTo(dAtA []byte) (int, error) { 1737 var i int 1738 _ = i 1739 var l int 1740 _ = l 1741 if m.Type != 0 { 1742 dAtA[i] = 0x8 1743 i++ 1744 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Type)) 1745 } 1746 return i, nil 1747} 1748 1749func (m *Tag) Marshal() (dAtA []byte, err error) { 1750 size := m.Size() 1751 dAtA = make([]byte, size) 1752 n, err := m.MarshalTo(dAtA) 1753 if err != nil { 1754 return nil, err 1755 } 1756 return dAtA[:n], nil 1757} 1758 1759func (m *Tag) MarshalTo(dAtA []byte) (int, error) { 1760 var i int 1761 _ = i 1762 var l int 1763 _ = l 1764 if len(m.Key) > 0 { 1765 dAtA[i] = 0xa 1766 i++ 1767 i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Key))) 1768 i += copy(dAtA[i:], m.Key) 1769 } 1770 if len(m.Value) > 0 { 1771 dAtA[i] = 0x12 1772 i++ 1773 i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Value))) 1774 i += copy(dAtA[i:], m.Value) 1775 } 1776 return i, nil 1777} 1778 1779func (m *ReadResponse) Marshal() (dAtA []byte, err error) { 1780 size := m.Size() 1781 dAtA = make([]byte, size) 1782 n, err := m.MarshalTo(dAtA) 1783 if err != nil { 1784 return nil, err 1785 } 1786 return dAtA[:n], nil 1787} 1788 1789func (m *ReadResponse) MarshalTo(dAtA []byte) (int, error) { 1790 var i int 1791 _ = i 1792 var l int 1793 _ = l 1794 if len(m.Frames) > 0 { 1795 for _, msg := range m.Frames { 1796 dAtA[i] = 0xa 1797 i++ 1798 i = encodeVarintStorageCommon(dAtA, i, uint64(msg.Size())) 1799 n, err := msg.MarshalTo(dAtA[i:]) 1800 if err != nil { 1801 return 0, err 1802 } 1803 i += n 1804 } 1805 } 1806 return i, nil 1807} 1808 1809func (m *ReadResponse_Frame) Marshal() (dAtA []byte, err error) { 1810 size := m.Size() 1811 dAtA = make([]byte, size) 1812 n, err := m.MarshalTo(dAtA) 1813 if err != nil { 1814 return nil, err 1815 } 1816 return dAtA[:n], nil 1817} 1818 1819func (m *ReadResponse_Frame) MarshalTo(dAtA []byte) (int, error) { 1820 var i int 1821 _ = i 1822 var l int 1823 _ = l 1824 if m.Data != nil { 1825 nn8, err := m.Data.MarshalTo(dAtA[i:]) 1826 if err != nil { 1827 return 0, err 1828 } 1829 i += nn8 1830 } 1831 return i, nil 1832} 1833 1834func (m *ReadResponse_Frame_Series) MarshalTo(dAtA []byte) (int, error) { 1835 i := 0 1836 if m.Series != nil { 1837 dAtA[i] = 0xa 1838 i++ 1839 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Series.Size())) 1840 n9, err := m.Series.MarshalTo(dAtA[i:]) 1841 if err != nil { 1842 return 0, err 1843 } 1844 i += n9 1845 } 1846 return i, nil 1847} 1848func (m *ReadResponse_Frame_FloatPoints) MarshalTo(dAtA []byte) (int, error) { 1849 i := 0 1850 if m.FloatPoints != nil { 1851 dAtA[i] = 0x12 1852 i++ 1853 i = encodeVarintStorageCommon(dAtA, i, uint64(m.FloatPoints.Size())) 1854 n10, err := m.FloatPoints.MarshalTo(dAtA[i:]) 1855 if err != nil { 1856 return 0, err 1857 } 1858 i += n10 1859 } 1860 return i, nil 1861} 1862func (m *ReadResponse_Frame_IntegerPoints) MarshalTo(dAtA []byte) (int, error) { 1863 i := 0 1864 if m.IntegerPoints != nil { 1865 dAtA[i] = 0x1a 1866 i++ 1867 i = encodeVarintStorageCommon(dAtA, i, uint64(m.IntegerPoints.Size())) 1868 n11, err := m.IntegerPoints.MarshalTo(dAtA[i:]) 1869 if err != nil { 1870 return 0, err 1871 } 1872 i += n11 1873 } 1874 return i, nil 1875} 1876func (m *ReadResponse_Frame_UnsignedPoints) MarshalTo(dAtA []byte) (int, error) { 1877 i := 0 1878 if m.UnsignedPoints != nil { 1879 dAtA[i] = 0x22 1880 i++ 1881 i = encodeVarintStorageCommon(dAtA, i, uint64(m.UnsignedPoints.Size())) 1882 n12, err := m.UnsignedPoints.MarshalTo(dAtA[i:]) 1883 if err != nil { 1884 return 0, err 1885 } 1886 i += n12 1887 } 1888 return i, nil 1889} 1890func (m *ReadResponse_Frame_BooleanPoints) MarshalTo(dAtA []byte) (int, error) { 1891 i := 0 1892 if m.BooleanPoints != nil { 1893 dAtA[i] = 0x2a 1894 i++ 1895 i = encodeVarintStorageCommon(dAtA, i, uint64(m.BooleanPoints.Size())) 1896 n13, err := m.BooleanPoints.MarshalTo(dAtA[i:]) 1897 if err != nil { 1898 return 0, err 1899 } 1900 i += n13 1901 } 1902 return i, nil 1903} 1904func (m *ReadResponse_Frame_StringPoints) MarshalTo(dAtA []byte) (int, error) { 1905 i := 0 1906 if m.StringPoints != nil { 1907 dAtA[i] = 0x32 1908 i++ 1909 i = encodeVarintStorageCommon(dAtA, i, uint64(m.StringPoints.Size())) 1910 n14, err := m.StringPoints.MarshalTo(dAtA[i:]) 1911 if err != nil { 1912 return 0, err 1913 } 1914 i += n14 1915 } 1916 return i, nil 1917} 1918func (m *ReadResponse_Frame_Group) MarshalTo(dAtA []byte) (int, error) { 1919 i := 0 1920 if m.Group != nil { 1921 dAtA[i] = 0x3a 1922 i++ 1923 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Group.Size())) 1924 n15, err := m.Group.MarshalTo(dAtA[i:]) 1925 if err != nil { 1926 return 0, err 1927 } 1928 i += n15 1929 } 1930 return i, nil 1931} 1932func (m *ReadResponse_GroupFrame) Marshal() (dAtA []byte, err error) { 1933 size := m.Size() 1934 dAtA = make([]byte, size) 1935 n, err := m.MarshalTo(dAtA) 1936 if err != nil { 1937 return nil, err 1938 } 1939 return dAtA[:n], nil 1940} 1941 1942func (m *ReadResponse_GroupFrame) MarshalTo(dAtA []byte) (int, error) { 1943 var i int 1944 _ = i 1945 var l int 1946 _ = l 1947 if len(m.TagKeys) > 0 { 1948 for _, b := range m.TagKeys { 1949 dAtA[i] = 0xa 1950 i++ 1951 i = encodeVarintStorageCommon(dAtA, i, uint64(len(b))) 1952 i += copy(dAtA[i:], b) 1953 } 1954 } 1955 if len(m.PartitionKeyVals) > 0 { 1956 for _, b := range m.PartitionKeyVals { 1957 dAtA[i] = 0x12 1958 i++ 1959 i = encodeVarintStorageCommon(dAtA, i, uint64(len(b))) 1960 i += copy(dAtA[i:], b) 1961 } 1962 } 1963 return i, nil 1964} 1965 1966func (m *ReadResponse_SeriesFrame) Marshal() (dAtA []byte, err error) { 1967 size := m.Size() 1968 dAtA = make([]byte, size) 1969 n, err := m.MarshalTo(dAtA) 1970 if err != nil { 1971 return nil, err 1972 } 1973 return dAtA[:n], nil 1974} 1975 1976func (m *ReadResponse_SeriesFrame) MarshalTo(dAtA []byte) (int, error) { 1977 var i int 1978 _ = i 1979 var l int 1980 _ = l 1981 if len(m.Tags) > 0 { 1982 for _, msg := range m.Tags { 1983 dAtA[i] = 0xa 1984 i++ 1985 i = encodeVarintStorageCommon(dAtA, i, uint64(msg.Size())) 1986 n, err := msg.MarshalTo(dAtA[i:]) 1987 if err != nil { 1988 return 0, err 1989 } 1990 i += n 1991 } 1992 } 1993 if m.DataType != 0 { 1994 dAtA[i] = 0x10 1995 i++ 1996 i = encodeVarintStorageCommon(dAtA, i, uint64(m.DataType)) 1997 } 1998 return i, nil 1999} 2000 2001func (m *ReadResponse_FloatPointsFrame) Marshal() (dAtA []byte, err error) { 2002 size := m.Size() 2003 dAtA = make([]byte, size) 2004 n, err := m.MarshalTo(dAtA) 2005 if err != nil { 2006 return nil, err 2007 } 2008 return dAtA[:n], nil 2009} 2010 2011func (m *ReadResponse_FloatPointsFrame) MarshalTo(dAtA []byte) (int, error) { 2012 var i int 2013 _ = i 2014 var l int 2015 _ = l 2016 if len(m.Timestamps) > 0 { 2017 dAtA[i] = 0xa 2018 i++ 2019 i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Timestamps)*8)) 2020 for _, num := range m.Timestamps { 2021 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(num)) 2022 i += 8 2023 } 2024 } 2025 if len(m.Values) > 0 { 2026 dAtA[i] = 0x12 2027 i++ 2028 i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Values)*8)) 2029 for _, num := range m.Values { 2030 f16 := math.Float64bits(float64(num)) 2031 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f16)) 2032 i += 8 2033 } 2034 } 2035 return i, nil 2036} 2037 2038func (m *ReadResponse_IntegerPointsFrame) Marshal() (dAtA []byte, err error) { 2039 size := m.Size() 2040 dAtA = make([]byte, size) 2041 n, err := m.MarshalTo(dAtA) 2042 if err != nil { 2043 return nil, err 2044 } 2045 return dAtA[:n], nil 2046} 2047 2048func (m *ReadResponse_IntegerPointsFrame) MarshalTo(dAtA []byte) (int, error) { 2049 var i int 2050 _ = i 2051 var l int 2052 _ = l 2053 if len(m.Timestamps) > 0 { 2054 dAtA[i] = 0xa 2055 i++ 2056 i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Timestamps)*8)) 2057 for _, num := range m.Timestamps { 2058 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(num)) 2059 i += 8 2060 } 2061 } 2062 if len(m.Values) > 0 { 2063 dAtA18 := make([]byte, len(m.Values)*10) 2064 var j17 int 2065 for _, num1 := range m.Values { 2066 num := uint64(num1) 2067 for num >= 1<<7 { 2068 dAtA18[j17] = uint8(uint64(num)&0x7f | 0x80) 2069 num >>= 7 2070 j17++ 2071 } 2072 dAtA18[j17] = uint8(num) 2073 j17++ 2074 } 2075 dAtA[i] = 0x12 2076 i++ 2077 i = encodeVarintStorageCommon(dAtA, i, uint64(j17)) 2078 i += copy(dAtA[i:], dAtA18[:j17]) 2079 } 2080 return i, nil 2081} 2082 2083func (m *ReadResponse_UnsignedPointsFrame) Marshal() (dAtA []byte, err error) { 2084 size := m.Size() 2085 dAtA = make([]byte, size) 2086 n, err := m.MarshalTo(dAtA) 2087 if err != nil { 2088 return nil, err 2089 } 2090 return dAtA[:n], nil 2091} 2092 2093func (m *ReadResponse_UnsignedPointsFrame) MarshalTo(dAtA []byte) (int, error) { 2094 var i int 2095 _ = i 2096 var l int 2097 _ = l 2098 if len(m.Timestamps) > 0 { 2099 dAtA[i] = 0xa 2100 i++ 2101 i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Timestamps)*8)) 2102 for _, num := range m.Timestamps { 2103 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(num)) 2104 i += 8 2105 } 2106 } 2107 if len(m.Values) > 0 { 2108 dAtA20 := make([]byte, len(m.Values)*10) 2109 var j19 int 2110 for _, num := range m.Values { 2111 for num >= 1<<7 { 2112 dAtA20[j19] = uint8(uint64(num)&0x7f | 0x80) 2113 num >>= 7 2114 j19++ 2115 } 2116 dAtA20[j19] = uint8(num) 2117 j19++ 2118 } 2119 dAtA[i] = 0x12 2120 i++ 2121 i = encodeVarintStorageCommon(dAtA, i, uint64(j19)) 2122 i += copy(dAtA[i:], dAtA20[:j19]) 2123 } 2124 return i, nil 2125} 2126 2127func (m *ReadResponse_BooleanPointsFrame) Marshal() (dAtA []byte, err error) { 2128 size := m.Size() 2129 dAtA = make([]byte, size) 2130 n, err := m.MarshalTo(dAtA) 2131 if err != nil { 2132 return nil, err 2133 } 2134 return dAtA[:n], nil 2135} 2136 2137func (m *ReadResponse_BooleanPointsFrame) MarshalTo(dAtA []byte) (int, error) { 2138 var i int 2139 _ = i 2140 var l int 2141 _ = l 2142 if len(m.Timestamps) > 0 { 2143 dAtA[i] = 0xa 2144 i++ 2145 i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Timestamps)*8)) 2146 for _, num := range m.Timestamps { 2147 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(num)) 2148 i += 8 2149 } 2150 } 2151 if len(m.Values) > 0 { 2152 dAtA[i] = 0x12 2153 i++ 2154 i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Values))) 2155 for _, b := range m.Values { 2156 if b { 2157 dAtA[i] = 1 2158 } else { 2159 dAtA[i] = 0 2160 } 2161 i++ 2162 } 2163 } 2164 return i, nil 2165} 2166 2167func (m *ReadResponse_StringPointsFrame) Marshal() (dAtA []byte, err error) { 2168 size := m.Size() 2169 dAtA = make([]byte, size) 2170 n, err := m.MarshalTo(dAtA) 2171 if err != nil { 2172 return nil, err 2173 } 2174 return dAtA[:n], nil 2175} 2176 2177func (m *ReadResponse_StringPointsFrame) MarshalTo(dAtA []byte) (int, error) { 2178 var i int 2179 _ = i 2180 var l int 2181 _ = l 2182 if len(m.Timestamps) > 0 { 2183 dAtA[i] = 0xa 2184 i++ 2185 i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.Timestamps)*8)) 2186 for _, num := range m.Timestamps { 2187 encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(num)) 2188 i += 8 2189 } 2190 } 2191 if len(m.Values) > 0 { 2192 for _, s := range m.Values { 2193 dAtA[i] = 0x12 2194 i++ 2195 l = len(s) 2196 for l >= 1<<7 { 2197 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 2198 l >>= 7 2199 i++ 2200 } 2201 dAtA[i] = uint8(l) 2202 i++ 2203 i += copy(dAtA[i:], s) 2204 } 2205 } 2206 return i, nil 2207} 2208 2209func (m *CapabilitiesResponse) Marshal() (dAtA []byte, err error) { 2210 size := m.Size() 2211 dAtA = make([]byte, size) 2212 n, err := m.MarshalTo(dAtA) 2213 if err != nil { 2214 return nil, err 2215 } 2216 return dAtA[:n], nil 2217} 2218 2219func (m *CapabilitiesResponse) MarshalTo(dAtA []byte) (int, error) { 2220 var i int 2221 _ = i 2222 var l int 2223 _ = l 2224 if len(m.Caps) > 0 { 2225 for k, _ := range m.Caps { 2226 dAtA[i] = 0xa 2227 i++ 2228 v := m.Caps[k] 2229 mapSize := 1 + len(k) + sovStorageCommon(uint64(len(k))) + 1 + len(v) + sovStorageCommon(uint64(len(v))) 2230 i = encodeVarintStorageCommon(dAtA, i, uint64(mapSize)) 2231 dAtA[i] = 0xa 2232 i++ 2233 i = encodeVarintStorageCommon(dAtA, i, uint64(len(k))) 2234 i += copy(dAtA[i:], k) 2235 dAtA[i] = 0x12 2236 i++ 2237 i = encodeVarintStorageCommon(dAtA, i, uint64(len(v))) 2238 i += copy(dAtA[i:], v) 2239 } 2240 } 2241 return i, nil 2242} 2243 2244func (m *TimestampRange) Marshal() (dAtA []byte, err error) { 2245 size := m.Size() 2246 dAtA = make([]byte, size) 2247 n, err := m.MarshalTo(dAtA) 2248 if err != nil { 2249 return nil, err 2250 } 2251 return dAtA[:n], nil 2252} 2253 2254func (m *TimestampRange) MarshalTo(dAtA []byte) (int, error) { 2255 var i int 2256 _ = i 2257 var l int 2258 _ = l 2259 if m.Start != 0 { 2260 dAtA[i] = 0x8 2261 i++ 2262 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Start)) 2263 } 2264 if m.End != 0 { 2265 dAtA[i] = 0x10 2266 i++ 2267 i = encodeVarintStorageCommon(dAtA, i, uint64(m.End)) 2268 } 2269 return i, nil 2270} 2271 2272func (m *TagKeysRequest) Marshal() (dAtA []byte, err error) { 2273 size := m.Size() 2274 dAtA = make([]byte, size) 2275 n, err := m.MarshalTo(dAtA) 2276 if err != nil { 2277 return nil, err 2278 } 2279 return dAtA[:n], nil 2280} 2281 2282func (m *TagKeysRequest) MarshalTo(dAtA []byte) (int, error) { 2283 var i int 2284 _ = i 2285 var l int 2286 _ = l 2287 if m.TagsSource != nil { 2288 dAtA[i] = 0xa 2289 i++ 2290 i = encodeVarintStorageCommon(dAtA, i, uint64(m.TagsSource.Size())) 2291 n21, err := m.TagsSource.MarshalTo(dAtA[i:]) 2292 if err != nil { 2293 return 0, err 2294 } 2295 i += n21 2296 } 2297 dAtA[i] = 0x12 2298 i++ 2299 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Range.Size())) 2300 n22, err := m.Range.MarshalTo(dAtA[i:]) 2301 if err != nil { 2302 return 0, err 2303 } 2304 i += n22 2305 if m.Predicate != nil { 2306 dAtA[i] = 0x1a 2307 i++ 2308 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Predicate.Size())) 2309 n23, err := m.Predicate.MarshalTo(dAtA[i:]) 2310 if err != nil { 2311 return 0, err 2312 } 2313 i += n23 2314 } 2315 return i, nil 2316} 2317 2318func (m *TagValuesRequest) Marshal() (dAtA []byte, err error) { 2319 size := m.Size() 2320 dAtA = make([]byte, size) 2321 n, err := m.MarshalTo(dAtA) 2322 if err != nil { 2323 return nil, err 2324 } 2325 return dAtA[:n], nil 2326} 2327 2328func (m *TagValuesRequest) MarshalTo(dAtA []byte) (int, error) { 2329 var i int 2330 _ = i 2331 var l int 2332 _ = l 2333 if m.TagsSource != nil { 2334 dAtA[i] = 0xa 2335 i++ 2336 i = encodeVarintStorageCommon(dAtA, i, uint64(m.TagsSource.Size())) 2337 n24, err := m.TagsSource.MarshalTo(dAtA[i:]) 2338 if err != nil { 2339 return 0, err 2340 } 2341 i += n24 2342 } 2343 dAtA[i] = 0x12 2344 i++ 2345 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Range.Size())) 2346 n25, err := m.Range.MarshalTo(dAtA[i:]) 2347 if err != nil { 2348 return 0, err 2349 } 2350 i += n25 2351 if m.Predicate != nil { 2352 dAtA[i] = 0x1a 2353 i++ 2354 i = encodeVarintStorageCommon(dAtA, i, uint64(m.Predicate.Size())) 2355 n26, err := m.Predicate.MarshalTo(dAtA[i:]) 2356 if err != nil { 2357 return 0, err 2358 } 2359 i += n26 2360 } 2361 if len(m.TagKey) > 0 { 2362 dAtA[i] = 0x22 2363 i++ 2364 i = encodeVarintStorageCommon(dAtA, i, uint64(len(m.TagKey))) 2365 i += copy(dAtA[i:], m.TagKey) 2366 } 2367 return i, nil 2368} 2369 2370func (m *StringValuesResponse) Marshal() (dAtA []byte, err error) { 2371 size := m.Size() 2372 dAtA = make([]byte, size) 2373 n, err := m.MarshalTo(dAtA) 2374 if err != nil { 2375 return nil, err 2376 } 2377 return dAtA[:n], nil 2378} 2379 2380func (m *StringValuesResponse) MarshalTo(dAtA []byte) (int, error) { 2381 var i int 2382 _ = i 2383 var l int 2384 _ = l 2385 if len(m.Values) > 0 { 2386 for _, b := range m.Values { 2387 dAtA[i] = 0xa 2388 i++ 2389 i = encodeVarintStorageCommon(dAtA, i, uint64(len(b))) 2390 i += copy(dAtA[i:], b) 2391 } 2392 } 2393 return i, nil 2394} 2395 2396func encodeVarintStorageCommon(dAtA []byte, offset int, v uint64) int { 2397 for v >= 1<<7 { 2398 dAtA[offset] = uint8(v&0x7f | 0x80) 2399 v >>= 7 2400 offset++ 2401 } 2402 dAtA[offset] = uint8(v) 2403 return offset + 1 2404} 2405func (m *ReadFilterRequest) Size() (n int) { 2406 if m == nil { 2407 return 0 2408 } 2409 var l int 2410 _ = l 2411 if m.ReadSource != nil { 2412 l = m.ReadSource.Size() 2413 n += 1 + l + sovStorageCommon(uint64(l)) 2414 } 2415 l = m.Range.Size() 2416 n += 1 + l + sovStorageCommon(uint64(l)) 2417 if m.Predicate != nil { 2418 l = m.Predicate.Size() 2419 n += 1 + l + sovStorageCommon(uint64(l)) 2420 } 2421 return n 2422} 2423 2424func (m *ReadGroupRequest) Size() (n int) { 2425 if m == nil { 2426 return 0 2427 } 2428 var l int 2429 _ = l 2430 if m.ReadSource != nil { 2431 l = m.ReadSource.Size() 2432 n += 1 + l + sovStorageCommon(uint64(l)) 2433 } 2434 l = m.Range.Size() 2435 n += 1 + l + sovStorageCommon(uint64(l)) 2436 if m.Predicate != nil { 2437 l = m.Predicate.Size() 2438 n += 1 + l + sovStorageCommon(uint64(l)) 2439 } 2440 if len(m.GroupKeys) > 0 { 2441 for _, s := range m.GroupKeys { 2442 l = len(s) 2443 n += 1 + l + sovStorageCommon(uint64(l)) 2444 } 2445 } 2446 if m.Group != 0 { 2447 n += 1 + sovStorageCommon(uint64(m.Group)) 2448 } 2449 if m.Aggregate != nil { 2450 l = m.Aggregate.Size() 2451 n += 1 + l + sovStorageCommon(uint64(l)) 2452 } 2453 if m.Hints != 0 { 2454 n += 5 2455 } 2456 return n 2457} 2458 2459func (m *Aggregate) Size() (n int) { 2460 if m == nil { 2461 return 0 2462 } 2463 var l int 2464 _ = l 2465 if m.Type != 0 { 2466 n += 1 + sovStorageCommon(uint64(m.Type)) 2467 } 2468 return n 2469} 2470 2471func (m *Tag) Size() (n int) { 2472 if m == nil { 2473 return 0 2474 } 2475 var l int 2476 _ = l 2477 l = len(m.Key) 2478 if l > 0 { 2479 n += 1 + l + sovStorageCommon(uint64(l)) 2480 } 2481 l = len(m.Value) 2482 if l > 0 { 2483 n += 1 + l + sovStorageCommon(uint64(l)) 2484 } 2485 return n 2486} 2487 2488func (m *ReadResponse) Size() (n int) { 2489 if m == nil { 2490 return 0 2491 } 2492 var l int 2493 _ = l 2494 if len(m.Frames) > 0 { 2495 for _, e := range m.Frames { 2496 l = e.Size() 2497 n += 1 + l + sovStorageCommon(uint64(l)) 2498 } 2499 } 2500 return n 2501} 2502 2503func (m *ReadResponse_Frame) Size() (n int) { 2504 if m == nil { 2505 return 0 2506 } 2507 var l int 2508 _ = l 2509 if m.Data != nil { 2510 n += m.Data.Size() 2511 } 2512 return n 2513} 2514 2515func (m *ReadResponse_Frame_Series) Size() (n int) { 2516 if m == nil { 2517 return 0 2518 } 2519 var l int 2520 _ = l 2521 if m.Series != nil { 2522 l = m.Series.Size() 2523 n += 1 + l + sovStorageCommon(uint64(l)) 2524 } 2525 return n 2526} 2527func (m *ReadResponse_Frame_FloatPoints) Size() (n int) { 2528 if m == nil { 2529 return 0 2530 } 2531 var l int 2532 _ = l 2533 if m.FloatPoints != nil { 2534 l = m.FloatPoints.Size() 2535 n += 1 + l + sovStorageCommon(uint64(l)) 2536 } 2537 return n 2538} 2539func (m *ReadResponse_Frame_IntegerPoints) Size() (n int) { 2540 if m == nil { 2541 return 0 2542 } 2543 var l int 2544 _ = l 2545 if m.IntegerPoints != nil { 2546 l = m.IntegerPoints.Size() 2547 n += 1 + l + sovStorageCommon(uint64(l)) 2548 } 2549 return n 2550} 2551func (m *ReadResponse_Frame_UnsignedPoints) Size() (n int) { 2552 if m == nil { 2553 return 0 2554 } 2555 var l int 2556 _ = l 2557 if m.UnsignedPoints != nil { 2558 l = m.UnsignedPoints.Size() 2559 n += 1 + l + sovStorageCommon(uint64(l)) 2560 } 2561 return n 2562} 2563func (m *ReadResponse_Frame_BooleanPoints) Size() (n int) { 2564 if m == nil { 2565 return 0 2566 } 2567 var l int 2568 _ = l 2569 if m.BooleanPoints != nil { 2570 l = m.BooleanPoints.Size() 2571 n += 1 + l + sovStorageCommon(uint64(l)) 2572 } 2573 return n 2574} 2575func (m *ReadResponse_Frame_StringPoints) Size() (n int) { 2576 if m == nil { 2577 return 0 2578 } 2579 var l int 2580 _ = l 2581 if m.StringPoints != nil { 2582 l = m.StringPoints.Size() 2583 n += 1 + l + sovStorageCommon(uint64(l)) 2584 } 2585 return n 2586} 2587func (m *ReadResponse_Frame_Group) Size() (n int) { 2588 if m == nil { 2589 return 0 2590 } 2591 var l int 2592 _ = l 2593 if m.Group != nil { 2594 l = m.Group.Size() 2595 n += 1 + l + sovStorageCommon(uint64(l)) 2596 } 2597 return n 2598} 2599func (m *ReadResponse_GroupFrame) Size() (n int) { 2600 if m == nil { 2601 return 0 2602 } 2603 var l int 2604 _ = l 2605 if len(m.TagKeys) > 0 { 2606 for _, b := range m.TagKeys { 2607 l = len(b) 2608 n += 1 + l + sovStorageCommon(uint64(l)) 2609 } 2610 } 2611 if len(m.PartitionKeyVals) > 0 { 2612 for _, b := range m.PartitionKeyVals { 2613 l = len(b) 2614 n += 1 + l + sovStorageCommon(uint64(l)) 2615 } 2616 } 2617 return n 2618} 2619 2620func (m *ReadResponse_SeriesFrame) Size() (n int) { 2621 if m == nil { 2622 return 0 2623 } 2624 var l int 2625 _ = l 2626 if len(m.Tags) > 0 { 2627 for _, e := range m.Tags { 2628 l = e.Size() 2629 n += 1 + l + sovStorageCommon(uint64(l)) 2630 } 2631 } 2632 if m.DataType != 0 { 2633 n += 1 + sovStorageCommon(uint64(m.DataType)) 2634 } 2635 return n 2636} 2637 2638func (m *ReadResponse_FloatPointsFrame) Size() (n int) { 2639 if m == nil { 2640 return 0 2641 } 2642 var l int 2643 _ = l 2644 if len(m.Timestamps) > 0 { 2645 n += 1 + sovStorageCommon(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8 2646 } 2647 if len(m.Values) > 0 { 2648 n += 1 + sovStorageCommon(uint64(len(m.Values)*8)) + len(m.Values)*8 2649 } 2650 return n 2651} 2652 2653func (m *ReadResponse_IntegerPointsFrame) Size() (n int) { 2654 if m == nil { 2655 return 0 2656 } 2657 var l int 2658 _ = l 2659 if len(m.Timestamps) > 0 { 2660 n += 1 + sovStorageCommon(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8 2661 } 2662 if len(m.Values) > 0 { 2663 l = 0 2664 for _, e := range m.Values { 2665 l += sovStorageCommon(uint64(e)) 2666 } 2667 n += 1 + sovStorageCommon(uint64(l)) + l 2668 } 2669 return n 2670} 2671 2672func (m *ReadResponse_UnsignedPointsFrame) Size() (n int) { 2673 if m == nil { 2674 return 0 2675 } 2676 var l int 2677 _ = l 2678 if len(m.Timestamps) > 0 { 2679 n += 1 + sovStorageCommon(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8 2680 } 2681 if len(m.Values) > 0 { 2682 l = 0 2683 for _, e := range m.Values { 2684 l += sovStorageCommon(uint64(e)) 2685 } 2686 n += 1 + sovStorageCommon(uint64(l)) + l 2687 } 2688 return n 2689} 2690 2691func (m *ReadResponse_BooleanPointsFrame) Size() (n int) { 2692 if m == nil { 2693 return 0 2694 } 2695 var l int 2696 _ = l 2697 if len(m.Timestamps) > 0 { 2698 n += 1 + sovStorageCommon(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8 2699 } 2700 if len(m.Values) > 0 { 2701 n += 1 + sovStorageCommon(uint64(len(m.Values))) + len(m.Values)*1 2702 } 2703 return n 2704} 2705 2706func (m *ReadResponse_StringPointsFrame) Size() (n int) { 2707 if m == nil { 2708 return 0 2709 } 2710 var l int 2711 _ = l 2712 if len(m.Timestamps) > 0 { 2713 n += 1 + sovStorageCommon(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8 2714 } 2715 if len(m.Values) > 0 { 2716 for _, s := range m.Values { 2717 l = len(s) 2718 n += 1 + l + sovStorageCommon(uint64(l)) 2719 } 2720 } 2721 return n 2722} 2723 2724func (m *CapabilitiesResponse) Size() (n int) { 2725 if m == nil { 2726 return 0 2727 } 2728 var l int 2729 _ = l 2730 if len(m.Caps) > 0 { 2731 for k, v := range m.Caps { 2732 _ = k 2733 _ = v 2734 mapEntrySize := 1 + len(k) + sovStorageCommon(uint64(len(k))) + 1 + len(v) + sovStorageCommon(uint64(len(v))) 2735 n += mapEntrySize + 1 + sovStorageCommon(uint64(mapEntrySize)) 2736 } 2737 } 2738 return n 2739} 2740 2741func (m *TimestampRange) Size() (n int) { 2742 if m == nil { 2743 return 0 2744 } 2745 var l int 2746 _ = l 2747 if m.Start != 0 { 2748 n += 1 + sovStorageCommon(uint64(m.Start)) 2749 } 2750 if m.End != 0 { 2751 n += 1 + sovStorageCommon(uint64(m.End)) 2752 } 2753 return n 2754} 2755 2756func (m *TagKeysRequest) Size() (n int) { 2757 if m == nil { 2758 return 0 2759 } 2760 var l int 2761 _ = l 2762 if m.TagsSource != nil { 2763 l = m.TagsSource.Size() 2764 n += 1 + l + sovStorageCommon(uint64(l)) 2765 } 2766 l = m.Range.Size() 2767 n += 1 + l + sovStorageCommon(uint64(l)) 2768 if m.Predicate != nil { 2769 l = m.Predicate.Size() 2770 n += 1 + l + sovStorageCommon(uint64(l)) 2771 } 2772 return n 2773} 2774 2775func (m *TagValuesRequest) Size() (n int) { 2776 if m == nil { 2777 return 0 2778 } 2779 var l int 2780 _ = l 2781 if m.TagsSource != nil { 2782 l = m.TagsSource.Size() 2783 n += 1 + l + sovStorageCommon(uint64(l)) 2784 } 2785 l = m.Range.Size() 2786 n += 1 + l + sovStorageCommon(uint64(l)) 2787 if m.Predicate != nil { 2788 l = m.Predicate.Size() 2789 n += 1 + l + sovStorageCommon(uint64(l)) 2790 } 2791 l = len(m.TagKey) 2792 if l > 0 { 2793 n += 1 + l + sovStorageCommon(uint64(l)) 2794 } 2795 return n 2796} 2797 2798func (m *StringValuesResponse) Size() (n int) { 2799 if m == nil { 2800 return 0 2801 } 2802 var l int 2803 _ = l 2804 if len(m.Values) > 0 { 2805 for _, b := range m.Values { 2806 l = len(b) 2807 n += 1 + l + sovStorageCommon(uint64(l)) 2808 } 2809 } 2810 return n 2811} 2812 2813func sovStorageCommon(x uint64) (n int) { 2814 for { 2815 n++ 2816 x >>= 7 2817 if x == 0 { 2818 break 2819 } 2820 } 2821 return n 2822} 2823func sozStorageCommon(x uint64) (n int) { 2824 return sovStorageCommon(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 2825} 2826func (m *ReadFilterRequest) Unmarshal(dAtA []byte) error { 2827 l := len(dAtA) 2828 iNdEx := 0 2829 for iNdEx < l { 2830 preIndex := iNdEx 2831 var wire uint64 2832 for shift := uint(0); ; shift += 7 { 2833 if shift >= 64 { 2834 return ErrIntOverflowStorageCommon 2835 } 2836 if iNdEx >= l { 2837 return io.ErrUnexpectedEOF 2838 } 2839 b := dAtA[iNdEx] 2840 iNdEx++ 2841 wire |= uint64(b&0x7F) << shift 2842 if b < 0x80 { 2843 break 2844 } 2845 } 2846 fieldNum := int32(wire >> 3) 2847 wireType := int(wire & 0x7) 2848 if wireType == 4 { 2849 return fmt.Errorf("proto: ReadFilterRequest: wiretype end group for non-group") 2850 } 2851 if fieldNum <= 0 { 2852 return fmt.Errorf("proto: ReadFilterRequest: illegal tag %d (wire type %d)", fieldNum, wire) 2853 } 2854 switch fieldNum { 2855 case 1: 2856 if wireType != 2 { 2857 return fmt.Errorf("proto: wrong wireType = %d for field ReadSource", wireType) 2858 } 2859 var msglen int 2860 for shift := uint(0); ; shift += 7 { 2861 if shift >= 64 { 2862 return ErrIntOverflowStorageCommon 2863 } 2864 if iNdEx >= l { 2865 return io.ErrUnexpectedEOF 2866 } 2867 b := dAtA[iNdEx] 2868 iNdEx++ 2869 msglen |= int(b&0x7F) << shift 2870 if b < 0x80 { 2871 break 2872 } 2873 } 2874 if msglen < 0 { 2875 return ErrInvalidLengthStorageCommon 2876 } 2877 postIndex := iNdEx + msglen 2878 if postIndex < 0 { 2879 return ErrInvalidLengthStorageCommon 2880 } 2881 if postIndex > l { 2882 return io.ErrUnexpectedEOF 2883 } 2884 if m.ReadSource == nil { 2885 m.ReadSource = &types.Any{} 2886 } 2887 if err := m.ReadSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 2888 return err 2889 } 2890 iNdEx = postIndex 2891 case 2: 2892 if wireType != 2 { 2893 return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType) 2894 } 2895 var msglen int 2896 for shift := uint(0); ; shift += 7 { 2897 if shift >= 64 { 2898 return ErrIntOverflowStorageCommon 2899 } 2900 if iNdEx >= l { 2901 return io.ErrUnexpectedEOF 2902 } 2903 b := dAtA[iNdEx] 2904 iNdEx++ 2905 msglen |= int(b&0x7F) << shift 2906 if b < 0x80 { 2907 break 2908 } 2909 } 2910 if msglen < 0 { 2911 return ErrInvalidLengthStorageCommon 2912 } 2913 postIndex := iNdEx + msglen 2914 if postIndex < 0 { 2915 return ErrInvalidLengthStorageCommon 2916 } 2917 if postIndex > l { 2918 return io.ErrUnexpectedEOF 2919 } 2920 if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 2921 return err 2922 } 2923 iNdEx = postIndex 2924 case 3: 2925 if wireType != 2 { 2926 return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType) 2927 } 2928 var msglen int 2929 for shift := uint(0); ; shift += 7 { 2930 if shift >= 64 { 2931 return ErrIntOverflowStorageCommon 2932 } 2933 if iNdEx >= l { 2934 return io.ErrUnexpectedEOF 2935 } 2936 b := dAtA[iNdEx] 2937 iNdEx++ 2938 msglen |= int(b&0x7F) << shift 2939 if b < 0x80 { 2940 break 2941 } 2942 } 2943 if msglen < 0 { 2944 return ErrInvalidLengthStorageCommon 2945 } 2946 postIndex := iNdEx + msglen 2947 if postIndex < 0 { 2948 return ErrInvalidLengthStorageCommon 2949 } 2950 if postIndex > l { 2951 return io.ErrUnexpectedEOF 2952 } 2953 if m.Predicate == nil { 2954 m.Predicate = &Predicate{} 2955 } 2956 if err := m.Predicate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 2957 return err 2958 } 2959 iNdEx = postIndex 2960 default: 2961 iNdEx = preIndex 2962 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 2963 if err != nil { 2964 return err 2965 } 2966 if skippy < 0 { 2967 return ErrInvalidLengthStorageCommon 2968 } 2969 if (iNdEx + skippy) < 0 { 2970 return ErrInvalidLengthStorageCommon 2971 } 2972 if (iNdEx + skippy) > l { 2973 return io.ErrUnexpectedEOF 2974 } 2975 iNdEx += skippy 2976 } 2977 } 2978 2979 if iNdEx > l { 2980 return io.ErrUnexpectedEOF 2981 } 2982 return nil 2983} 2984func (m *ReadGroupRequest) Unmarshal(dAtA []byte) error { 2985 l := len(dAtA) 2986 iNdEx := 0 2987 for iNdEx < l { 2988 preIndex := iNdEx 2989 var wire uint64 2990 for shift := uint(0); ; shift += 7 { 2991 if shift >= 64 { 2992 return ErrIntOverflowStorageCommon 2993 } 2994 if iNdEx >= l { 2995 return io.ErrUnexpectedEOF 2996 } 2997 b := dAtA[iNdEx] 2998 iNdEx++ 2999 wire |= uint64(b&0x7F) << shift 3000 if b < 0x80 { 3001 break 3002 } 3003 } 3004 fieldNum := int32(wire >> 3) 3005 wireType := int(wire & 0x7) 3006 if wireType == 4 { 3007 return fmt.Errorf("proto: ReadGroupRequest: wiretype end group for non-group") 3008 } 3009 if fieldNum <= 0 { 3010 return fmt.Errorf("proto: ReadGroupRequest: illegal tag %d (wire type %d)", fieldNum, wire) 3011 } 3012 switch fieldNum { 3013 case 1: 3014 if wireType != 2 { 3015 return fmt.Errorf("proto: wrong wireType = %d for field ReadSource", wireType) 3016 } 3017 var msglen int 3018 for shift := uint(0); ; shift += 7 { 3019 if shift >= 64 { 3020 return ErrIntOverflowStorageCommon 3021 } 3022 if iNdEx >= l { 3023 return io.ErrUnexpectedEOF 3024 } 3025 b := dAtA[iNdEx] 3026 iNdEx++ 3027 msglen |= int(b&0x7F) << shift 3028 if b < 0x80 { 3029 break 3030 } 3031 } 3032 if msglen < 0 { 3033 return ErrInvalidLengthStorageCommon 3034 } 3035 postIndex := iNdEx + msglen 3036 if postIndex < 0 { 3037 return ErrInvalidLengthStorageCommon 3038 } 3039 if postIndex > l { 3040 return io.ErrUnexpectedEOF 3041 } 3042 if m.ReadSource == nil { 3043 m.ReadSource = &types.Any{} 3044 } 3045 if err := m.ReadSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3046 return err 3047 } 3048 iNdEx = postIndex 3049 case 2: 3050 if wireType != 2 { 3051 return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType) 3052 } 3053 var msglen int 3054 for shift := uint(0); ; shift += 7 { 3055 if shift >= 64 { 3056 return ErrIntOverflowStorageCommon 3057 } 3058 if iNdEx >= l { 3059 return io.ErrUnexpectedEOF 3060 } 3061 b := dAtA[iNdEx] 3062 iNdEx++ 3063 msglen |= int(b&0x7F) << shift 3064 if b < 0x80 { 3065 break 3066 } 3067 } 3068 if msglen < 0 { 3069 return ErrInvalidLengthStorageCommon 3070 } 3071 postIndex := iNdEx + msglen 3072 if postIndex < 0 { 3073 return ErrInvalidLengthStorageCommon 3074 } 3075 if postIndex > l { 3076 return io.ErrUnexpectedEOF 3077 } 3078 if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3079 return err 3080 } 3081 iNdEx = postIndex 3082 case 3: 3083 if wireType != 2 { 3084 return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType) 3085 } 3086 var msglen int 3087 for shift := uint(0); ; shift += 7 { 3088 if shift >= 64 { 3089 return ErrIntOverflowStorageCommon 3090 } 3091 if iNdEx >= l { 3092 return io.ErrUnexpectedEOF 3093 } 3094 b := dAtA[iNdEx] 3095 iNdEx++ 3096 msglen |= int(b&0x7F) << shift 3097 if b < 0x80 { 3098 break 3099 } 3100 } 3101 if msglen < 0 { 3102 return ErrInvalidLengthStorageCommon 3103 } 3104 postIndex := iNdEx + msglen 3105 if postIndex < 0 { 3106 return ErrInvalidLengthStorageCommon 3107 } 3108 if postIndex > l { 3109 return io.ErrUnexpectedEOF 3110 } 3111 if m.Predicate == nil { 3112 m.Predicate = &Predicate{} 3113 } 3114 if err := m.Predicate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3115 return err 3116 } 3117 iNdEx = postIndex 3118 case 4: 3119 if wireType != 2 { 3120 return fmt.Errorf("proto: wrong wireType = %d for field GroupKeys", wireType) 3121 } 3122 var stringLen uint64 3123 for shift := uint(0); ; shift += 7 { 3124 if shift >= 64 { 3125 return ErrIntOverflowStorageCommon 3126 } 3127 if iNdEx >= l { 3128 return io.ErrUnexpectedEOF 3129 } 3130 b := dAtA[iNdEx] 3131 iNdEx++ 3132 stringLen |= uint64(b&0x7F) << shift 3133 if b < 0x80 { 3134 break 3135 } 3136 } 3137 intStringLen := int(stringLen) 3138 if intStringLen < 0 { 3139 return ErrInvalidLengthStorageCommon 3140 } 3141 postIndex := iNdEx + intStringLen 3142 if postIndex < 0 { 3143 return ErrInvalidLengthStorageCommon 3144 } 3145 if postIndex > l { 3146 return io.ErrUnexpectedEOF 3147 } 3148 m.GroupKeys = append(m.GroupKeys, string(dAtA[iNdEx:postIndex])) 3149 iNdEx = postIndex 3150 case 5: 3151 if wireType != 0 { 3152 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) 3153 } 3154 m.Group = 0 3155 for shift := uint(0); ; shift += 7 { 3156 if shift >= 64 { 3157 return ErrIntOverflowStorageCommon 3158 } 3159 if iNdEx >= l { 3160 return io.ErrUnexpectedEOF 3161 } 3162 b := dAtA[iNdEx] 3163 iNdEx++ 3164 m.Group |= ReadGroupRequest_Group(b&0x7F) << shift 3165 if b < 0x80 { 3166 break 3167 } 3168 } 3169 case 6: 3170 if wireType != 2 { 3171 return fmt.Errorf("proto: wrong wireType = %d for field Aggregate", wireType) 3172 } 3173 var msglen int 3174 for shift := uint(0); ; shift += 7 { 3175 if shift >= 64 { 3176 return ErrIntOverflowStorageCommon 3177 } 3178 if iNdEx >= l { 3179 return io.ErrUnexpectedEOF 3180 } 3181 b := dAtA[iNdEx] 3182 iNdEx++ 3183 msglen |= int(b&0x7F) << shift 3184 if b < 0x80 { 3185 break 3186 } 3187 } 3188 if msglen < 0 { 3189 return ErrInvalidLengthStorageCommon 3190 } 3191 postIndex := iNdEx + msglen 3192 if postIndex < 0 { 3193 return ErrInvalidLengthStorageCommon 3194 } 3195 if postIndex > l { 3196 return io.ErrUnexpectedEOF 3197 } 3198 if m.Aggregate == nil { 3199 m.Aggregate = &Aggregate{} 3200 } 3201 if err := m.Aggregate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3202 return err 3203 } 3204 iNdEx = postIndex 3205 case 7: 3206 if wireType != 5 { 3207 return fmt.Errorf("proto: wrong wireType = %d for field Hints", wireType) 3208 } 3209 m.Hints = 0 3210 if (iNdEx + 4) > l { 3211 return io.ErrUnexpectedEOF 3212 } 3213 m.Hints = HintFlags(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])) 3214 iNdEx += 4 3215 default: 3216 iNdEx = preIndex 3217 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 3218 if err != nil { 3219 return err 3220 } 3221 if skippy < 0 { 3222 return ErrInvalidLengthStorageCommon 3223 } 3224 if (iNdEx + skippy) < 0 { 3225 return ErrInvalidLengthStorageCommon 3226 } 3227 if (iNdEx + skippy) > l { 3228 return io.ErrUnexpectedEOF 3229 } 3230 iNdEx += skippy 3231 } 3232 } 3233 3234 if iNdEx > l { 3235 return io.ErrUnexpectedEOF 3236 } 3237 return nil 3238} 3239func (m *Aggregate) Unmarshal(dAtA []byte) error { 3240 l := len(dAtA) 3241 iNdEx := 0 3242 for iNdEx < l { 3243 preIndex := iNdEx 3244 var wire uint64 3245 for shift := uint(0); ; shift += 7 { 3246 if shift >= 64 { 3247 return ErrIntOverflowStorageCommon 3248 } 3249 if iNdEx >= l { 3250 return io.ErrUnexpectedEOF 3251 } 3252 b := dAtA[iNdEx] 3253 iNdEx++ 3254 wire |= uint64(b&0x7F) << shift 3255 if b < 0x80 { 3256 break 3257 } 3258 } 3259 fieldNum := int32(wire >> 3) 3260 wireType := int(wire & 0x7) 3261 if wireType == 4 { 3262 return fmt.Errorf("proto: Aggregate: wiretype end group for non-group") 3263 } 3264 if fieldNum <= 0 { 3265 return fmt.Errorf("proto: Aggregate: illegal tag %d (wire type %d)", fieldNum, wire) 3266 } 3267 switch fieldNum { 3268 case 1: 3269 if wireType != 0 { 3270 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 3271 } 3272 m.Type = 0 3273 for shift := uint(0); ; shift += 7 { 3274 if shift >= 64 { 3275 return ErrIntOverflowStorageCommon 3276 } 3277 if iNdEx >= l { 3278 return io.ErrUnexpectedEOF 3279 } 3280 b := dAtA[iNdEx] 3281 iNdEx++ 3282 m.Type |= Aggregate_AggregateType(b&0x7F) << shift 3283 if b < 0x80 { 3284 break 3285 } 3286 } 3287 default: 3288 iNdEx = preIndex 3289 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 3290 if err != nil { 3291 return err 3292 } 3293 if skippy < 0 { 3294 return ErrInvalidLengthStorageCommon 3295 } 3296 if (iNdEx + skippy) < 0 { 3297 return ErrInvalidLengthStorageCommon 3298 } 3299 if (iNdEx + skippy) > l { 3300 return io.ErrUnexpectedEOF 3301 } 3302 iNdEx += skippy 3303 } 3304 } 3305 3306 if iNdEx > l { 3307 return io.ErrUnexpectedEOF 3308 } 3309 return nil 3310} 3311func (m *Tag) Unmarshal(dAtA []byte) error { 3312 l := len(dAtA) 3313 iNdEx := 0 3314 for iNdEx < l { 3315 preIndex := iNdEx 3316 var wire uint64 3317 for shift := uint(0); ; shift += 7 { 3318 if shift >= 64 { 3319 return ErrIntOverflowStorageCommon 3320 } 3321 if iNdEx >= l { 3322 return io.ErrUnexpectedEOF 3323 } 3324 b := dAtA[iNdEx] 3325 iNdEx++ 3326 wire |= uint64(b&0x7F) << shift 3327 if b < 0x80 { 3328 break 3329 } 3330 } 3331 fieldNum := int32(wire >> 3) 3332 wireType := int(wire & 0x7) 3333 if wireType == 4 { 3334 return fmt.Errorf("proto: Tag: wiretype end group for non-group") 3335 } 3336 if fieldNum <= 0 { 3337 return fmt.Errorf("proto: Tag: illegal tag %d (wire type %d)", fieldNum, wire) 3338 } 3339 switch fieldNum { 3340 case 1: 3341 if wireType != 2 { 3342 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) 3343 } 3344 var byteLen int 3345 for shift := uint(0); ; shift += 7 { 3346 if shift >= 64 { 3347 return ErrIntOverflowStorageCommon 3348 } 3349 if iNdEx >= l { 3350 return io.ErrUnexpectedEOF 3351 } 3352 b := dAtA[iNdEx] 3353 iNdEx++ 3354 byteLen |= int(b&0x7F) << shift 3355 if b < 0x80 { 3356 break 3357 } 3358 } 3359 if byteLen < 0 { 3360 return ErrInvalidLengthStorageCommon 3361 } 3362 postIndex := iNdEx + byteLen 3363 if postIndex < 0 { 3364 return ErrInvalidLengthStorageCommon 3365 } 3366 if postIndex > l { 3367 return io.ErrUnexpectedEOF 3368 } 3369 m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) 3370 if m.Key == nil { 3371 m.Key = []byte{} 3372 } 3373 iNdEx = postIndex 3374 case 2: 3375 if wireType != 2 { 3376 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 3377 } 3378 var byteLen int 3379 for shift := uint(0); ; shift += 7 { 3380 if shift >= 64 { 3381 return ErrIntOverflowStorageCommon 3382 } 3383 if iNdEx >= l { 3384 return io.ErrUnexpectedEOF 3385 } 3386 b := dAtA[iNdEx] 3387 iNdEx++ 3388 byteLen |= int(b&0x7F) << shift 3389 if b < 0x80 { 3390 break 3391 } 3392 } 3393 if byteLen < 0 { 3394 return ErrInvalidLengthStorageCommon 3395 } 3396 postIndex := iNdEx + byteLen 3397 if postIndex < 0 { 3398 return ErrInvalidLengthStorageCommon 3399 } 3400 if postIndex > l { 3401 return io.ErrUnexpectedEOF 3402 } 3403 m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) 3404 if m.Value == nil { 3405 m.Value = []byte{} 3406 } 3407 iNdEx = postIndex 3408 default: 3409 iNdEx = preIndex 3410 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 3411 if err != nil { 3412 return err 3413 } 3414 if skippy < 0 { 3415 return ErrInvalidLengthStorageCommon 3416 } 3417 if (iNdEx + skippy) < 0 { 3418 return ErrInvalidLengthStorageCommon 3419 } 3420 if (iNdEx + skippy) > l { 3421 return io.ErrUnexpectedEOF 3422 } 3423 iNdEx += skippy 3424 } 3425 } 3426 3427 if iNdEx > l { 3428 return io.ErrUnexpectedEOF 3429 } 3430 return nil 3431} 3432func (m *ReadResponse) Unmarshal(dAtA []byte) error { 3433 l := len(dAtA) 3434 iNdEx := 0 3435 for iNdEx < l { 3436 preIndex := iNdEx 3437 var wire uint64 3438 for shift := uint(0); ; shift += 7 { 3439 if shift >= 64 { 3440 return ErrIntOverflowStorageCommon 3441 } 3442 if iNdEx >= l { 3443 return io.ErrUnexpectedEOF 3444 } 3445 b := dAtA[iNdEx] 3446 iNdEx++ 3447 wire |= uint64(b&0x7F) << shift 3448 if b < 0x80 { 3449 break 3450 } 3451 } 3452 fieldNum := int32(wire >> 3) 3453 wireType := int(wire & 0x7) 3454 if wireType == 4 { 3455 return fmt.Errorf("proto: ReadResponse: wiretype end group for non-group") 3456 } 3457 if fieldNum <= 0 { 3458 return fmt.Errorf("proto: ReadResponse: illegal tag %d (wire type %d)", fieldNum, wire) 3459 } 3460 switch fieldNum { 3461 case 1: 3462 if wireType != 2 { 3463 return fmt.Errorf("proto: wrong wireType = %d for field Frames", wireType) 3464 } 3465 var msglen int 3466 for shift := uint(0); ; shift += 7 { 3467 if shift >= 64 { 3468 return ErrIntOverflowStorageCommon 3469 } 3470 if iNdEx >= l { 3471 return io.ErrUnexpectedEOF 3472 } 3473 b := dAtA[iNdEx] 3474 iNdEx++ 3475 msglen |= int(b&0x7F) << shift 3476 if b < 0x80 { 3477 break 3478 } 3479 } 3480 if msglen < 0 { 3481 return ErrInvalidLengthStorageCommon 3482 } 3483 postIndex := iNdEx + msglen 3484 if postIndex < 0 { 3485 return ErrInvalidLengthStorageCommon 3486 } 3487 if postIndex > l { 3488 return io.ErrUnexpectedEOF 3489 } 3490 m.Frames = append(m.Frames, ReadResponse_Frame{}) 3491 if err := m.Frames[len(m.Frames)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3492 return err 3493 } 3494 iNdEx = postIndex 3495 default: 3496 iNdEx = preIndex 3497 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 3498 if err != nil { 3499 return err 3500 } 3501 if skippy < 0 { 3502 return ErrInvalidLengthStorageCommon 3503 } 3504 if (iNdEx + skippy) < 0 { 3505 return ErrInvalidLengthStorageCommon 3506 } 3507 if (iNdEx + skippy) > l { 3508 return io.ErrUnexpectedEOF 3509 } 3510 iNdEx += skippy 3511 } 3512 } 3513 3514 if iNdEx > l { 3515 return io.ErrUnexpectedEOF 3516 } 3517 return nil 3518} 3519func (m *ReadResponse_Frame) Unmarshal(dAtA []byte) error { 3520 l := len(dAtA) 3521 iNdEx := 0 3522 for iNdEx < l { 3523 preIndex := iNdEx 3524 var wire uint64 3525 for shift := uint(0); ; shift += 7 { 3526 if shift >= 64 { 3527 return ErrIntOverflowStorageCommon 3528 } 3529 if iNdEx >= l { 3530 return io.ErrUnexpectedEOF 3531 } 3532 b := dAtA[iNdEx] 3533 iNdEx++ 3534 wire |= uint64(b&0x7F) << shift 3535 if b < 0x80 { 3536 break 3537 } 3538 } 3539 fieldNum := int32(wire >> 3) 3540 wireType := int(wire & 0x7) 3541 if wireType == 4 { 3542 return fmt.Errorf("proto: Frame: wiretype end group for non-group") 3543 } 3544 if fieldNum <= 0 { 3545 return fmt.Errorf("proto: Frame: illegal tag %d (wire type %d)", fieldNum, wire) 3546 } 3547 switch fieldNum { 3548 case 1: 3549 if wireType != 2 { 3550 return fmt.Errorf("proto: wrong wireType = %d for field Series", wireType) 3551 } 3552 var msglen int 3553 for shift := uint(0); ; shift += 7 { 3554 if shift >= 64 { 3555 return ErrIntOverflowStorageCommon 3556 } 3557 if iNdEx >= l { 3558 return io.ErrUnexpectedEOF 3559 } 3560 b := dAtA[iNdEx] 3561 iNdEx++ 3562 msglen |= int(b&0x7F) << shift 3563 if b < 0x80 { 3564 break 3565 } 3566 } 3567 if msglen < 0 { 3568 return ErrInvalidLengthStorageCommon 3569 } 3570 postIndex := iNdEx + msglen 3571 if postIndex < 0 { 3572 return ErrInvalidLengthStorageCommon 3573 } 3574 if postIndex > l { 3575 return io.ErrUnexpectedEOF 3576 } 3577 v := &ReadResponse_SeriesFrame{} 3578 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3579 return err 3580 } 3581 m.Data = &ReadResponse_Frame_Series{v} 3582 iNdEx = postIndex 3583 case 2: 3584 if wireType != 2 { 3585 return fmt.Errorf("proto: wrong wireType = %d for field FloatPoints", wireType) 3586 } 3587 var msglen int 3588 for shift := uint(0); ; shift += 7 { 3589 if shift >= 64 { 3590 return ErrIntOverflowStorageCommon 3591 } 3592 if iNdEx >= l { 3593 return io.ErrUnexpectedEOF 3594 } 3595 b := dAtA[iNdEx] 3596 iNdEx++ 3597 msglen |= int(b&0x7F) << shift 3598 if b < 0x80 { 3599 break 3600 } 3601 } 3602 if msglen < 0 { 3603 return ErrInvalidLengthStorageCommon 3604 } 3605 postIndex := iNdEx + msglen 3606 if postIndex < 0 { 3607 return ErrInvalidLengthStorageCommon 3608 } 3609 if postIndex > l { 3610 return io.ErrUnexpectedEOF 3611 } 3612 v := &ReadResponse_FloatPointsFrame{} 3613 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3614 return err 3615 } 3616 m.Data = &ReadResponse_Frame_FloatPoints{v} 3617 iNdEx = postIndex 3618 case 3: 3619 if wireType != 2 { 3620 return fmt.Errorf("proto: wrong wireType = %d for field IntegerPoints", wireType) 3621 } 3622 var msglen int 3623 for shift := uint(0); ; shift += 7 { 3624 if shift >= 64 { 3625 return ErrIntOverflowStorageCommon 3626 } 3627 if iNdEx >= l { 3628 return io.ErrUnexpectedEOF 3629 } 3630 b := dAtA[iNdEx] 3631 iNdEx++ 3632 msglen |= int(b&0x7F) << shift 3633 if b < 0x80 { 3634 break 3635 } 3636 } 3637 if msglen < 0 { 3638 return ErrInvalidLengthStorageCommon 3639 } 3640 postIndex := iNdEx + msglen 3641 if postIndex < 0 { 3642 return ErrInvalidLengthStorageCommon 3643 } 3644 if postIndex > l { 3645 return io.ErrUnexpectedEOF 3646 } 3647 v := &ReadResponse_IntegerPointsFrame{} 3648 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3649 return err 3650 } 3651 m.Data = &ReadResponse_Frame_IntegerPoints{v} 3652 iNdEx = postIndex 3653 case 4: 3654 if wireType != 2 { 3655 return fmt.Errorf("proto: wrong wireType = %d for field UnsignedPoints", wireType) 3656 } 3657 var msglen int 3658 for shift := uint(0); ; shift += 7 { 3659 if shift >= 64 { 3660 return ErrIntOverflowStorageCommon 3661 } 3662 if iNdEx >= l { 3663 return io.ErrUnexpectedEOF 3664 } 3665 b := dAtA[iNdEx] 3666 iNdEx++ 3667 msglen |= int(b&0x7F) << shift 3668 if b < 0x80 { 3669 break 3670 } 3671 } 3672 if msglen < 0 { 3673 return ErrInvalidLengthStorageCommon 3674 } 3675 postIndex := iNdEx + msglen 3676 if postIndex < 0 { 3677 return ErrInvalidLengthStorageCommon 3678 } 3679 if postIndex > l { 3680 return io.ErrUnexpectedEOF 3681 } 3682 v := &ReadResponse_UnsignedPointsFrame{} 3683 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3684 return err 3685 } 3686 m.Data = &ReadResponse_Frame_UnsignedPoints{v} 3687 iNdEx = postIndex 3688 case 5: 3689 if wireType != 2 { 3690 return fmt.Errorf("proto: wrong wireType = %d for field BooleanPoints", wireType) 3691 } 3692 var msglen int 3693 for shift := uint(0); ; shift += 7 { 3694 if shift >= 64 { 3695 return ErrIntOverflowStorageCommon 3696 } 3697 if iNdEx >= l { 3698 return io.ErrUnexpectedEOF 3699 } 3700 b := dAtA[iNdEx] 3701 iNdEx++ 3702 msglen |= int(b&0x7F) << shift 3703 if b < 0x80 { 3704 break 3705 } 3706 } 3707 if msglen < 0 { 3708 return ErrInvalidLengthStorageCommon 3709 } 3710 postIndex := iNdEx + msglen 3711 if postIndex < 0 { 3712 return ErrInvalidLengthStorageCommon 3713 } 3714 if postIndex > l { 3715 return io.ErrUnexpectedEOF 3716 } 3717 v := &ReadResponse_BooleanPointsFrame{} 3718 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3719 return err 3720 } 3721 m.Data = &ReadResponse_Frame_BooleanPoints{v} 3722 iNdEx = postIndex 3723 case 6: 3724 if wireType != 2 { 3725 return fmt.Errorf("proto: wrong wireType = %d for field StringPoints", wireType) 3726 } 3727 var msglen int 3728 for shift := uint(0); ; shift += 7 { 3729 if shift >= 64 { 3730 return ErrIntOverflowStorageCommon 3731 } 3732 if iNdEx >= l { 3733 return io.ErrUnexpectedEOF 3734 } 3735 b := dAtA[iNdEx] 3736 iNdEx++ 3737 msglen |= int(b&0x7F) << shift 3738 if b < 0x80 { 3739 break 3740 } 3741 } 3742 if msglen < 0 { 3743 return ErrInvalidLengthStorageCommon 3744 } 3745 postIndex := iNdEx + msglen 3746 if postIndex < 0 { 3747 return ErrInvalidLengthStorageCommon 3748 } 3749 if postIndex > l { 3750 return io.ErrUnexpectedEOF 3751 } 3752 v := &ReadResponse_StringPointsFrame{} 3753 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3754 return err 3755 } 3756 m.Data = &ReadResponse_Frame_StringPoints{v} 3757 iNdEx = postIndex 3758 case 7: 3759 if wireType != 2 { 3760 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) 3761 } 3762 var msglen int 3763 for shift := uint(0); ; shift += 7 { 3764 if shift >= 64 { 3765 return ErrIntOverflowStorageCommon 3766 } 3767 if iNdEx >= l { 3768 return io.ErrUnexpectedEOF 3769 } 3770 b := dAtA[iNdEx] 3771 iNdEx++ 3772 msglen |= int(b&0x7F) << shift 3773 if b < 0x80 { 3774 break 3775 } 3776 } 3777 if msglen < 0 { 3778 return ErrInvalidLengthStorageCommon 3779 } 3780 postIndex := iNdEx + msglen 3781 if postIndex < 0 { 3782 return ErrInvalidLengthStorageCommon 3783 } 3784 if postIndex > l { 3785 return io.ErrUnexpectedEOF 3786 } 3787 v := &ReadResponse_GroupFrame{} 3788 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3789 return err 3790 } 3791 m.Data = &ReadResponse_Frame_Group{v} 3792 iNdEx = postIndex 3793 default: 3794 iNdEx = preIndex 3795 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 3796 if err != nil { 3797 return err 3798 } 3799 if skippy < 0 { 3800 return ErrInvalidLengthStorageCommon 3801 } 3802 if (iNdEx + skippy) < 0 { 3803 return ErrInvalidLengthStorageCommon 3804 } 3805 if (iNdEx + skippy) > l { 3806 return io.ErrUnexpectedEOF 3807 } 3808 iNdEx += skippy 3809 } 3810 } 3811 3812 if iNdEx > l { 3813 return io.ErrUnexpectedEOF 3814 } 3815 return nil 3816} 3817func (m *ReadResponse_GroupFrame) Unmarshal(dAtA []byte) error { 3818 l := len(dAtA) 3819 iNdEx := 0 3820 for iNdEx < l { 3821 preIndex := iNdEx 3822 var wire uint64 3823 for shift := uint(0); ; shift += 7 { 3824 if shift >= 64 { 3825 return ErrIntOverflowStorageCommon 3826 } 3827 if iNdEx >= l { 3828 return io.ErrUnexpectedEOF 3829 } 3830 b := dAtA[iNdEx] 3831 iNdEx++ 3832 wire |= uint64(b&0x7F) << shift 3833 if b < 0x80 { 3834 break 3835 } 3836 } 3837 fieldNum := int32(wire >> 3) 3838 wireType := int(wire & 0x7) 3839 if wireType == 4 { 3840 return fmt.Errorf("proto: GroupFrame: wiretype end group for non-group") 3841 } 3842 if fieldNum <= 0 { 3843 return fmt.Errorf("proto: GroupFrame: illegal tag %d (wire type %d)", fieldNum, wire) 3844 } 3845 switch fieldNum { 3846 case 1: 3847 if wireType != 2 { 3848 return fmt.Errorf("proto: wrong wireType = %d for field TagKeys", wireType) 3849 } 3850 var byteLen int 3851 for shift := uint(0); ; shift += 7 { 3852 if shift >= 64 { 3853 return ErrIntOverflowStorageCommon 3854 } 3855 if iNdEx >= l { 3856 return io.ErrUnexpectedEOF 3857 } 3858 b := dAtA[iNdEx] 3859 iNdEx++ 3860 byteLen |= int(b&0x7F) << shift 3861 if b < 0x80 { 3862 break 3863 } 3864 } 3865 if byteLen < 0 { 3866 return ErrInvalidLengthStorageCommon 3867 } 3868 postIndex := iNdEx + byteLen 3869 if postIndex < 0 { 3870 return ErrInvalidLengthStorageCommon 3871 } 3872 if postIndex > l { 3873 return io.ErrUnexpectedEOF 3874 } 3875 m.TagKeys = append(m.TagKeys, make([]byte, postIndex-iNdEx)) 3876 copy(m.TagKeys[len(m.TagKeys)-1], dAtA[iNdEx:postIndex]) 3877 iNdEx = postIndex 3878 case 2: 3879 if wireType != 2 { 3880 return fmt.Errorf("proto: wrong wireType = %d for field PartitionKeyVals", wireType) 3881 } 3882 var byteLen int 3883 for shift := uint(0); ; shift += 7 { 3884 if shift >= 64 { 3885 return ErrIntOverflowStorageCommon 3886 } 3887 if iNdEx >= l { 3888 return io.ErrUnexpectedEOF 3889 } 3890 b := dAtA[iNdEx] 3891 iNdEx++ 3892 byteLen |= int(b&0x7F) << shift 3893 if b < 0x80 { 3894 break 3895 } 3896 } 3897 if byteLen < 0 { 3898 return ErrInvalidLengthStorageCommon 3899 } 3900 postIndex := iNdEx + byteLen 3901 if postIndex < 0 { 3902 return ErrInvalidLengthStorageCommon 3903 } 3904 if postIndex > l { 3905 return io.ErrUnexpectedEOF 3906 } 3907 m.PartitionKeyVals = append(m.PartitionKeyVals, make([]byte, postIndex-iNdEx)) 3908 copy(m.PartitionKeyVals[len(m.PartitionKeyVals)-1], dAtA[iNdEx:postIndex]) 3909 iNdEx = postIndex 3910 default: 3911 iNdEx = preIndex 3912 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 3913 if err != nil { 3914 return err 3915 } 3916 if skippy < 0 { 3917 return ErrInvalidLengthStorageCommon 3918 } 3919 if (iNdEx + skippy) < 0 { 3920 return ErrInvalidLengthStorageCommon 3921 } 3922 if (iNdEx + skippy) > l { 3923 return io.ErrUnexpectedEOF 3924 } 3925 iNdEx += skippy 3926 } 3927 } 3928 3929 if iNdEx > l { 3930 return io.ErrUnexpectedEOF 3931 } 3932 return nil 3933} 3934func (m *ReadResponse_SeriesFrame) Unmarshal(dAtA []byte) error { 3935 l := len(dAtA) 3936 iNdEx := 0 3937 for iNdEx < l { 3938 preIndex := iNdEx 3939 var wire uint64 3940 for shift := uint(0); ; shift += 7 { 3941 if shift >= 64 { 3942 return ErrIntOverflowStorageCommon 3943 } 3944 if iNdEx >= l { 3945 return io.ErrUnexpectedEOF 3946 } 3947 b := dAtA[iNdEx] 3948 iNdEx++ 3949 wire |= uint64(b&0x7F) << shift 3950 if b < 0x80 { 3951 break 3952 } 3953 } 3954 fieldNum := int32(wire >> 3) 3955 wireType := int(wire & 0x7) 3956 if wireType == 4 { 3957 return fmt.Errorf("proto: SeriesFrame: wiretype end group for non-group") 3958 } 3959 if fieldNum <= 0 { 3960 return fmt.Errorf("proto: SeriesFrame: illegal tag %d (wire type %d)", fieldNum, wire) 3961 } 3962 switch fieldNum { 3963 case 1: 3964 if wireType != 2 { 3965 return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType) 3966 } 3967 var msglen int 3968 for shift := uint(0); ; shift += 7 { 3969 if shift >= 64 { 3970 return ErrIntOverflowStorageCommon 3971 } 3972 if iNdEx >= l { 3973 return io.ErrUnexpectedEOF 3974 } 3975 b := dAtA[iNdEx] 3976 iNdEx++ 3977 msglen |= int(b&0x7F) << shift 3978 if b < 0x80 { 3979 break 3980 } 3981 } 3982 if msglen < 0 { 3983 return ErrInvalidLengthStorageCommon 3984 } 3985 postIndex := iNdEx + msglen 3986 if postIndex < 0 { 3987 return ErrInvalidLengthStorageCommon 3988 } 3989 if postIndex > l { 3990 return io.ErrUnexpectedEOF 3991 } 3992 m.Tags = append(m.Tags, Tag{}) 3993 if err := m.Tags[len(m.Tags)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 3994 return err 3995 } 3996 iNdEx = postIndex 3997 case 2: 3998 if wireType != 0 { 3999 return fmt.Errorf("proto: wrong wireType = %d for field DataType", wireType) 4000 } 4001 m.DataType = 0 4002 for shift := uint(0); ; shift += 7 { 4003 if shift >= 64 { 4004 return ErrIntOverflowStorageCommon 4005 } 4006 if iNdEx >= l { 4007 return io.ErrUnexpectedEOF 4008 } 4009 b := dAtA[iNdEx] 4010 iNdEx++ 4011 m.DataType |= ReadResponse_DataType(b&0x7F) << shift 4012 if b < 0x80 { 4013 break 4014 } 4015 } 4016 default: 4017 iNdEx = preIndex 4018 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 4019 if err != nil { 4020 return err 4021 } 4022 if skippy < 0 { 4023 return ErrInvalidLengthStorageCommon 4024 } 4025 if (iNdEx + skippy) < 0 { 4026 return ErrInvalidLengthStorageCommon 4027 } 4028 if (iNdEx + skippy) > l { 4029 return io.ErrUnexpectedEOF 4030 } 4031 iNdEx += skippy 4032 } 4033 } 4034 4035 if iNdEx > l { 4036 return io.ErrUnexpectedEOF 4037 } 4038 return nil 4039} 4040func (m *ReadResponse_FloatPointsFrame) Unmarshal(dAtA []byte) error { 4041 l := len(dAtA) 4042 iNdEx := 0 4043 for iNdEx < l { 4044 preIndex := iNdEx 4045 var wire uint64 4046 for shift := uint(0); ; shift += 7 { 4047 if shift >= 64 { 4048 return ErrIntOverflowStorageCommon 4049 } 4050 if iNdEx >= l { 4051 return io.ErrUnexpectedEOF 4052 } 4053 b := dAtA[iNdEx] 4054 iNdEx++ 4055 wire |= uint64(b&0x7F) << shift 4056 if b < 0x80 { 4057 break 4058 } 4059 } 4060 fieldNum := int32(wire >> 3) 4061 wireType := int(wire & 0x7) 4062 if wireType == 4 { 4063 return fmt.Errorf("proto: FloatPointsFrame: wiretype end group for non-group") 4064 } 4065 if fieldNum <= 0 { 4066 return fmt.Errorf("proto: FloatPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire) 4067 } 4068 switch fieldNum { 4069 case 1: 4070 if wireType == 1 { 4071 var v int64 4072 if (iNdEx + 8) > l { 4073 return io.ErrUnexpectedEOF 4074 } 4075 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 4076 iNdEx += 8 4077 m.Timestamps = append(m.Timestamps, v) 4078 } else if wireType == 2 { 4079 var packedLen int 4080 for shift := uint(0); ; shift += 7 { 4081 if shift >= 64 { 4082 return ErrIntOverflowStorageCommon 4083 } 4084 if iNdEx >= l { 4085 return io.ErrUnexpectedEOF 4086 } 4087 b := dAtA[iNdEx] 4088 iNdEx++ 4089 packedLen |= int(b&0x7F) << shift 4090 if b < 0x80 { 4091 break 4092 } 4093 } 4094 if packedLen < 0 { 4095 return ErrInvalidLengthStorageCommon 4096 } 4097 postIndex := iNdEx + packedLen 4098 if postIndex < 0 { 4099 return ErrInvalidLengthStorageCommon 4100 } 4101 if postIndex > l { 4102 return io.ErrUnexpectedEOF 4103 } 4104 var elementCount int 4105 elementCount = packedLen / 8 4106 if elementCount != 0 && len(m.Timestamps) == 0 { 4107 m.Timestamps = make([]int64, 0, elementCount) 4108 } 4109 for iNdEx < postIndex { 4110 var v int64 4111 if (iNdEx + 8) > l { 4112 return io.ErrUnexpectedEOF 4113 } 4114 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 4115 iNdEx += 8 4116 m.Timestamps = append(m.Timestamps, v) 4117 } 4118 } else { 4119 return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType) 4120 } 4121 case 2: 4122 if wireType == 1 { 4123 var v uint64 4124 if (iNdEx + 8) > l { 4125 return io.ErrUnexpectedEOF 4126 } 4127 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 4128 iNdEx += 8 4129 v2 := float64(math.Float64frombits(v)) 4130 m.Values = append(m.Values, v2) 4131 } else if wireType == 2 { 4132 var packedLen int 4133 for shift := uint(0); ; shift += 7 { 4134 if shift >= 64 { 4135 return ErrIntOverflowStorageCommon 4136 } 4137 if iNdEx >= l { 4138 return io.ErrUnexpectedEOF 4139 } 4140 b := dAtA[iNdEx] 4141 iNdEx++ 4142 packedLen |= int(b&0x7F) << shift 4143 if b < 0x80 { 4144 break 4145 } 4146 } 4147 if packedLen < 0 { 4148 return ErrInvalidLengthStorageCommon 4149 } 4150 postIndex := iNdEx + packedLen 4151 if postIndex < 0 { 4152 return ErrInvalidLengthStorageCommon 4153 } 4154 if postIndex > l { 4155 return io.ErrUnexpectedEOF 4156 } 4157 var elementCount int 4158 elementCount = packedLen / 8 4159 if elementCount != 0 && len(m.Values) == 0 { 4160 m.Values = make([]float64, 0, elementCount) 4161 } 4162 for iNdEx < postIndex { 4163 var v uint64 4164 if (iNdEx + 8) > l { 4165 return io.ErrUnexpectedEOF 4166 } 4167 v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 4168 iNdEx += 8 4169 v2 := float64(math.Float64frombits(v)) 4170 m.Values = append(m.Values, v2) 4171 } 4172 } else { 4173 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 4174 } 4175 default: 4176 iNdEx = preIndex 4177 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 4178 if err != nil { 4179 return err 4180 } 4181 if skippy < 0 { 4182 return ErrInvalidLengthStorageCommon 4183 } 4184 if (iNdEx + skippy) < 0 { 4185 return ErrInvalidLengthStorageCommon 4186 } 4187 if (iNdEx + skippy) > l { 4188 return io.ErrUnexpectedEOF 4189 } 4190 iNdEx += skippy 4191 } 4192 } 4193 4194 if iNdEx > l { 4195 return io.ErrUnexpectedEOF 4196 } 4197 return nil 4198} 4199func (m *ReadResponse_IntegerPointsFrame) Unmarshal(dAtA []byte) error { 4200 l := len(dAtA) 4201 iNdEx := 0 4202 for iNdEx < l { 4203 preIndex := iNdEx 4204 var wire uint64 4205 for shift := uint(0); ; shift += 7 { 4206 if shift >= 64 { 4207 return ErrIntOverflowStorageCommon 4208 } 4209 if iNdEx >= l { 4210 return io.ErrUnexpectedEOF 4211 } 4212 b := dAtA[iNdEx] 4213 iNdEx++ 4214 wire |= uint64(b&0x7F) << shift 4215 if b < 0x80 { 4216 break 4217 } 4218 } 4219 fieldNum := int32(wire >> 3) 4220 wireType := int(wire & 0x7) 4221 if wireType == 4 { 4222 return fmt.Errorf("proto: IntegerPointsFrame: wiretype end group for non-group") 4223 } 4224 if fieldNum <= 0 { 4225 return fmt.Errorf("proto: IntegerPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire) 4226 } 4227 switch fieldNum { 4228 case 1: 4229 if wireType == 1 { 4230 var v int64 4231 if (iNdEx + 8) > l { 4232 return io.ErrUnexpectedEOF 4233 } 4234 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 4235 iNdEx += 8 4236 m.Timestamps = append(m.Timestamps, v) 4237 } else if wireType == 2 { 4238 var packedLen int 4239 for shift := uint(0); ; shift += 7 { 4240 if shift >= 64 { 4241 return ErrIntOverflowStorageCommon 4242 } 4243 if iNdEx >= l { 4244 return io.ErrUnexpectedEOF 4245 } 4246 b := dAtA[iNdEx] 4247 iNdEx++ 4248 packedLen |= int(b&0x7F) << shift 4249 if b < 0x80 { 4250 break 4251 } 4252 } 4253 if packedLen < 0 { 4254 return ErrInvalidLengthStorageCommon 4255 } 4256 postIndex := iNdEx + packedLen 4257 if postIndex < 0 { 4258 return ErrInvalidLengthStorageCommon 4259 } 4260 if postIndex > l { 4261 return io.ErrUnexpectedEOF 4262 } 4263 var elementCount int 4264 elementCount = packedLen / 8 4265 if elementCount != 0 && len(m.Timestamps) == 0 { 4266 m.Timestamps = make([]int64, 0, elementCount) 4267 } 4268 for iNdEx < postIndex { 4269 var v int64 4270 if (iNdEx + 8) > l { 4271 return io.ErrUnexpectedEOF 4272 } 4273 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 4274 iNdEx += 8 4275 m.Timestamps = append(m.Timestamps, v) 4276 } 4277 } else { 4278 return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType) 4279 } 4280 case 2: 4281 if wireType == 0 { 4282 var v int64 4283 for shift := uint(0); ; shift += 7 { 4284 if shift >= 64 { 4285 return ErrIntOverflowStorageCommon 4286 } 4287 if iNdEx >= l { 4288 return io.ErrUnexpectedEOF 4289 } 4290 b := dAtA[iNdEx] 4291 iNdEx++ 4292 v |= int64(b&0x7F) << shift 4293 if b < 0x80 { 4294 break 4295 } 4296 } 4297 m.Values = append(m.Values, v) 4298 } else if wireType == 2 { 4299 var packedLen int 4300 for shift := uint(0); ; shift += 7 { 4301 if shift >= 64 { 4302 return ErrIntOverflowStorageCommon 4303 } 4304 if iNdEx >= l { 4305 return io.ErrUnexpectedEOF 4306 } 4307 b := dAtA[iNdEx] 4308 iNdEx++ 4309 packedLen |= int(b&0x7F) << shift 4310 if b < 0x80 { 4311 break 4312 } 4313 } 4314 if packedLen < 0 { 4315 return ErrInvalidLengthStorageCommon 4316 } 4317 postIndex := iNdEx + packedLen 4318 if postIndex < 0 { 4319 return ErrInvalidLengthStorageCommon 4320 } 4321 if postIndex > l { 4322 return io.ErrUnexpectedEOF 4323 } 4324 var elementCount int 4325 var count int 4326 for _, integer := range dAtA[iNdEx:postIndex] { 4327 if integer < 128 { 4328 count++ 4329 } 4330 } 4331 elementCount = count 4332 if elementCount != 0 && len(m.Values) == 0 { 4333 m.Values = make([]int64, 0, elementCount) 4334 } 4335 for iNdEx < postIndex { 4336 var v int64 4337 for shift := uint(0); ; shift += 7 { 4338 if shift >= 64 { 4339 return ErrIntOverflowStorageCommon 4340 } 4341 if iNdEx >= l { 4342 return io.ErrUnexpectedEOF 4343 } 4344 b := dAtA[iNdEx] 4345 iNdEx++ 4346 v |= int64(b&0x7F) << shift 4347 if b < 0x80 { 4348 break 4349 } 4350 } 4351 m.Values = append(m.Values, v) 4352 } 4353 } else { 4354 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 4355 } 4356 default: 4357 iNdEx = preIndex 4358 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 4359 if err != nil { 4360 return err 4361 } 4362 if skippy < 0 { 4363 return ErrInvalidLengthStorageCommon 4364 } 4365 if (iNdEx + skippy) < 0 { 4366 return ErrInvalidLengthStorageCommon 4367 } 4368 if (iNdEx + skippy) > l { 4369 return io.ErrUnexpectedEOF 4370 } 4371 iNdEx += skippy 4372 } 4373 } 4374 4375 if iNdEx > l { 4376 return io.ErrUnexpectedEOF 4377 } 4378 return nil 4379} 4380func (m *ReadResponse_UnsignedPointsFrame) Unmarshal(dAtA []byte) error { 4381 l := len(dAtA) 4382 iNdEx := 0 4383 for iNdEx < l { 4384 preIndex := iNdEx 4385 var wire uint64 4386 for shift := uint(0); ; shift += 7 { 4387 if shift >= 64 { 4388 return ErrIntOverflowStorageCommon 4389 } 4390 if iNdEx >= l { 4391 return io.ErrUnexpectedEOF 4392 } 4393 b := dAtA[iNdEx] 4394 iNdEx++ 4395 wire |= uint64(b&0x7F) << shift 4396 if b < 0x80 { 4397 break 4398 } 4399 } 4400 fieldNum := int32(wire >> 3) 4401 wireType := int(wire & 0x7) 4402 if wireType == 4 { 4403 return fmt.Errorf("proto: UnsignedPointsFrame: wiretype end group for non-group") 4404 } 4405 if fieldNum <= 0 { 4406 return fmt.Errorf("proto: UnsignedPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire) 4407 } 4408 switch fieldNum { 4409 case 1: 4410 if wireType == 1 { 4411 var v int64 4412 if (iNdEx + 8) > l { 4413 return io.ErrUnexpectedEOF 4414 } 4415 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 4416 iNdEx += 8 4417 m.Timestamps = append(m.Timestamps, v) 4418 } else if wireType == 2 { 4419 var packedLen int 4420 for shift := uint(0); ; shift += 7 { 4421 if shift >= 64 { 4422 return ErrIntOverflowStorageCommon 4423 } 4424 if iNdEx >= l { 4425 return io.ErrUnexpectedEOF 4426 } 4427 b := dAtA[iNdEx] 4428 iNdEx++ 4429 packedLen |= int(b&0x7F) << shift 4430 if b < 0x80 { 4431 break 4432 } 4433 } 4434 if packedLen < 0 { 4435 return ErrInvalidLengthStorageCommon 4436 } 4437 postIndex := iNdEx + packedLen 4438 if postIndex < 0 { 4439 return ErrInvalidLengthStorageCommon 4440 } 4441 if postIndex > l { 4442 return io.ErrUnexpectedEOF 4443 } 4444 var elementCount int 4445 elementCount = packedLen / 8 4446 if elementCount != 0 && len(m.Timestamps) == 0 { 4447 m.Timestamps = make([]int64, 0, elementCount) 4448 } 4449 for iNdEx < postIndex { 4450 var v int64 4451 if (iNdEx + 8) > l { 4452 return io.ErrUnexpectedEOF 4453 } 4454 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 4455 iNdEx += 8 4456 m.Timestamps = append(m.Timestamps, v) 4457 } 4458 } else { 4459 return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType) 4460 } 4461 case 2: 4462 if wireType == 0 { 4463 var v uint64 4464 for shift := uint(0); ; shift += 7 { 4465 if shift >= 64 { 4466 return ErrIntOverflowStorageCommon 4467 } 4468 if iNdEx >= l { 4469 return io.ErrUnexpectedEOF 4470 } 4471 b := dAtA[iNdEx] 4472 iNdEx++ 4473 v |= uint64(b&0x7F) << shift 4474 if b < 0x80 { 4475 break 4476 } 4477 } 4478 m.Values = append(m.Values, v) 4479 } else if wireType == 2 { 4480 var packedLen int 4481 for shift := uint(0); ; shift += 7 { 4482 if shift >= 64 { 4483 return ErrIntOverflowStorageCommon 4484 } 4485 if iNdEx >= l { 4486 return io.ErrUnexpectedEOF 4487 } 4488 b := dAtA[iNdEx] 4489 iNdEx++ 4490 packedLen |= int(b&0x7F) << shift 4491 if b < 0x80 { 4492 break 4493 } 4494 } 4495 if packedLen < 0 { 4496 return ErrInvalidLengthStorageCommon 4497 } 4498 postIndex := iNdEx + packedLen 4499 if postIndex < 0 { 4500 return ErrInvalidLengthStorageCommon 4501 } 4502 if postIndex > l { 4503 return io.ErrUnexpectedEOF 4504 } 4505 var elementCount int 4506 var count int 4507 for _, integer := range dAtA[iNdEx:postIndex] { 4508 if integer < 128 { 4509 count++ 4510 } 4511 } 4512 elementCount = count 4513 if elementCount != 0 && len(m.Values) == 0 { 4514 m.Values = make([]uint64, 0, elementCount) 4515 } 4516 for iNdEx < postIndex { 4517 var v uint64 4518 for shift := uint(0); ; shift += 7 { 4519 if shift >= 64 { 4520 return ErrIntOverflowStorageCommon 4521 } 4522 if iNdEx >= l { 4523 return io.ErrUnexpectedEOF 4524 } 4525 b := dAtA[iNdEx] 4526 iNdEx++ 4527 v |= uint64(b&0x7F) << shift 4528 if b < 0x80 { 4529 break 4530 } 4531 } 4532 m.Values = append(m.Values, v) 4533 } 4534 } else { 4535 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 4536 } 4537 default: 4538 iNdEx = preIndex 4539 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 4540 if err != nil { 4541 return err 4542 } 4543 if skippy < 0 { 4544 return ErrInvalidLengthStorageCommon 4545 } 4546 if (iNdEx + skippy) < 0 { 4547 return ErrInvalidLengthStorageCommon 4548 } 4549 if (iNdEx + skippy) > l { 4550 return io.ErrUnexpectedEOF 4551 } 4552 iNdEx += skippy 4553 } 4554 } 4555 4556 if iNdEx > l { 4557 return io.ErrUnexpectedEOF 4558 } 4559 return nil 4560} 4561func (m *ReadResponse_BooleanPointsFrame) Unmarshal(dAtA []byte) error { 4562 l := len(dAtA) 4563 iNdEx := 0 4564 for iNdEx < l { 4565 preIndex := iNdEx 4566 var wire uint64 4567 for shift := uint(0); ; shift += 7 { 4568 if shift >= 64 { 4569 return ErrIntOverflowStorageCommon 4570 } 4571 if iNdEx >= l { 4572 return io.ErrUnexpectedEOF 4573 } 4574 b := dAtA[iNdEx] 4575 iNdEx++ 4576 wire |= uint64(b&0x7F) << shift 4577 if b < 0x80 { 4578 break 4579 } 4580 } 4581 fieldNum := int32(wire >> 3) 4582 wireType := int(wire & 0x7) 4583 if wireType == 4 { 4584 return fmt.Errorf("proto: BooleanPointsFrame: wiretype end group for non-group") 4585 } 4586 if fieldNum <= 0 { 4587 return fmt.Errorf("proto: BooleanPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire) 4588 } 4589 switch fieldNum { 4590 case 1: 4591 if wireType == 1 { 4592 var v int64 4593 if (iNdEx + 8) > l { 4594 return io.ErrUnexpectedEOF 4595 } 4596 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 4597 iNdEx += 8 4598 m.Timestamps = append(m.Timestamps, v) 4599 } else if wireType == 2 { 4600 var packedLen int 4601 for shift := uint(0); ; shift += 7 { 4602 if shift >= 64 { 4603 return ErrIntOverflowStorageCommon 4604 } 4605 if iNdEx >= l { 4606 return io.ErrUnexpectedEOF 4607 } 4608 b := dAtA[iNdEx] 4609 iNdEx++ 4610 packedLen |= int(b&0x7F) << shift 4611 if b < 0x80 { 4612 break 4613 } 4614 } 4615 if packedLen < 0 { 4616 return ErrInvalidLengthStorageCommon 4617 } 4618 postIndex := iNdEx + packedLen 4619 if postIndex < 0 { 4620 return ErrInvalidLengthStorageCommon 4621 } 4622 if postIndex > l { 4623 return io.ErrUnexpectedEOF 4624 } 4625 var elementCount int 4626 elementCount = packedLen / 8 4627 if elementCount != 0 && len(m.Timestamps) == 0 { 4628 m.Timestamps = make([]int64, 0, elementCount) 4629 } 4630 for iNdEx < postIndex { 4631 var v int64 4632 if (iNdEx + 8) > l { 4633 return io.ErrUnexpectedEOF 4634 } 4635 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 4636 iNdEx += 8 4637 m.Timestamps = append(m.Timestamps, v) 4638 } 4639 } else { 4640 return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType) 4641 } 4642 case 2: 4643 if wireType == 0 { 4644 var v int 4645 for shift := uint(0); ; shift += 7 { 4646 if shift >= 64 { 4647 return ErrIntOverflowStorageCommon 4648 } 4649 if iNdEx >= l { 4650 return io.ErrUnexpectedEOF 4651 } 4652 b := dAtA[iNdEx] 4653 iNdEx++ 4654 v |= int(b&0x7F) << shift 4655 if b < 0x80 { 4656 break 4657 } 4658 } 4659 m.Values = append(m.Values, bool(v != 0)) 4660 } else if wireType == 2 { 4661 var packedLen int 4662 for shift := uint(0); ; shift += 7 { 4663 if shift >= 64 { 4664 return ErrIntOverflowStorageCommon 4665 } 4666 if iNdEx >= l { 4667 return io.ErrUnexpectedEOF 4668 } 4669 b := dAtA[iNdEx] 4670 iNdEx++ 4671 packedLen |= int(b&0x7F) << shift 4672 if b < 0x80 { 4673 break 4674 } 4675 } 4676 if packedLen < 0 { 4677 return ErrInvalidLengthStorageCommon 4678 } 4679 postIndex := iNdEx + packedLen 4680 if postIndex < 0 { 4681 return ErrInvalidLengthStorageCommon 4682 } 4683 if postIndex > l { 4684 return io.ErrUnexpectedEOF 4685 } 4686 var elementCount int 4687 elementCount = packedLen 4688 if elementCount != 0 && len(m.Values) == 0 { 4689 m.Values = make([]bool, 0, elementCount) 4690 } 4691 for iNdEx < postIndex { 4692 var v int 4693 for shift := uint(0); ; shift += 7 { 4694 if shift >= 64 { 4695 return ErrIntOverflowStorageCommon 4696 } 4697 if iNdEx >= l { 4698 return io.ErrUnexpectedEOF 4699 } 4700 b := dAtA[iNdEx] 4701 iNdEx++ 4702 v |= int(b&0x7F) << shift 4703 if b < 0x80 { 4704 break 4705 } 4706 } 4707 m.Values = append(m.Values, bool(v != 0)) 4708 } 4709 } else { 4710 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 4711 } 4712 default: 4713 iNdEx = preIndex 4714 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 4715 if err != nil { 4716 return err 4717 } 4718 if skippy < 0 { 4719 return ErrInvalidLengthStorageCommon 4720 } 4721 if (iNdEx + skippy) < 0 { 4722 return ErrInvalidLengthStorageCommon 4723 } 4724 if (iNdEx + skippy) > l { 4725 return io.ErrUnexpectedEOF 4726 } 4727 iNdEx += skippy 4728 } 4729 } 4730 4731 if iNdEx > l { 4732 return io.ErrUnexpectedEOF 4733 } 4734 return nil 4735} 4736func (m *ReadResponse_StringPointsFrame) Unmarshal(dAtA []byte) error { 4737 l := len(dAtA) 4738 iNdEx := 0 4739 for iNdEx < l { 4740 preIndex := iNdEx 4741 var wire uint64 4742 for shift := uint(0); ; shift += 7 { 4743 if shift >= 64 { 4744 return ErrIntOverflowStorageCommon 4745 } 4746 if iNdEx >= l { 4747 return io.ErrUnexpectedEOF 4748 } 4749 b := dAtA[iNdEx] 4750 iNdEx++ 4751 wire |= uint64(b&0x7F) << shift 4752 if b < 0x80 { 4753 break 4754 } 4755 } 4756 fieldNum := int32(wire >> 3) 4757 wireType := int(wire & 0x7) 4758 if wireType == 4 { 4759 return fmt.Errorf("proto: StringPointsFrame: wiretype end group for non-group") 4760 } 4761 if fieldNum <= 0 { 4762 return fmt.Errorf("proto: StringPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire) 4763 } 4764 switch fieldNum { 4765 case 1: 4766 if wireType == 1 { 4767 var v int64 4768 if (iNdEx + 8) > l { 4769 return io.ErrUnexpectedEOF 4770 } 4771 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 4772 iNdEx += 8 4773 m.Timestamps = append(m.Timestamps, v) 4774 } else if wireType == 2 { 4775 var packedLen int 4776 for shift := uint(0); ; shift += 7 { 4777 if shift >= 64 { 4778 return ErrIntOverflowStorageCommon 4779 } 4780 if iNdEx >= l { 4781 return io.ErrUnexpectedEOF 4782 } 4783 b := dAtA[iNdEx] 4784 iNdEx++ 4785 packedLen |= int(b&0x7F) << shift 4786 if b < 0x80 { 4787 break 4788 } 4789 } 4790 if packedLen < 0 { 4791 return ErrInvalidLengthStorageCommon 4792 } 4793 postIndex := iNdEx + packedLen 4794 if postIndex < 0 { 4795 return ErrInvalidLengthStorageCommon 4796 } 4797 if postIndex > l { 4798 return io.ErrUnexpectedEOF 4799 } 4800 var elementCount int 4801 elementCount = packedLen / 8 4802 if elementCount != 0 && len(m.Timestamps) == 0 { 4803 m.Timestamps = make([]int64, 0, elementCount) 4804 } 4805 for iNdEx < postIndex { 4806 var v int64 4807 if (iNdEx + 8) > l { 4808 return io.ErrUnexpectedEOF 4809 } 4810 v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) 4811 iNdEx += 8 4812 m.Timestamps = append(m.Timestamps, v) 4813 } 4814 } else { 4815 return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType) 4816 } 4817 case 2: 4818 if wireType != 2 { 4819 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 4820 } 4821 var stringLen uint64 4822 for shift := uint(0); ; shift += 7 { 4823 if shift >= 64 { 4824 return ErrIntOverflowStorageCommon 4825 } 4826 if iNdEx >= l { 4827 return io.ErrUnexpectedEOF 4828 } 4829 b := dAtA[iNdEx] 4830 iNdEx++ 4831 stringLen |= uint64(b&0x7F) << shift 4832 if b < 0x80 { 4833 break 4834 } 4835 } 4836 intStringLen := int(stringLen) 4837 if intStringLen < 0 { 4838 return ErrInvalidLengthStorageCommon 4839 } 4840 postIndex := iNdEx + intStringLen 4841 if postIndex < 0 { 4842 return ErrInvalidLengthStorageCommon 4843 } 4844 if postIndex > l { 4845 return io.ErrUnexpectedEOF 4846 } 4847 m.Values = append(m.Values, string(dAtA[iNdEx:postIndex])) 4848 iNdEx = postIndex 4849 default: 4850 iNdEx = preIndex 4851 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 4852 if err != nil { 4853 return err 4854 } 4855 if skippy < 0 { 4856 return ErrInvalidLengthStorageCommon 4857 } 4858 if (iNdEx + skippy) < 0 { 4859 return ErrInvalidLengthStorageCommon 4860 } 4861 if (iNdEx + skippy) > l { 4862 return io.ErrUnexpectedEOF 4863 } 4864 iNdEx += skippy 4865 } 4866 } 4867 4868 if iNdEx > l { 4869 return io.ErrUnexpectedEOF 4870 } 4871 return nil 4872} 4873func (m *CapabilitiesResponse) Unmarshal(dAtA []byte) error { 4874 l := len(dAtA) 4875 iNdEx := 0 4876 for iNdEx < l { 4877 preIndex := iNdEx 4878 var wire uint64 4879 for shift := uint(0); ; shift += 7 { 4880 if shift >= 64 { 4881 return ErrIntOverflowStorageCommon 4882 } 4883 if iNdEx >= l { 4884 return io.ErrUnexpectedEOF 4885 } 4886 b := dAtA[iNdEx] 4887 iNdEx++ 4888 wire |= uint64(b&0x7F) << shift 4889 if b < 0x80 { 4890 break 4891 } 4892 } 4893 fieldNum := int32(wire >> 3) 4894 wireType := int(wire & 0x7) 4895 if wireType == 4 { 4896 return fmt.Errorf("proto: CapabilitiesResponse: wiretype end group for non-group") 4897 } 4898 if fieldNum <= 0 { 4899 return fmt.Errorf("proto: CapabilitiesResponse: illegal tag %d (wire type %d)", fieldNum, wire) 4900 } 4901 switch fieldNum { 4902 case 1: 4903 if wireType != 2 { 4904 return fmt.Errorf("proto: wrong wireType = %d for field Caps", wireType) 4905 } 4906 var msglen int 4907 for shift := uint(0); ; shift += 7 { 4908 if shift >= 64 { 4909 return ErrIntOverflowStorageCommon 4910 } 4911 if iNdEx >= l { 4912 return io.ErrUnexpectedEOF 4913 } 4914 b := dAtA[iNdEx] 4915 iNdEx++ 4916 msglen |= int(b&0x7F) << shift 4917 if b < 0x80 { 4918 break 4919 } 4920 } 4921 if msglen < 0 { 4922 return ErrInvalidLengthStorageCommon 4923 } 4924 postIndex := iNdEx + msglen 4925 if postIndex < 0 { 4926 return ErrInvalidLengthStorageCommon 4927 } 4928 if postIndex > l { 4929 return io.ErrUnexpectedEOF 4930 } 4931 if m.Caps == nil { 4932 m.Caps = make(map[string]string) 4933 } 4934 var mapkey string 4935 var mapvalue string 4936 for iNdEx < postIndex { 4937 entryPreIndex := iNdEx 4938 var wire uint64 4939 for shift := uint(0); ; shift += 7 { 4940 if shift >= 64 { 4941 return ErrIntOverflowStorageCommon 4942 } 4943 if iNdEx >= l { 4944 return io.ErrUnexpectedEOF 4945 } 4946 b := dAtA[iNdEx] 4947 iNdEx++ 4948 wire |= uint64(b&0x7F) << shift 4949 if b < 0x80 { 4950 break 4951 } 4952 } 4953 fieldNum := int32(wire >> 3) 4954 if fieldNum == 1 { 4955 var stringLenmapkey uint64 4956 for shift := uint(0); ; shift += 7 { 4957 if shift >= 64 { 4958 return ErrIntOverflowStorageCommon 4959 } 4960 if iNdEx >= l { 4961 return io.ErrUnexpectedEOF 4962 } 4963 b := dAtA[iNdEx] 4964 iNdEx++ 4965 stringLenmapkey |= uint64(b&0x7F) << shift 4966 if b < 0x80 { 4967 break 4968 } 4969 } 4970 intStringLenmapkey := int(stringLenmapkey) 4971 if intStringLenmapkey < 0 { 4972 return ErrInvalidLengthStorageCommon 4973 } 4974 postStringIndexmapkey := iNdEx + intStringLenmapkey 4975 if postStringIndexmapkey < 0 { 4976 return ErrInvalidLengthStorageCommon 4977 } 4978 if postStringIndexmapkey > l { 4979 return io.ErrUnexpectedEOF 4980 } 4981 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 4982 iNdEx = postStringIndexmapkey 4983 } else if fieldNum == 2 { 4984 var stringLenmapvalue uint64 4985 for shift := uint(0); ; shift += 7 { 4986 if shift >= 64 { 4987 return ErrIntOverflowStorageCommon 4988 } 4989 if iNdEx >= l { 4990 return io.ErrUnexpectedEOF 4991 } 4992 b := dAtA[iNdEx] 4993 iNdEx++ 4994 stringLenmapvalue |= uint64(b&0x7F) << shift 4995 if b < 0x80 { 4996 break 4997 } 4998 } 4999 intStringLenmapvalue := int(stringLenmapvalue) 5000 if intStringLenmapvalue < 0 { 5001 return ErrInvalidLengthStorageCommon 5002 } 5003 postStringIndexmapvalue := iNdEx + intStringLenmapvalue 5004 if postStringIndexmapvalue < 0 { 5005 return ErrInvalidLengthStorageCommon 5006 } 5007 if postStringIndexmapvalue > l { 5008 return io.ErrUnexpectedEOF 5009 } 5010 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) 5011 iNdEx = postStringIndexmapvalue 5012 } else { 5013 iNdEx = entryPreIndex 5014 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 5015 if err != nil { 5016 return err 5017 } 5018 if skippy < 0 { 5019 return ErrInvalidLengthStorageCommon 5020 } 5021 if (iNdEx + skippy) > postIndex { 5022 return io.ErrUnexpectedEOF 5023 } 5024 iNdEx += skippy 5025 } 5026 } 5027 m.Caps[mapkey] = mapvalue 5028 iNdEx = postIndex 5029 default: 5030 iNdEx = preIndex 5031 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 5032 if err != nil { 5033 return err 5034 } 5035 if skippy < 0 { 5036 return ErrInvalidLengthStorageCommon 5037 } 5038 if (iNdEx + skippy) < 0 { 5039 return ErrInvalidLengthStorageCommon 5040 } 5041 if (iNdEx + skippy) > l { 5042 return io.ErrUnexpectedEOF 5043 } 5044 iNdEx += skippy 5045 } 5046 } 5047 5048 if iNdEx > l { 5049 return io.ErrUnexpectedEOF 5050 } 5051 return nil 5052} 5053func (m *TimestampRange) Unmarshal(dAtA []byte) error { 5054 l := len(dAtA) 5055 iNdEx := 0 5056 for iNdEx < l { 5057 preIndex := iNdEx 5058 var wire uint64 5059 for shift := uint(0); ; shift += 7 { 5060 if shift >= 64 { 5061 return ErrIntOverflowStorageCommon 5062 } 5063 if iNdEx >= l { 5064 return io.ErrUnexpectedEOF 5065 } 5066 b := dAtA[iNdEx] 5067 iNdEx++ 5068 wire |= uint64(b&0x7F) << shift 5069 if b < 0x80 { 5070 break 5071 } 5072 } 5073 fieldNum := int32(wire >> 3) 5074 wireType := int(wire & 0x7) 5075 if wireType == 4 { 5076 return fmt.Errorf("proto: TimestampRange: wiretype end group for non-group") 5077 } 5078 if fieldNum <= 0 { 5079 return fmt.Errorf("proto: TimestampRange: illegal tag %d (wire type %d)", fieldNum, wire) 5080 } 5081 switch fieldNum { 5082 case 1: 5083 if wireType != 0 { 5084 return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType) 5085 } 5086 m.Start = 0 5087 for shift := uint(0); ; shift += 7 { 5088 if shift >= 64 { 5089 return ErrIntOverflowStorageCommon 5090 } 5091 if iNdEx >= l { 5092 return io.ErrUnexpectedEOF 5093 } 5094 b := dAtA[iNdEx] 5095 iNdEx++ 5096 m.Start |= int64(b&0x7F) << shift 5097 if b < 0x80 { 5098 break 5099 } 5100 } 5101 case 2: 5102 if wireType != 0 { 5103 return fmt.Errorf("proto: wrong wireType = %d for field End", wireType) 5104 } 5105 m.End = 0 5106 for shift := uint(0); ; shift += 7 { 5107 if shift >= 64 { 5108 return ErrIntOverflowStorageCommon 5109 } 5110 if iNdEx >= l { 5111 return io.ErrUnexpectedEOF 5112 } 5113 b := dAtA[iNdEx] 5114 iNdEx++ 5115 m.End |= int64(b&0x7F) << shift 5116 if b < 0x80 { 5117 break 5118 } 5119 } 5120 default: 5121 iNdEx = preIndex 5122 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 5123 if err != nil { 5124 return err 5125 } 5126 if skippy < 0 { 5127 return ErrInvalidLengthStorageCommon 5128 } 5129 if (iNdEx + skippy) < 0 { 5130 return ErrInvalidLengthStorageCommon 5131 } 5132 if (iNdEx + skippy) > l { 5133 return io.ErrUnexpectedEOF 5134 } 5135 iNdEx += skippy 5136 } 5137 } 5138 5139 if iNdEx > l { 5140 return io.ErrUnexpectedEOF 5141 } 5142 return nil 5143} 5144func (m *TagKeysRequest) Unmarshal(dAtA []byte) error { 5145 l := len(dAtA) 5146 iNdEx := 0 5147 for iNdEx < l { 5148 preIndex := iNdEx 5149 var wire uint64 5150 for shift := uint(0); ; shift += 7 { 5151 if shift >= 64 { 5152 return ErrIntOverflowStorageCommon 5153 } 5154 if iNdEx >= l { 5155 return io.ErrUnexpectedEOF 5156 } 5157 b := dAtA[iNdEx] 5158 iNdEx++ 5159 wire |= uint64(b&0x7F) << shift 5160 if b < 0x80 { 5161 break 5162 } 5163 } 5164 fieldNum := int32(wire >> 3) 5165 wireType := int(wire & 0x7) 5166 if wireType == 4 { 5167 return fmt.Errorf("proto: TagKeysRequest: wiretype end group for non-group") 5168 } 5169 if fieldNum <= 0 { 5170 return fmt.Errorf("proto: TagKeysRequest: illegal tag %d (wire type %d)", fieldNum, wire) 5171 } 5172 switch fieldNum { 5173 case 1: 5174 if wireType != 2 { 5175 return fmt.Errorf("proto: wrong wireType = %d for field TagsSource", wireType) 5176 } 5177 var msglen int 5178 for shift := uint(0); ; shift += 7 { 5179 if shift >= 64 { 5180 return ErrIntOverflowStorageCommon 5181 } 5182 if iNdEx >= l { 5183 return io.ErrUnexpectedEOF 5184 } 5185 b := dAtA[iNdEx] 5186 iNdEx++ 5187 msglen |= int(b&0x7F) << shift 5188 if b < 0x80 { 5189 break 5190 } 5191 } 5192 if msglen < 0 { 5193 return ErrInvalidLengthStorageCommon 5194 } 5195 postIndex := iNdEx + msglen 5196 if postIndex < 0 { 5197 return ErrInvalidLengthStorageCommon 5198 } 5199 if postIndex > l { 5200 return io.ErrUnexpectedEOF 5201 } 5202 if m.TagsSource == nil { 5203 m.TagsSource = &types.Any{} 5204 } 5205 if err := m.TagsSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5206 return err 5207 } 5208 iNdEx = postIndex 5209 case 2: 5210 if wireType != 2 { 5211 return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType) 5212 } 5213 var msglen int 5214 for shift := uint(0); ; shift += 7 { 5215 if shift >= 64 { 5216 return ErrIntOverflowStorageCommon 5217 } 5218 if iNdEx >= l { 5219 return io.ErrUnexpectedEOF 5220 } 5221 b := dAtA[iNdEx] 5222 iNdEx++ 5223 msglen |= int(b&0x7F) << shift 5224 if b < 0x80 { 5225 break 5226 } 5227 } 5228 if msglen < 0 { 5229 return ErrInvalidLengthStorageCommon 5230 } 5231 postIndex := iNdEx + msglen 5232 if postIndex < 0 { 5233 return ErrInvalidLengthStorageCommon 5234 } 5235 if postIndex > l { 5236 return io.ErrUnexpectedEOF 5237 } 5238 if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5239 return err 5240 } 5241 iNdEx = postIndex 5242 case 3: 5243 if wireType != 2 { 5244 return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType) 5245 } 5246 var msglen int 5247 for shift := uint(0); ; shift += 7 { 5248 if shift >= 64 { 5249 return ErrIntOverflowStorageCommon 5250 } 5251 if iNdEx >= l { 5252 return io.ErrUnexpectedEOF 5253 } 5254 b := dAtA[iNdEx] 5255 iNdEx++ 5256 msglen |= int(b&0x7F) << shift 5257 if b < 0x80 { 5258 break 5259 } 5260 } 5261 if msglen < 0 { 5262 return ErrInvalidLengthStorageCommon 5263 } 5264 postIndex := iNdEx + msglen 5265 if postIndex < 0 { 5266 return ErrInvalidLengthStorageCommon 5267 } 5268 if postIndex > l { 5269 return io.ErrUnexpectedEOF 5270 } 5271 if m.Predicate == nil { 5272 m.Predicate = &Predicate{} 5273 } 5274 if err := m.Predicate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5275 return err 5276 } 5277 iNdEx = postIndex 5278 default: 5279 iNdEx = preIndex 5280 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 5281 if err != nil { 5282 return err 5283 } 5284 if skippy < 0 { 5285 return ErrInvalidLengthStorageCommon 5286 } 5287 if (iNdEx + skippy) < 0 { 5288 return ErrInvalidLengthStorageCommon 5289 } 5290 if (iNdEx + skippy) > l { 5291 return io.ErrUnexpectedEOF 5292 } 5293 iNdEx += skippy 5294 } 5295 } 5296 5297 if iNdEx > l { 5298 return io.ErrUnexpectedEOF 5299 } 5300 return nil 5301} 5302func (m *TagValuesRequest) Unmarshal(dAtA []byte) error { 5303 l := len(dAtA) 5304 iNdEx := 0 5305 for iNdEx < l { 5306 preIndex := iNdEx 5307 var wire uint64 5308 for shift := uint(0); ; shift += 7 { 5309 if shift >= 64 { 5310 return ErrIntOverflowStorageCommon 5311 } 5312 if iNdEx >= l { 5313 return io.ErrUnexpectedEOF 5314 } 5315 b := dAtA[iNdEx] 5316 iNdEx++ 5317 wire |= uint64(b&0x7F) << shift 5318 if b < 0x80 { 5319 break 5320 } 5321 } 5322 fieldNum := int32(wire >> 3) 5323 wireType := int(wire & 0x7) 5324 if wireType == 4 { 5325 return fmt.Errorf("proto: TagValuesRequest: wiretype end group for non-group") 5326 } 5327 if fieldNum <= 0 { 5328 return fmt.Errorf("proto: TagValuesRequest: illegal tag %d (wire type %d)", fieldNum, wire) 5329 } 5330 switch fieldNum { 5331 case 1: 5332 if wireType != 2 { 5333 return fmt.Errorf("proto: wrong wireType = %d for field TagsSource", wireType) 5334 } 5335 var msglen int 5336 for shift := uint(0); ; shift += 7 { 5337 if shift >= 64 { 5338 return ErrIntOverflowStorageCommon 5339 } 5340 if iNdEx >= l { 5341 return io.ErrUnexpectedEOF 5342 } 5343 b := dAtA[iNdEx] 5344 iNdEx++ 5345 msglen |= int(b&0x7F) << shift 5346 if b < 0x80 { 5347 break 5348 } 5349 } 5350 if msglen < 0 { 5351 return ErrInvalidLengthStorageCommon 5352 } 5353 postIndex := iNdEx + msglen 5354 if postIndex < 0 { 5355 return ErrInvalidLengthStorageCommon 5356 } 5357 if postIndex > l { 5358 return io.ErrUnexpectedEOF 5359 } 5360 if m.TagsSource == nil { 5361 m.TagsSource = &types.Any{} 5362 } 5363 if err := m.TagsSource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5364 return err 5365 } 5366 iNdEx = postIndex 5367 case 2: 5368 if wireType != 2 { 5369 return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType) 5370 } 5371 var msglen int 5372 for shift := uint(0); ; shift += 7 { 5373 if shift >= 64 { 5374 return ErrIntOverflowStorageCommon 5375 } 5376 if iNdEx >= l { 5377 return io.ErrUnexpectedEOF 5378 } 5379 b := dAtA[iNdEx] 5380 iNdEx++ 5381 msglen |= int(b&0x7F) << shift 5382 if b < 0x80 { 5383 break 5384 } 5385 } 5386 if msglen < 0 { 5387 return ErrInvalidLengthStorageCommon 5388 } 5389 postIndex := iNdEx + msglen 5390 if postIndex < 0 { 5391 return ErrInvalidLengthStorageCommon 5392 } 5393 if postIndex > l { 5394 return io.ErrUnexpectedEOF 5395 } 5396 if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5397 return err 5398 } 5399 iNdEx = postIndex 5400 case 3: 5401 if wireType != 2 { 5402 return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType) 5403 } 5404 var msglen int 5405 for shift := uint(0); ; shift += 7 { 5406 if shift >= 64 { 5407 return ErrIntOverflowStorageCommon 5408 } 5409 if iNdEx >= l { 5410 return io.ErrUnexpectedEOF 5411 } 5412 b := dAtA[iNdEx] 5413 iNdEx++ 5414 msglen |= int(b&0x7F) << shift 5415 if b < 0x80 { 5416 break 5417 } 5418 } 5419 if msglen < 0 { 5420 return ErrInvalidLengthStorageCommon 5421 } 5422 postIndex := iNdEx + msglen 5423 if postIndex < 0 { 5424 return ErrInvalidLengthStorageCommon 5425 } 5426 if postIndex > l { 5427 return io.ErrUnexpectedEOF 5428 } 5429 if m.Predicate == nil { 5430 m.Predicate = &Predicate{} 5431 } 5432 if err := m.Predicate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5433 return err 5434 } 5435 iNdEx = postIndex 5436 case 4: 5437 if wireType != 2 { 5438 return fmt.Errorf("proto: wrong wireType = %d for field TagKey", wireType) 5439 } 5440 var stringLen uint64 5441 for shift := uint(0); ; shift += 7 { 5442 if shift >= 64 { 5443 return ErrIntOverflowStorageCommon 5444 } 5445 if iNdEx >= l { 5446 return io.ErrUnexpectedEOF 5447 } 5448 b := dAtA[iNdEx] 5449 iNdEx++ 5450 stringLen |= uint64(b&0x7F) << shift 5451 if b < 0x80 { 5452 break 5453 } 5454 } 5455 intStringLen := int(stringLen) 5456 if intStringLen < 0 { 5457 return ErrInvalidLengthStorageCommon 5458 } 5459 postIndex := iNdEx + intStringLen 5460 if postIndex < 0 { 5461 return ErrInvalidLengthStorageCommon 5462 } 5463 if postIndex > l { 5464 return io.ErrUnexpectedEOF 5465 } 5466 m.TagKey = string(dAtA[iNdEx:postIndex]) 5467 iNdEx = postIndex 5468 default: 5469 iNdEx = preIndex 5470 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 5471 if err != nil { 5472 return err 5473 } 5474 if skippy < 0 { 5475 return ErrInvalidLengthStorageCommon 5476 } 5477 if (iNdEx + skippy) < 0 { 5478 return ErrInvalidLengthStorageCommon 5479 } 5480 if (iNdEx + skippy) > l { 5481 return io.ErrUnexpectedEOF 5482 } 5483 iNdEx += skippy 5484 } 5485 } 5486 5487 if iNdEx > l { 5488 return io.ErrUnexpectedEOF 5489 } 5490 return nil 5491} 5492func (m *StringValuesResponse) Unmarshal(dAtA []byte) error { 5493 l := len(dAtA) 5494 iNdEx := 0 5495 for iNdEx < l { 5496 preIndex := iNdEx 5497 var wire uint64 5498 for shift := uint(0); ; shift += 7 { 5499 if shift >= 64 { 5500 return ErrIntOverflowStorageCommon 5501 } 5502 if iNdEx >= l { 5503 return io.ErrUnexpectedEOF 5504 } 5505 b := dAtA[iNdEx] 5506 iNdEx++ 5507 wire |= uint64(b&0x7F) << shift 5508 if b < 0x80 { 5509 break 5510 } 5511 } 5512 fieldNum := int32(wire >> 3) 5513 wireType := int(wire & 0x7) 5514 if wireType == 4 { 5515 return fmt.Errorf("proto: StringValuesResponse: wiretype end group for non-group") 5516 } 5517 if fieldNum <= 0 { 5518 return fmt.Errorf("proto: StringValuesResponse: illegal tag %d (wire type %d)", fieldNum, wire) 5519 } 5520 switch fieldNum { 5521 case 1: 5522 if wireType != 2 { 5523 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 5524 } 5525 var byteLen int 5526 for shift := uint(0); ; shift += 7 { 5527 if shift >= 64 { 5528 return ErrIntOverflowStorageCommon 5529 } 5530 if iNdEx >= l { 5531 return io.ErrUnexpectedEOF 5532 } 5533 b := dAtA[iNdEx] 5534 iNdEx++ 5535 byteLen |= int(b&0x7F) << shift 5536 if b < 0x80 { 5537 break 5538 } 5539 } 5540 if byteLen < 0 { 5541 return ErrInvalidLengthStorageCommon 5542 } 5543 postIndex := iNdEx + byteLen 5544 if postIndex < 0 { 5545 return ErrInvalidLengthStorageCommon 5546 } 5547 if postIndex > l { 5548 return io.ErrUnexpectedEOF 5549 } 5550 m.Values = append(m.Values, make([]byte, postIndex-iNdEx)) 5551 copy(m.Values[len(m.Values)-1], dAtA[iNdEx:postIndex]) 5552 iNdEx = postIndex 5553 default: 5554 iNdEx = preIndex 5555 skippy, err := skipStorageCommon(dAtA[iNdEx:]) 5556 if err != nil { 5557 return err 5558 } 5559 if skippy < 0 { 5560 return ErrInvalidLengthStorageCommon 5561 } 5562 if (iNdEx + skippy) < 0 { 5563 return ErrInvalidLengthStorageCommon 5564 } 5565 if (iNdEx + skippy) > l { 5566 return io.ErrUnexpectedEOF 5567 } 5568 iNdEx += skippy 5569 } 5570 } 5571 5572 if iNdEx > l { 5573 return io.ErrUnexpectedEOF 5574 } 5575 return nil 5576} 5577func skipStorageCommon(dAtA []byte) (n int, err error) { 5578 l := len(dAtA) 5579 iNdEx := 0 5580 for iNdEx < l { 5581 var wire uint64 5582 for shift := uint(0); ; shift += 7 { 5583 if shift >= 64 { 5584 return 0, ErrIntOverflowStorageCommon 5585 } 5586 if iNdEx >= l { 5587 return 0, io.ErrUnexpectedEOF 5588 } 5589 b := dAtA[iNdEx] 5590 iNdEx++ 5591 wire |= (uint64(b) & 0x7F) << shift 5592 if b < 0x80 { 5593 break 5594 } 5595 } 5596 wireType := int(wire & 0x7) 5597 switch wireType { 5598 case 0: 5599 for shift := uint(0); ; shift += 7 { 5600 if shift >= 64 { 5601 return 0, ErrIntOverflowStorageCommon 5602 } 5603 if iNdEx >= l { 5604 return 0, io.ErrUnexpectedEOF 5605 } 5606 iNdEx++ 5607 if dAtA[iNdEx-1] < 0x80 { 5608 break 5609 } 5610 } 5611 return iNdEx, nil 5612 case 1: 5613 iNdEx += 8 5614 return iNdEx, nil 5615 case 2: 5616 var length int 5617 for shift := uint(0); ; shift += 7 { 5618 if shift >= 64 { 5619 return 0, ErrIntOverflowStorageCommon 5620 } 5621 if iNdEx >= l { 5622 return 0, io.ErrUnexpectedEOF 5623 } 5624 b := dAtA[iNdEx] 5625 iNdEx++ 5626 length |= (int(b) & 0x7F) << shift 5627 if b < 0x80 { 5628 break 5629 } 5630 } 5631 if length < 0 { 5632 return 0, ErrInvalidLengthStorageCommon 5633 } 5634 iNdEx += length 5635 if iNdEx < 0 { 5636 return 0, ErrInvalidLengthStorageCommon 5637 } 5638 return iNdEx, nil 5639 case 3: 5640 for { 5641 var innerWire uint64 5642 var start int = iNdEx 5643 for shift := uint(0); ; shift += 7 { 5644 if shift >= 64 { 5645 return 0, ErrIntOverflowStorageCommon 5646 } 5647 if iNdEx >= l { 5648 return 0, io.ErrUnexpectedEOF 5649 } 5650 b := dAtA[iNdEx] 5651 iNdEx++ 5652 innerWire |= (uint64(b) & 0x7F) << shift 5653 if b < 0x80 { 5654 break 5655 } 5656 } 5657 innerWireType := int(innerWire & 0x7) 5658 if innerWireType == 4 { 5659 break 5660 } 5661 next, err := skipStorageCommon(dAtA[start:]) 5662 if err != nil { 5663 return 0, err 5664 } 5665 iNdEx = start + next 5666 if iNdEx < 0 { 5667 return 0, ErrInvalidLengthStorageCommon 5668 } 5669 } 5670 return iNdEx, nil 5671 case 4: 5672 return iNdEx, nil 5673 case 5: 5674 iNdEx += 4 5675 return iNdEx, nil 5676 default: 5677 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 5678 } 5679 } 5680 panic("unreachable") 5681} 5682 5683var ( 5684 ErrInvalidLengthStorageCommon = fmt.Errorf("proto: negative length found during unmarshaling") 5685 ErrIntOverflowStorageCommon = fmt.Errorf("proto: integer overflow") 5686) 5687