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