mirror of https://github.com/prometheus/prometheus
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4440 lines
107 KiB
4440 lines
107 KiB
// Code generated by protoc-gen-gogo. DO NOT EDIT. |
|
// source: types.proto |
|
|
|
package prompb |
|
|
|
import ( |
|
encoding_binary "encoding/binary" |
|
fmt "fmt" |
|
io "io" |
|
math "math" |
|
math_bits "math/bits" |
|
|
|
_ "github.com/gogo/protobuf/gogoproto" |
|
proto "github.com/gogo/protobuf/proto" |
|
) |
|
|
|
// Reference imports to suppress errors if they are not otherwise used. |
|
var _ = proto.Marshal |
|
var _ = fmt.Errorf |
|
var _ = math.Inf |
|
|
|
// This is a compile-time assertion to ensure that this generated file |
|
// is compatible with the proto package it is being compiled against. |
|
// A compilation error at this line likely means your copy of the |
|
// proto package needs to be updated. |
|
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package |
|
|
|
type MetricMetadata_MetricType int32 |
|
|
|
const ( |
|
MetricMetadata_UNKNOWN MetricMetadata_MetricType = 0 |
|
MetricMetadata_COUNTER MetricMetadata_MetricType = 1 |
|
MetricMetadata_GAUGE MetricMetadata_MetricType = 2 |
|
MetricMetadata_HISTOGRAM MetricMetadata_MetricType = 3 |
|
MetricMetadata_GAUGEHISTOGRAM MetricMetadata_MetricType = 4 |
|
MetricMetadata_SUMMARY MetricMetadata_MetricType = 5 |
|
MetricMetadata_INFO MetricMetadata_MetricType = 6 |
|
MetricMetadata_STATESET MetricMetadata_MetricType = 7 |
|
) |
|
|
|
var MetricMetadata_MetricType_name = map[int32]string{ |
|
0: "UNKNOWN", |
|
1: "COUNTER", |
|
2: "GAUGE", |
|
3: "HISTOGRAM", |
|
4: "GAUGEHISTOGRAM", |
|
5: "SUMMARY", |
|
6: "INFO", |
|
7: "STATESET", |
|
} |
|
|
|
var MetricMetadata_MetricType_value = map[string]int32{ |
|
"UNKNOWN": 0, |
|
"COUNTER": 1, |
|
"GAUGE": 2, |
|
"HISTOGRAM": 3, |
|
"GAUGEHISTOGRAM": 4, |
|
"SUMMARY": 5, |
|
"INFO": 6, |
|
"STATESET": 7, |
|
} |
|
|
|
func (x MetricMetadata_MetricType) String() string { |
|
return proto.EnumName(MetricMetadata_MetricType_name, int32(x)) |
|
} |
|
|
|
func (MetricMetadata_MetricType) EnumDescriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{0, 0} |
|
} |
|
|
|
type Histogram_ResetHint int32 |
|
|
|
const ( |
|
Histogram_UNKNOWN Histogram_ResetHint = 0 |
|
Histogram_YES Histogram_ResetHint = 1 |
|
Histogram_NO Histogram_ResetHint = 2 |
|
Histogram_GAUGE Histogram_ResetHint = 3 |
|
) |
|
|
|
var Histogram_ResetHint_name = map[int32]string{ |
|
0: "UNKNOWN", |
|
1: "YES", |
|
2: "NO", |
|
3: "GAUGE", |
|
} |
|
|
|
var Histogram_ResetHint_value = map[string]int32{ |
|
"UNKNOWN": 0, |
|
"YES": 1, |
|
"NO": 2, |
|
"GAUGE": 3, |
|
} |
|
|
|
func (x Histogram_ResetHint) String() string { |
|
return proto.EnumName(Histogram_ResetHint_name, int32(x)) |
|
} |
|
|
|
func (Histogram_ResetHint) EnumDescriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{3, 0} |
|
} |
|
|
|
type LabelMatcher_Type int32 |
|
|
|
const ( |
|
LabelMatcher_EQ LabelMatcher_Type = 0 |
|
LabelMatcher_NEQ LabelMatcher_Type = 1 |
|
LabelMatcher_RE LabelMatcher_Type = 2 |
|
LabelMatcher_NRE LabelMatcher_Type = 3 |
|
) |
|
|
|
var LabelMatcher_Type_name = map[int32]string{ |
|
0: "EQ", |
|
1: "NEQ", |
|
2: "RE", |
|
3: "NRE", |
|
} |
|
|
|
var LabelMatcher_Type_value = map[string]int32{ |
|
"EQ": 0, |
|
"NEQ": 1, |
|
"RE": 2, |
|
"NRE": 3, |
|
} |
|
|
|
func (x LabelMatcher_Type) String() string { |
|
return proto.EnumName(LabelMatcher_Type_name, int32(x)) |
|
} |
|
|
|
func (LabelMatcher_Type) EnumDescriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{8, 0} |
|
} |
|
|
|
// We require this to match chunkenc.Encoding. |
|
type Chunk_Encoding int32 |
|
|
|
const ( |
|
Chunk_UNKNOWN Chunk_Encoding = 0 |
|
Chunk_XOR Chunk_Encoding = 1 |
|
Chunk_HISTOGRAM Chunk_Encoding = 2 |
|
Chunk_FLOAT_HISTOGRAM Chunk_Encoding = 3 |
|
) |
|
|
|
var Chunk_Encoding_name = map[int32]string{ |
|
0: "UNKNOWN", |
|
1: "XOR", |
|
2: "HISTOGRAM", |
|
3: "FLOAT_HISTOGRAM", |
|
} |
|
|
|
var Chunk_Encoding_value = map[string]int32{ |
|
"UNKNOWN": 0, |
|
"XOR": 1, |
|
"HISTOGRAM": 2, |
|
"FLOAT_HISTOGRAM": 3, |
|
} |
|
|
|
func (x Chunk_Encoding) String() string { |
|
return proto.EnumName(Chunk_Encoding_name, int32(x)) |
|
} |
|
|
|
func (Chunk_Encoding) EnumDescriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{10, 0} |
|
} |
|
|
|
type MetricMetadata struct { |
|
// Represents the metric type, these match the set from Prometheus. |
|
// Refer to github.com/prometheus/common/model/metadata.go for details. |
|
Type MetricMetadata_MetricType `protobuf:"varint,1,opt,name=type,proto3,enum=prometheus.MetricMetadata_MetricType" json:"type,omitempty"` |
|
MetricFamilyName string `protobuf:"bytes,2,opt,name=metric_family_name,json=metricFamilyName,proto3" json:"metric_family_name,omitempty"` |
|
Help string `protobuf:"bytes,4,opt,name=help,proto3" json:"help,omitempty"` |
|
Unit string `protobuf:"bytes,5,opt,name=unit,proto3" json:"unit,omitempty"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *MetricMetadata) Reset() { *m = MetricMetadata{} } |
|
func (m *MetricMetadata) String() string { return proto.CompactTextString(m) } |
|
func (*MetricMetadata) ProtoMessage() {} |
|
func (*MetricMetadata) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{0} |
|
} |
|
func (m *MetricMetadata) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *MetricMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_MetricMetadata.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalToSizedBuffer(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (m *MetricMetadata) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_MetricMetadata.Merge(m, src) |
|
} |
|
func (m *MetricMetadata) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *MetricMetadata) XXX_DiscardUnknown() { |
|
xxx_messageInfo_MetricMetadata.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_MetricMetadata proto.InternalMessageInfo |
|
|
|
func (m *MetricMetadata) GetType() MetricMetadata_MetricType { |
|
if m != nil { |
|
return m.Type |
|
} |
|
return MetricMetadata_UNKNOWN |
|
} |
|
|
|
func (m *MetricMetadata) GetMetricFamilyName() string { |
|
if m != nil { |
|
return m.MetricFamilyName |
|
} |
|
return "" |
|
} |
|
|
|
func (m *MetricMetadata) GetHelp() string { |
|
if m != nil { |
|
return m.Help |
|
} |
|
return "" |
|
} |
|
|
|
func (m *MetricMetadata) GetUnit() string { |
|
if m != nil { |
|
return m.Unit |
|
} |
|
return "" |
|
} |
|
|
|
type Sample struct { |
|
Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"` |
|
// timestamp is in ms format, see model/timestamp/timestamp.go for |
|
// conversion from time.Time to Prometheus timestamp. |
|
Timestamp int64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *Sample) Reset() { *m = Sample{} } |
|
func (m *Sample) String() string { return proto.CompactTextString(m) } |
|
func (*Sample) ProtoMessage() {} |
|
func (*Sample) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{1} |
|
} |
|
func (m *Sample) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *Sample) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_Sample.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalToSizedBuffer(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (m *Sample) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_Sample.Merge(m, src) |
|
} |
|
func (m *Sample) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *Sample) XXX_DiscardUnknown() { |
|
xxx_messageInfo_Sample.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_Sample proto.InternalMessageInfo |
|
|
|
func (m *Sample) GetValue() float64 { |
|
if m != nil { |
|
return m.Value |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *Sample) GetTimestamp() int64 { |
|
if m != nil { |
|
return m.Timestamp |
|
} |
|
return 0 |
|
} |
|
|
|
type Exemplar struct { |
|
// Optional, can be empty. |
|
Labels []Label `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"` |
|
Value float64 `protobuf:"fixed64,2,opt,name=value,proto3" json:"value,omitempty"` |
|
// timestamp is in ms format, see model/timestamp/timestamp.go for |
|
// conversion from time.Time to Prometheus timestamp. |
|
Timestamp int64 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *Exemplar) Reset() { *m = Exemplar{} } |
|
func (m *Exemplar) String() string { return proto.CompactTextString(m) } |
|
func (*Exemplar) ProtoMessage() {} |
|
func (*Exemplar) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{2} |
|
} |
|
func (m *Exemplar) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *Exemplar) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_Exemplar.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalToSizedBuffer(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (m *Exemplar) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_Exemplar.Merge(m, src) |
|
} |
|
func (m *Exemplar) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *Exemplar) XXX_DiscardUnknown() { |
|
xxx_messageInfo_Exemplar.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_Exemplar proto.InternalMessageInfo |
|
|
|
func (m *Exemplar) GetLabels() []Label { |
|
if m != nil { |
|
return m.Labels |
|
} |
|
return nil |
|
} |
|
|
|
func (m *Exemplar) GetValue() float64 { |
|
if m != nil { |
|
return m.Value |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *Exemplar) GetTimestamp() int64 { |
|
if m != nil { |
|
return m.Timestamp |
|
} |
|
return 0 |
|
} |
|
|
|
// A native histogram, also known as a sparse histogram. |
|
// Original design doc: |
|
// https://docs.google.com/document/d/1cLNv3aufPZb3fNfaJgdaRBZsInZKKIHo9E6HinJVbpM/edit |
|
// The appendix of this design doc also explains the concept of float |
|
// histograms. This Histogram message can represent both, the usual |
|
// integer histogram as well as a float histogram. |
|
type Histogram struct { |
|
// Types that are valid to be assigned to Count: |
|
// |
|
// *Histogram_CountInt |
|
// *Histogram_CountFloat |
|
Count isHistogram_Count `protobuf_oneof:"count"` |
|
Sum float64 `protobuf:"fixed64,3,opt,name=sum,proto3" json:"sum,omitempty"` |
|
// The schema defines the bucket schema. Currently, valid numbers |
|
// are -4 <= n <= 8. They are all for base-2 bucket schemas, where 1 |
|
// is a bucket boundary in each case, and then each power of two is |
|
// divided into 2^n logarithmic buckets. Or in other words, each |
|
// bucket boundary is the previous boundary times 2^(2^-n). In the |
|
// future, more bucket schemas may be added using numbers < -4 or > |
|
// 8. |
|
Schema int32 `protobuf:"zigzag32,4,opt,name=schema,proto3" json:"schema,omitempty"` |
|
ZeroThreshold float64 `protobuf:"fixed64,5,opt,name=zero_threshold,json=zeroThreshold,proto3" json:"zero_threshold,omitempty"` |
|
// Types that are valid to be assigned to ZeroCount: |
|
// |
|
// *Histogram_ZeroCountInt |
|
// *Histogram_ZeroCountFloat |
|
ZeroCount isHistogram_ZeroCount `protobuf_oneof:"zero_count"` |
|
// Negative Buckets. |
|
NegativeSpans []BucketSpan `protobuf:"bytes,8,rep,name=negative_spans,json=negativeSpans,proto3" json:"negative_spans"` |
|
// Use either "negative_deltas" or "negative_counts", the former for |
|
// regular histograms with integer counts, the latter for float |
|
// histograms. |
|
NegativeDeltas []int64 `protobuf:"zigzag64,9,rep,packed,name=negative_deltas,json=negativeDeltas,proto3" json:"negative_deltas,omitempty"` |
|
NegativeCounts []float64 `protobuf:"fixed64,10,rep,packed,name=negative_counts,json=negativeCounts,proto3" json:"negative_counts,omitempty"` |
|
// Positive Buckets. |
|
PositiveSpans []BucketSpan `protobuf:"bytes,11,rep,name=positive_spans,json=positiveSpans,proto3" json:"positive_spans"` |
|
// Use either "positive_deltas" or "positive_counts", the former for |
|
// regular histograms with integer counts, the latter for float |
|
// histograms. |
|
PositiveDeltas []int64 `protobuf:"zigzag64,12,rep,packed,name=positive_deltas,json=positiveDeltas,proto3" json:"positive_deltas,omitempty"` |
|
PositiveCounts []float64 `protobuf:"fixed64,13,rep,packed,name=positive_counts,json=positiveCounts,proto3" json:"positive_counts,omitempty"` |
|
ResetHint Histogram_ResetHint `protobuf:"varint,14,opt,name=reset_hint,json=resetHint,proto3,enum=prometheus.Histogram_ResetHint" json:"reset_hint,omitempty"` |
|
// timestamp is in ms format, see model/timestamp/timestamp.go for |
|
// conversion from time.Time to Prometheus timestamp. |
|
Timestamp int64 `protobuf:"varint,15,opt,name=timestamp,proto3" json:"timestamp,omitempty"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *Histogram) Reset() { *m = Histogram{} } |
|
func (m *Histogram) String() string { return proto.CompactTextString(m) } |
|
func (*Histogram) ProtoMessage() {} |
|
func (*Histogram) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{3} |
|
} |
|
func (m *Histogram) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *Histogram) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_Histogram.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalToSizedBuffer(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (m *Histogram) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_Histogram.Merge(m, src) |
|
} |
|
func (m *Histogram) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *Histogram) XXX_DiscardUnknown() { |
|
xxx_messageInfo_Histogram.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_Histogram proto.InternalMessageInfo |
|
|
|
type isHistogram_Count interface { |
|
isHistogram_Count() |
|
MarshalTo([]byte) (int, error) |
|
Size() int |
|
} |
|
type isHistogram_ZeroCount interface { |
|
isHistogram_ZeroCount() |
|
MarshalTo([]byte) (int, error) |
|
Size() int |
|
} |
|
|
|
type Histogram_CountInt struct { |
|
CountInt uint64 `protobuf:"varint,1,opt,name=count_int,json=countInt,proto3,oneof" json:"count_int,omitempty"` |
|
} |
|
type Histogram_CountFloat struct { |
|
CountFloat float64 `protobuf:"fixed64,2,opt,name=count_float,json=countFloat,proto3,oneof" json:"count_float,omitempty"` |
|
} |
|
type Histogram_ZeroCountInt struct { |
|
ZeroCountInt uint64 `protobuf:"varint,6,opt,name=zero_count_int,json=zeroCountInt,proto3,oneof" json:"zero_count_int,omitempty"` |
|
} |
|
type Histogram_ZeroCountFloat struct { |
|
ZeroCountFloat float64 `protobuf:"fixed64,7,opt,name=zero_count_float,json=zeroCountFloat,proto3,oneof" json:"zero_count_float,omitempty"` |
|
} |
|
|
|
func (*Histogram_CountInt) isHistogram_Count() {} |
|
func (*Histogram_CountFloat) isHistogram_Count() {} |
|
func (*Histogram_ZeroCountInt) isHistogram_ZeroCount() {} |
|
func (*Histogram_ZeroCountFloat) isHistogram_ZeroCount() {} |
|
|
|
func (m *Histogram) GetCount() isHistogram_Count { |
|
if m != nil { |
|
return m.Count |
|
} |
|
return nil |
|
} |
|
func (m *Histogram) GetZeroCount() isHistogram_ZeroCount { |
|
if m != nil { |
|
return m.ZeroCount |
|
} |
|
return nil |
|
} |
|
|
|
func (m *Histogram) GetCountInt() uint64 { |
|
if x, ok := m.GetCount().(*Histogram_CountInt); ok { |
|
return x.CountInt |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *Histogram) GetCountFloat() float64 { |
|
if x, ok := m.GetCount().(*Histogram_CountFloat); ok { |
|
return x.CountFloat |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *Histogram) GetSum() float64 { |
|
if m != nil { |
|
return m.Sum |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *Histogram) GetSchema() int32 { |
|
if m != nil { |
|
return m.Schema |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *Histogram) GetZeroThreshold() float64 { |
|
if m != nil { |
|
return m.ZeroThreshold |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *Histogram) GetZeroCountInt() uint64 { |
|
if x, ok := m.GetZeroCount().(*Histogram_ZeroCountInt); ok { |
|
return x.ZeroCountInt |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *Histogram) GetZeroCountFloat() float64 { |
|
if x, ok := m.GetZeroCount().(*Histogram_ZeroCountFloat); ok { |
|
return x.ZeroCountFloat |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *Histogram) GetNegativeSpans() []BucketSpan { |
|
if m != nil { |
|
return m.NegativeSpans |
|
} |
|
return nil |
|
} |
|
|
|
func (m *Histogram) GetNegativeDeltas() []int64 { |
|
if m != nil { |
|
return m.NegativeDeltas |
|
} |
|
return nil |
|
} |
|
|
|
func (m *Histogram) GetNegativeCounts() []float64 { |
|
if m != nil { |
|
return m.NegativeCounts |
|
} |
|
return nil |
|
} |
|
|
|
func (m *Histogram) GetPositiveSpans() []BucketSpan { |
|
if m != nil { |
|
return m.PositiveSpans |
|
} |
|
return nil |
|
} |
|
|
|
func (m *Histogram) GetPositiveDeltas() []int64 { |
|
if m != nil { |
|
return m.PositiveDeltas |
|
} |
|
return nil |
|
} |
|
|
|
func (m *Histogram) GetPositiveCounts() []float64 { |
|
if m != nil { |
|
return m.PositiveCounts |
|
} |
|
return nil |
|
} |
|
|
|
func (m *Histogram) GetResetHint() Histogram_ResetHint { |
|
if m != nil { |
|
return m.ResetHint |
|
} |
|
return Histogram_UNKNOWN |
|
} |
|
|
|
func (m *Histogram) GetTimestamp() int64 { |
|
if m != nil { |
|
return m.Timestamp |
|
} |
|
return 0 |
|
} |
|
|
|
// XXX_OneofWrappers is for the internal use of the proto package. |
|
func (*Histogram) XXX_OneofWrappers() []interface{} { |
|
return []interface{}{ |
|
(*Histogram_CountInt)(nil), |
|
(*Histogram_CountFloat)(nil), |
|
(*Histogram_ZeroCountInt)(nil), |
|
(*Histogram_ZeroCountFloat)(nil), |
|
} |
|
} |
|
|
|
// A BucketSpan defines a number of consecutive buckets with their |
|
// offset. Logically, it would be more straightforward to include the |
|
// bucket counts in the Span. However, the protobuf representation is |
|
// more compact in the way the data is structured here (with all the |
|
// buckets in a single array separate from the Spans). |
|
type BucketSpan struct { |
|
Offset int32 `protobuf:"zigzag32,1,opt,name=offset,proto3" json:"offset,omitempty"` |
|
Length uint32 `protobuf:"varint,2,opt,name=length,proto3" json:"length,omitempty"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *BucketSpan) Reset() { *m = BucketSpan{} } |
|
func (m *BucketSpan) String() string { return proto.CompactTextString(m) } |
|
func (*BucketSpan) ProtoMessage() {} |
|
func (*BucketSpan) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{4} |
|
} |
|
func (m *BucketSpan) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *BucketSpan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_BucketSpan.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalToSizedBuffer(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (m *BucketSpan) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_BucketSpan.Merge(m, src) |
|
} |
|
func (m *BucketSpan) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *BucketSpan) XXX_DiscardUnknown() { |
|
xxx_messageInfo_BucketSpan.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_BucketSpan proto.InternalMessageInfo |
|
|
|
func (m *BucketSpan) GetOffset() int32 { |
|
if m != nil { |
|
return m.Offset |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *BucketSpan) GetLength() uint32 { |
|
if m != nil { |
|
return m.Length |
|
} |
|
return 0 |
|
} |
|
|
|
// TimeSeries represents samples and labels for a single time series. |
|
type TimeSeries struct { |
|
// For a timeseries to be valid, and for the samples and exemplars |
|
// to be ingested by the remote system properly, the labels field is required. |
|
Labels []Label `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"` |
|
Samples []Sample `protobuf:"bytes,2,rep,name=samples,proto3" json:"samples"` |
|
Exemplars []Exemplar `protobuf:"bytes,3,rep,name=exemplars,proto3" json:"exemplars"` |
|
Histograms []Histogram `protobuf:"bytes,4,rep,name=histograms,proto3" json:"histograms"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *TimeSeries) Reset() { *m = TimeSeries{} } |
|
func (m *TimeSeries) String() string { return proto.CompactTextString(m) } |
|
func (*TimeSeries) ProtoMessage() {} |
|
func (*TimeSeries) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{5} |
|
} |
|
func (m *TimeSeries) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *TimeSeries) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_TimeSeries.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalToSizedBuffer(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (m *TimeSeries) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_TimeSeries.Merge(m, src) |
|
} |
|
func (m *TimeSeries) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *TimeSeries) XXX_DiscardUnknown() { |
|
xxx_messageInfo_TimeSeries.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_TimeSeries proto.InternalMessageInfo |
|
|
|
func (m *TimeSeries) GetLabels() []Label { |
|
if m != nil { |
|
return m.Labels |
|
} |
|
return nil |
|
} |
|
|
|
func (m *TimeSeries) GetSamples() []Sample { |
|
if m != nil { |
|
return m.Samples |
|
} |
|
return nil |
|
} |
|
|
|
func (m *TimeSeries) GetExemplars() []Exemplar { |
|
if m != nil { |
|
return m.Exemplars |
|
} |
|
return nil |
|
} |
|
|
|
func (m *TimeSeries) GetHistograms() []Histogram { |
|
if m != nil { |
|
return m.Histograms |
|
} |
|
return nil |
|
} |
|
|
|
type Label struct { |
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` |
|
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *Label) Reset() { *m = Label{} } |
|
func (m *Label) String() string { return proto.CompactTextString(m) } |
|
func (*Label) ProtoMessage() {} |
|
func (*Label) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{6} |
|
} |
|
func (m *Label) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *Label) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_Label.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalToSizedBuffer(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (m *Label) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_Label.Merge(m, src) |
|
} |
|
func (m *Label) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *Label) XXX_DiscardUnknown() { |
|
xxx_messageInfo_Label.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_Label proto.InternalMessageInfo |
|
|
|
func (m *Label) GetName() string { |
|
if m != nil { |
|
return m.Name |
|
} |
|
return "" |
|
} |
|
|
|
func (m *Label) GetValue() string { |
|
if m != nil { |
|
return m.Value |
|
} |
|
return "" |
|
} |
|
|
|
type Labels struct { |
|
Labels []Label `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *Labels) Reset() { *m = Labels{} } |
|
func (m *Labels) String() string { return proto.CompactTextString(m) } |
|
func (*Labels) ProtoMessage() {} |
|
func (*Labels) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{7} |
|
} |
|
func (m *Labels) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *Labels) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_Labels.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalToSizedBuffer(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (m *Labels) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_Labels.Merge(m, src) |
|
} |
|
func (m *Labels) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *Labels) XXX_DiscardUnknown() { |
|
xxx_messageInfo_Labels.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_Labels proto.InternalMessageInfo |
|
|
|
func (m *Labels) GetLabels() []Label { |
|
if m != nil { |
|
return m.Labels |
|
} |
|
return nil |
|
} |
|
|
|
// Matcher specifies a rule, which can match or set of labels or not. |
|
type LabelMatcher struct { |
|
Type LabelMatcher_Type `protobuf:"varint,1,opt,name=type,proto3,enum=prometheus.LabelMatcher_Type" json:"type,omitempty"` |
|
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` |
|
Value string `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *LabelMatcher) Reset() { *m = LabelMatcher{} } |
|
func (m *LabelMatcher) String() string { return proto.CompactTextString(m) } |
|
func (*LabelMatcher) ProtoMessage() {} |
|
func (*LabelMatcher) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{8} |
|
} |
|
func (m *LabelMatcher) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *LabelMatcher) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_LabelMatcher.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalToSizedBuffer(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (m *LabelMatcher) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_LabelMatcher.Merge(m, src) |
|
} |
|
func (m *LabelMatcher) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *LabelMatcher) XXX_DiscardUnknown() { |
|
xxx_messageInfo_LabelMatcher.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_LabelMatcher proto.InternalMessageInfo |
|
|
|
func (m *LabelMatcher) GetType() LabelMatcher_Type { |
|
if m != nil { |
|
return m.Type |
|
} |
|
return LabelMatcher_EQ |
|
} |
|
|
|
func (m *LabelMatcher) GetName() string { |
|
if m != nil { |
|
return m.Name |
|
} |
|
return "" |
|
} |
|
|
|
func (m *LabelMatcher) GetValue() string { |
|
if m != nil { |
|
return m.Value |
|
} |
|
return "" |
|
} |
|
|
|
type ReadHints struct { |
|
StepMs int64 `protobuf:"varint,1,opt,name=step_ms,json=stepMs,proto3" json:"step_ms,omitempty"` |
|
Func string `protobuf:"bytes,2,opt,name=func,proto3" json:"func,omitempty"` |
|
StartMs int64 `protobuf:"varint,3,opt,name=start_ms,json=startMs,proto3" json:"start_ms,omitempty"` |
|
EndMs int64 `protobuf:"varint,4,opt,name=end_ms,json=endMs,proto3" json:"end_ms,omitempty"` |
|
Grouping []string `protobuf:"bytes,5,rep,name=grouping,proto3" json:"grouping,omitempty"` |
|
By bool `protobuf:"varint,6,opt,name=by,proto3" json:"by,omitempty"` |
|
RangeMs int64 `protobuf:"varint,7,opt,name=range_ms,json=rangeMs,proto3" json:"range_ms,omitempty"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *ReadHints) Reset() { *m = ReadHints{} } |
|
func (m *ReadHints) String() string { return proto.CompactTextString(m) } |
|
func (*ReadHints) ProtoMessage() {} |
|
func (*ReadHints) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{9} |
|
} |
|
func (m *ReadHints) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *ReadHints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_ReadHints.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalToSizedBuffer(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (m *ReadHints) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_ReadHints.Merge(m, src) |
|
} |
|
func (m *ReadHints) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *ReadHints) XXX_DiscardUnknown() { |
|
xxx_messageInfo_ReadHints.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_ReadHints proto.InternalMessageInfo |
|
|
|
func (m *ReadHints) GetStepMs() int64 { |
|
if m != nil { |
|
return m.StepMs |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ReadHints) GetFunc() string { |
|
if m != nil { |
|
return m.Func |
|
} |
|
return "" |
|
} |
|
|
|
func (m *ReadHints) GetStartMs() int64 { |
|
if m != nil { |
|
return m.StartMs |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ReadHints) GetEndMs() int64 { |
|
if m != nil { |
|
return m.EndMs |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ReadHints) GetGrouping() []string { |
|
if m != nil { |
|
return m.Grouping |
|
} |
|
return nil |
|
} |
|
|
|
func (m *ReadHints) GetBy() bool { |
|
if m != nil { |
|
return m.By |
|
} |
|
return false |
|
} |
|
|
|
func (m *ReadHints) GetRangeMs() int64 { |
|
if m != nil { |
|
return m.RangeMs |
|
} |
|
return 0 |
|
} |
|
|
|
// Chunk represents a TSDB chunk. |
|
// Time range [min, max] is inclusive. |
|
type Chunk struct { |
|
MinTimeMs int64 `protobuf:"varint,1,opt,name=min_time_ms,json=minTimeMs,proto3" json:"min_time_ms,omitempty"` |
|
MaxTimeMs int64 `protobuf:"varint,2,opt,name=max_time_ms,json=maxTimeMs,proto3" json:"max_time_ms,omitempty"` |
|
Type Chunk_Encoding `protobuf:"varint,3,opt,name=type,proto3,enum=prometheus.Chunk_Encoding" json:"type,omitempty"` |
|
Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *Chunk) Reset() { *m = Chunk{} } |
|
func (m *Chunk) String() string { return proto.CompactTextString(m) } |
|
func (*Chunk) ProtoMessage() {} |
|
func (*Chunk) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{10} |
|
} |
|
func (m *Chunk) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *Chunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_Chunk.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalToSizedBuffer(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (m *Chunk) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_Chunk.Merge(m, src) |
|
} |
|
func (m *Chunk) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *Chunk) XXX_DiscardUnknown() { |
|
xxx_messageInfo_Chunk.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_Chunk proto.InternalMessageInfo |
|
|
|
func (m *Chunk) GetMinTimeMs() int64 { |
|
if m != nil { |
|
return m.MinTimeMs |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *Chunk) GetMaxTimeMs() int64 { |
|
if m != nil { |
|
return m.MaxTimeMs |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *Chunk) GetType() Chunk_Encoding { |
|
if m != nil { |
|
return m.Type |
|
} |
|
return Chunk_UNKNOWN |
|
} |
|
|
|
func (m *Chunk) GetData() []byte { |
|
if m != nil { |
|
return m.Data |
|
} |
|
return nil |
|
} |
|
|
|
// ChunkedSeries represents single, encoded time series. |
|
type ChunkedSeries struct { |
|
// Labels should be sorted. |
|
Labels []Label `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"` |
|
// Chunks will be in start time order and may overlap. |
|
Chunks []Chunk `protobuf:"bytes,2,rep,name=chunks,proto3" json:"chunks"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *ChunkedSeries) Reset() { *m = ChunkedSeries{} } |
|
func (m *ChunkedSeries) String() string { return proto.CompactTextString(m) } |
|
func (*ChunkedSeries) ProtoMessage() {} |
|
func (*ChunkedSeries) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_d938547f84707355, []int{11} |
|
} |
|
func (m *ChunkedSeries) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *ChunkedSeries) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_ChunkedSeries.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalToSizedBuffer(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (m *ChunkedSeries) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_ChunkedSeries.Merge(m, src) |
|
} |
|
func (m *ChunkedSeries) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *ChunkedSeries) XXX_DiscardUnknown() { |
|
xxx_messageInfo_ChunkedSeries.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_ChunkedSeries proto.InternalMessageInfo |
|
|
|
func (m *ChunkedSeries) GetLabels() []Label { |
|
if m != nil { |
|
return m.Labels |
|
} |
|
return nil |
|
} |
|
|
|
func (m *ChunkedSeries) GetChunks() []Chunk { |
|
if m != nil { |
|
return m.Chunks |
|
} |
|
return nil |
|
} |
|
|
|
func init() { |
|
proto.RegisterEnum("prometheus.MetricMetadata_MetricType", MetricMetadata_MetricType_name, MetricMetadata_MetricType_value) |
|
proto.RegisterEnum("prometheus.Histogram_ResetHint", Histogram_ResetHint_name, Histogram_ResetHint_value) |
|
proto.RegisterEnum("prometheus.LabelMatcher_Type", LabelMatcher_Type_name, LabelMatcher_Type_value) |
|
proto.RegisterEnum("prometheus.Chunk_Encoding", Chunk_Encoding_name, Chunk_Encoding_value) |
|
proto.RegisterType((*MetricMetadata)(nil), "prometheus.MetricMetadata") |
|
proto.RegisterType((*Sample)(nil), "prometheus.Sample") |
|
proto.RegisterType((*Exemplar)(nil), "prometheus.Exemplar") |
|
proto.RegisterType((*Histogram)(nil), "prometheus.Histogram") |
|
proto.RegisterType((*BucketSpan)(nil), "prometheus.BucketSpan") |
|
proto.RegisterType((*TimeSeries)(nil), "prometheus.TimeSeries") |
|
proto.RegisterType((*Label)(nil), "prometheus.Label") |
|
proto.RegisterType((*Labels)(nil), "prometheus.Labels") |
|
proto.RegisterType((*LabelMatcher)(nil), "prometheus.LabelMatcher") |
|
proto.RegisterType((*ReadHints)(nil), "prometheus.ReadHints") |
|
proto.RegisterType((*Chunk)(nil), "prometheus.Chunk") |
|
proto.RegisterType((*ChunkedSeries)(nil), "prometheus.ChunkedSeries") |
|
} |
|
|
|
func init() { proto.RegisterFile("types.proto", fileDescriptor_d938547f84707355) } |
|
|
|
var fileDescriptor_d938547f84707355 = []byte{ |
|
// 1092 bytes of a gzipped FileDescriptorProto |
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xdb, 0x6e, 0xdb, 0x46, |
|
0x13, 0x36, 0x49, 0x89, 0x12, 0x47, 0x87, 0xd0, 0xfb, 0x3b, 0xf9, 0x59, 0xa3, 0x71, 0x54, 0x02, |
|
0x69, 0x85, 0xa2, 0x90, 0x11, 0xb7, 0x17, 0x0d, 0x1a, 0x14, 0xb0, 0x1d, 0xf9, 0x80, 0x5a, 0x12, |
|
0xb2, 0x92, 0xd1, 0xa6, 0x37, 0xc2, 0x5a, 0x5a, 0x4b, 0x44, 0xc4, 0x43, 0xb9, 0xab, 0xc0, 0xea, |
|
0x7b, 0xf4, 0xae, 0x2f, 0xd1, 0xb7, 0x08, 0xd0, 0x9b, 0xf6, 0x05, 0x8a, 0xc2, 0x57, 0x7d, 0x8c, |
|
0x62, 0x87, 0xa4, 0x48, 0xc5, 0x29, 0xd0, 0xf4, 0x6e, 0xe7, 0x9b, 0x6f, 0x76, 0x3e, 0xee, 0xce, |
|
0xcc, 0x12, 0x6a, 0x72, 0x15, 0x71, 0xd1, 0x89, 0xe2, 0x50, 0x86, 0x04, 0xa2, 0x38, 0xf4, 0xb9, |
|
0x9c, 0xf3, 0xa5, 0xd8, 0xdd, 0x99, 0x85, 0xb3, 0x10, 0xe1, 0x7d, 0xb5, 0x4a, 0x18, 0xee, 0xcf, |
|
0x3a, 0x34, 0x7b, 0x5c, 0xc6, 0xde, 0xa4, 0xc7, 0x25, 0x9b, 0x32, 0xc9, 0xc8, 0x53, 0x28, 0xa9, |
|
0x3d, 0x1c, 0xad, 0xa5, 0xb5, 0x9b, 0x07, 0x8f, 0x3b, 0xf9, 0x1e, 0x9d, 0x4d, 0x66, 0x6a, 0x8e, |
|
0x56, 0x11, 0xa7, 0x18, 0x42, 0x3e, 0x03, 0xe2, 0x23, 0x36, 0xbe, 0x66, 0xbe, 0xb7, 0x58, 0x8d, |
|
0x03, 0xe6, 0x73, 0x47, 0x6f, 0x69, 0x6d, 0x8b, 0xda, 0x89, 0xe7, 0x04, 0x1d, 0x7d, 0xe6, 0x73, |
|
0x42, 0xa0, 0x34, 0xe7, 0x8b, 0xc8, 0x29, 0xa1, 0x1f, 0xd7, 0x0a, 0x5b, 0x06, 0x9e, 0x74, 0xca, |
|
0x09, 0xa6, 0xd6, 0xee, 0x0a, 0x20, 0xcf, 0x44, 0x6a, 0x50, 0xb9, 0xec, 0x7f, 0xd3, 0x1f, 0x7c, |
|
0xdb, 0xb7, 0xb7, 0x94, 0x71, 0x3c, 0xb8, 0xec, 0x8f, 0xba, 0xd4, 0xd6, 0x88, 0x05, 0xe5, 0xd3, |
|
0xc3, 0xcb, 0xd3, 0xae, 0xad, 0x93, 0x06, 0x58, 0x67, 0xe7, 0xc3, 0xd1, 0xe0, 0x94, 0x1e, 0xf6, |
|
0x6c, 0x83, 0x10, 0x68, 0xa2, 0x27, 0xc7, 0x4a, 0x2a, 0x74, 0x78, 0xd9, 0xeb, 0x1d, 0xd2, 0x97, |
|
0x76, 0x99, 0x54, 0xa1, 0x74, 0xde, 0x3f, 0x19, 0xd8, 0x26, 0xa9, 0x43, 0x75, 0x38, 0x3a, 0x1c, |
|
0x75, 0x87, 0xdd, 0x91, 0x5d, 0x71, 0x9f, 0x81, 0x39, 0x64, 0x7e, 0xb4, 0xe0, 0x64, 0x07, 0xca, |
|
0xaf, 0xd9, 0x62, 0x99, 0x1c, 0x8b, 0x46, 0x13, 0x83, 0x7c, 0x08, 0x96, 0xf4, 0x7c, 0x2e, 0x24, |
|
0xf3, 0x23, 0xfc, 0x4e, 0x83, 0xe6, 0x80, 0x1b, 0x42, 0xb5, 0x7b, 0xc3, 0xfd, 0x68, 0xc1, 0x62, |
|
0xb2, 0x0f, 0xe6, 0x82, 0x5d, 0xf1, 0x85, 0x70, 0xb4, 0x96, 0xd1, 0xae, 0x1d, 0x6c, 0x17, 0xcf, |
|
0xf5, 0x42, 0x79, 0x8e, 0x4a, 0x6f, 0xfe, 0x78, 0xb4, 0x45, 0x53, 0x5a, 0x9e, 0x50, 0xff, 0xc7, |
|
0x84, 0xc6, 0xdb, 0x09, 0x7f, 0x2d, 0x83, 0x75, 0xe6, 0x09, 0x19, 0xce, 0x62, 0xe6, 0x93, 0x87, |
|
0x60, 0x4d, 0xc2, 0x65, 0x20, 0xc7, 0x5e, 0x20, 0x51, 0x76, 0xe9, 0x6c, 0x8b, 0x56, 0x11, 0x3a, |
|
0x0f, 0x24, 0xf9, 0x08, 0x6a, 0x89, 0xfb, 0x7a, 0x11, 0x32, 0x99, 0xa4, 0x39, 0xdb, 0xa2, 0x80, |
|
0xe0, 0x89, 0xc2, 0x88, 0x0d, 0x86, 0x58, 0xfa, 0x98, 0x47, 0xa3, 0x6a, 0x49, 0x1e, 0x80, 0x29, |
|
0x26, 0x73, 0xee, 0x33, 0xbc, 0xb5, 0x6d, 0x9a, 0x5a, 0xe4, 0x31, 0x34, 0x7f, 0xe4, 0x71, 0x38, |
|
0x96, 0xf3, 0x98, 0x8b, 0x79, 0xb8, 0x98, 0xe2, 0x0d, 0x6a, 0xb4, 0xa1, 0xd0, 0x51, 0x06, 0x92, |
|
0x8f, 0x53, 0x5a, 0xae, 0xcb, 0x44, 0x5d, 0x1a, 0xad, 0x2b, 0xfc, 0x38, 0xd3, 0xf6, 0x29, 0xd8, |
|
0x05, 0x5e, 0x22, 0xb0, 0x82, 0x02, 0x35, 0xda, 0x5c, 0x33, 0x13, 0x91, 0xc7, 0xd0, 0x0c, 0xf8, |
|
0x8c, 0x49, 0xef, 0x35, 0x1f, 0x8b, 0x88, 0x05, 0xc2, 0xa9, 0xe2, 0x09, 0x3f, 0x28, 0x9e, 0xf0, |
|
0xd1, 0x72, 0xf2, 0x8a, 0xcb, 0x61, 0xc4, 0x82, 0xf4, 0x98, 0x1b, 0x59, 0x8c, 0xc2, 0x04, 0xf9, |
|
0x04, 0xee, 0xad, 0x37, 0x99, 0xf2, 0x85, 0x64, 0xc2, 0xb1, 0x5a, 0x46, 0x9b, 0xd0, 0xf5, 0xde, |
|
0xcf, 0x11, 0xdd, 0x20, 0xa2, 0x3a, 0xe1, 0x40, 0xcb, 0x68, 0x6b, 0x39, 0x11, 0xa5, 0x09, 0x25, |
|
0x2b, 0x0a, 0x85, 0x57, 0x90, 0x55, 0xfb, 0x37, 0xb2, 0xb2, 0x98, 0xb5, 0xac, 0xf5, 0x26, 0xa9, |
|
0xac, 0x7a, 0x22, 0x2b, 0x83, 0x73, 0x59, 0x6b, 0x62, 0x2a, 0xab, 0x91, 0xc8, 0xca, 0xe0, 0x54, |
|
0xd6, 0xd7, 0x00, 0x31, 0x17, 0x5c, 0x8e, 0xe7, 0xea, 0xf4, 0x9b, 0xd8, 0xe3, 0x8f, 0x8a, 0x92, |
|
0xd6, 0xf5, 0xd3, 0xa1, 0x8a, 0x77, 0xe6, 0x05, 0x92, 0x5a, 0x71, 0xb6, 0xdc, 0x2c, 0xc0, 0x7b, |
|
0x6f, 0x17, 0xe0, 0x17, 0x60, 0xad, 0xa3, 0x36, 0x3b, 0xb5, 0x02, 0xc6, 0xcb, 0xee, 0xd0, 0xd6, |
|
0x88, 0x09, 0x7a, 0x7f, 0x60, 0xeb, 0x79, 0xb7, 0x1a, 0x47, 0x15, 0x28, 0xa3, 0xe6, 0xa3, 0x3a, |
|
0x40, 0x7e, 0xed, 0xee, 0x33, 0x80, 0xfc, 0x7c, 0x54, 0xe5, 0x85, 0xd7, 0xd7, 0x82, 0x27, 0xa5, |
|
0xbc, 0x4d, 0x53, 0x4b, 0xe1, 0x0b, 0x1e, 0xcc, 0xe4, 0x1c, 0x2b, 0xb8, 0x41, 0x53, 0xcb, 0xfd, |
|
0x4b, 0x03, 0x18, 0x79, 0x3e, 0x1f, 0xf2, 0xd8, 0xe3, 0xe2, 0xfd, 0xfb, 0xef, 0x00, 0x2a, 0x02, |
|
0x5b, 0x5f, 0x38, 0x3a, 0x46, 0x90, 0x62, 0x44, 0x32, 0x15, 0xd2, 0x90, 0x8c, 0x48, 0xbe, 0x04, |
|
0x8b, 0xa7, 0x0d, 0x2f, 0x1c, 0x03, 0xa3, 0x76, 0x8a, 0x51, 0xd9, 0x34, 0x48, 0xe3, 0x72, 0x32, |
|
0xf9, 0x0a, 0x60, 0x9e, 0x1d, 0xbc, 0x70, 0x4a, 0x18, 0x7a, 0xff, 0x9d, 0xd7, 0x92, 0xc6, 0x16, |
|
0xe8, 0xee, 0x13, 0x28, 0xe3, 0x17, 0xa8, 0xe9, 0x89, 0x13, 0x57, 0x4b, 0xa6, 0xa7, 0x5a, 0x6f, |
|
0xce, 0x11, 0x2b, 0x9d, 0x23, 0xee, 0x53, 0x30, 0x2f, 0x92, 0xef, 0x7c, 0xdf, 0x83, 0x71, 0x7f, |
|
0xd2, 0xa0, 0x8e, 0x78, 0x8f, 0xc9, 0xc9, 0x9c, 0xc7, 0xe4, 0xc9, 0xc6, 0x83, 0xf1, 0xf0, 0x4e, |
|
0x7c, 0xca, 0xeb, 0x14, 0x1e, 0x8a, 0x4c, 0xa8, 0xfe, 0x2e, 0xa1, 0x46, 0x51, 0x68, 0x1b, 0x4a, |
|
0x38, 0xf6, 0x4d, 0xd0, 0xbb, 0x2f, 0x92, 0x3a, 0xea, 0x77, 0x5f, 0x24, 0x75, 0x44, 0xd5, 0xa8, |
|
0x57, 0x00, 0xed, 0xda, 0x86, 0xfb, 0x8b, 0xa6, 0x8a, 0x8f, 0x4d, 0x55, 0xed, 0x09, 0xf2, 0x7f, |
|
0xa8, 0x08, 0xc9, 0xa3, 0xb1, 0x2f, 0x50, 0x97, 0x41, 0x4d, 0x65, 0xf6, 0x84, 0x4a, 0x7d, 0xbd, |
|
0x0c, 0x26, 0x59, 0x6a, 0xb5, 0x26, 0x1f, 0x40, 0x55, 0x48, 0x16, 0x4b, 0xc5, 0x4e, 0x86, 0x6a, |
|
0x05, 0xed, 0x9e, 0x20, 0xf7, 0xc1, 0xe4, 0xc1, 0x74, 0x8c, 0x97, 0xa2, 0x1c, 0x65, 0x1e, 0x4c, |
|
0x7b, 0x82, 0xec, 0x42, 0x75, 0x16, 0x87, 0xcb, 0xc8, 0x0b, 0x66, 0x4e, 0xb9, 0x65, 0xb4, 0x2d, |
|
0xba, 0xb6, 0x49, 0x13, 0xf4, 0xab, 0x15, 0x0e, 0xb6, 0x2a, 0xd5, 0xaf, 0x56, 0x6a, 0xf7, 0x98, |
|
0x05, 0x33, 0xae, 0x36, 0xa9, 0x24, 0xbb, 0xa3, 0xdd, 0x13, 0xee, 0xef, 0x1a, 0x94, 0x8f, 0xe7, |
|
0xcb, 0xe0, 0x15, 0xd9, 0x83, 0x9a, 0xef, 0x05, 0x63, 0xd5, 0x4a, 0xb9, 0x66, 0xcb, 0xf7, 0x02, |
|
0x55, 0xc3, 0x3d, 0x81, 0x7e, 0x76, 0xb3, 0xf6, 0xa7, 0x6f, 0x8d, 0xcf, 0x6e, 0x52, 0x7f, 0x27, |
|
0xbd, 0x04, 0x03, 0x2f, 0x61, 0xb7, 0x78, 0x09, 0x98, 0xa0, 0xd3, 0x0d, 0x26, 0xe1, 0xd4, 0x0b, |
|
0x66, 0xf9, 0x0d, 0xa8, 0x37, 0x1c, 0xbf, 0xaa, 0x4e, 0x71, 0xed, 0x3e, 0x87, 0x6a, 0xc6, 0xba, |
|
0xd3, 0xbc, 0xdf, 0x0d, 0xd4, 0x13, 0xbb, 0xf1, 0xae, 0xea, 0xe4, 0x7f, 0x70, 0xef, 0xe4, 0x62, |
|
0x70, 0x38, 0x1a, 0x17, 0x1e, 0x5b, 0xf7, 0x07, 0x68, 0x60, 0x46, 0x3e, 0xfd, 0xaf, 0xad, 0xb7, |
|
0x0f, 0xe6, 0x44, 0xed, 0x90, 0x75, 0xde, 0xf6, 0x9d, 0xaf, 0xc9, 0x02, 0x12, 0xda, 0xd1, 0xce, |
|
0x9b, 0xdb, 0x3d, 0xed, 0xb7, 0xdb, 0x3d, 0xed, 0xcf, 0xdb, 0x3d, 0xed, 0x7b, 0x53, 0xb1, 0xa3, |
|
0xab, 0x2b, 0x13, 0x7f, 0x71, 0x3e, 0xff, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xfb, 0x5f, 0xf2, 0x4d, |
|
0x13, 0x09, 0x00, 0x00, |
|
} |
|
|
|
func (m *MetricMetadata) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *MetricMetadata) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *MetricMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i -= len(m.XXX_unrecognized) |
|
copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
if len(m.Unit) > 0 { |
|
i -= len(m.Unit) |
|
copy(dAtA[i:], m.Unit) |
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Unit))) |
|
i-- |
|
dAtA[i] = 0x2a |
|
} |
|
if len(m.Help) > 0 { |
|
i -= len(m.Help) |
|
copy(dAtA[i:], m.Help) |
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Help))) |
|
i-- |
|
dAtA[i] = 0x22 |
|
} |
|
if len(m.MetricFamilyName) > 0 { |
|
i -= len(m.MetricFamilyName) |
|
copy(dAtA[i:], m.MetricFamilyName) |
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.MetricFamilyName))) |
|
i-- |
|
dAtA[i] = 0x12 |
|
} |
|
if m.Type != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.Type)) |
|
i-- |
|
dAtA[i] = 0x8 |
|
} |
|
return len(dAtA) - i, nil |
|
} |
|
|
|
func (m *Sample) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *Sample) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *Sample) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i -= len(m.XXX_unrecognized) |
|
copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
if m.Timestamp != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.Timestamp)) |
|
i-- |
|
dAtA[i] = 0x10 |
|
} |
|
if m.Value != 0 { |
|
i -= 8 |
|
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value)))) |
|
i-- |
|
dAtA[i] = 0x9 |
|
} |
|
return len(dAtA) - i, nil |
|
} |
|
|
|
func (m *Exemplar) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *Exemplar) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *Exemplar) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i -= len(m.XXX_unrecognized) |
|
copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
if m.Timestamp != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.Timestamp)) |
|
i-- |
|
dAtA[i] = 0x18 |
|
} |
|
if m.Value != 0 { |
|
i -= 8 |
|
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value)))) |
|
i-- |
|
dAtA[i] = 0x11 |
|
} |
|
if len(m.Labels) > 0 { |
|
for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- { |
|
{ |
|
size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i -= size |
|
i = encodeVarintTypes(dAtA, i, uint64(size)) |
|
} |
|
i-- |
|
dAtA[i] = 0xa |
|
} |
|
} |
|
return len(dAtA) - i, nil |
|
} |
|
|
|
func (m *Histogram) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *Histogram) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *Histogram) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i -= len(m.XXX_unrecognized) |
|
copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
if m.Timestamp != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.Timestamp)) |
|
i-- |
|
dAtA[i] = 0x78 |
|
} |
|
if m.ResetHint != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.ResetHint)) |
|
i-- |
|
dAtA[i] = 0x70 |
|
} |
|
if len(m.PositiveCounts) > 0 { |
|
for iNdEx := len(m.PositiveCounts) - 1; iNdEx >= 0; iNdEx-- { |
|
f1 := math.Float64bits(float64(m.PositiveCounts[iNdEx])) |
|
i -= 8 |
|
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f1)) |
|
} |
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.PositiveCounts)*8)) |
|
i-- |
|
dAtA[i] = 0x6a |
|
} |
|
if len(m.PositiveDeltas) > 0 { |
|
var j2 int |
|
dAtA4 := make([]byte, len(m.PositiveDeltas)*10) |
|
for _, num := range m.PositiveDeltas { |
|
x3 := (uint64(num) << 1) ^ uint64((num >> 63)) |
|
for x3 >= 1<<7 { |
|
dAtA4[j2] = uint8(uint64(x3)&0x7f | 0x80) |
|
j2++ |
|
x3 >>= 7 |
|
} |
|
dAtA4[j2] = uint8(x3) |
|
j2++ |
|
} |
|
i -= j2 |
|
copy(dAtA[i:], dAtA4[:j2]) |
|
i = encodeVarintTypes(dAtA, i, uint64(j2)) |
|
i-- |
|
dAtA[i] = 0x62 |
|
} |
|
if len(m.PositiveSpans) > 0 { |
|
for iNdEx := len(m.PositiveSpans) - 1; iNdEx >= 0; iNdEx-- { |
|
{ |
|
size, err := m.PositiveSpans[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i -= size |
|
i = encodeVarintTypes(dAtA, i, uint64(size)) |
|
} |
|
i-- |
|
dAtA[i] = 0x5a |
|
} |
|
} |
|
if len(m.NegativeCounts) > 0 { |
|
for iNdEx := len(m.NegativeCounts) - 1; iNdEx >= 0; iNdEx-- { |
|
f5 := math.Float64bits(float64(m.NegativeCounts[iNdEx])) |
|
i -= 8 |
|
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f5)) |
|
} |
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.NegativeCounts)*8)) |
|
i-- |
|
dAtA[i] = 0x52 |
|
} |
|
if len(m.NegativeDeltas) > 0 { |
|
var j6 int |
|
dAtA8 := make([]byte, len(m.NegativeDeltas)*10) |
|
for _, num := range m.NegativeDeltas { |
|
x7 := (uint64(num) << 1) ^ uint64((num >> 63)) |
|
for x7 >= 1<<7 { |
|
dAtA8[j6] = uint8(uint64(x7)&0x7f | 0x80) |
|
j6++ |
|
x7 >>= 7 |
|
} |
|
dAtA8[j6] = uint8(x7) |
|
j6++ |
|
} |
|
i -= j6 |
|
copy(dAtA[i:], dAtA8[:j6]) |
|
i = encodeVarintTypes(dAtA, i, uint64(j6)) |
|
i-- |
|
dAtA[i] = 0x4a |
|
} |
|
if len(m.NegativeSpans) > 0 { |
|
for iNdEx := len(m.NegativeSpans) - 1; iNdEx >= 0; iNdEx-- { |
|
{ |
|
size, err := m.NegativeSpans[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i -= size |
|
i = encodeVarintTypes(dAtA, i, uint64(size)) |
|
} |
|
i-- |
|
dAtA[i] = 0x42 |
|
} |
|
} |
|
if m.ZeroCount != nil { |
|
{ |
|
size := m.ZeroCount.Size() |
|
i -= size |
|
if _, err := m.ZeroCount.MarshalTo(dAtA[i:]); err != nil { |
|
return 0, err |
|
} |
|
} |
|
} |
|
if m.ZeroThreshold != 0 { |
|
i -= 8 |
|
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ZeroThreshold)))) |
|
i-- |
|
dAtA[i] = 0x29 |
|
} |
|
if m.Schema != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64((uint32(m.Schema)<<1)^uint32((m.Schema>>31)))) |
|
i-- |
|
dAtA[i] = 0x20 |
|
} |
|
if m.Sum != 0 { |
|
i -= 8 |
|
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Sum)))) |
|
i-- |
|
dAtA[i] = 0x19 |
|
} |
|
if m.Count != nil { |
|
{ |
|
size := m.Count.Size() |
|
i -= size |
|
if _, err := m.Count.MarshalTo(dAtA[i:]); err != nil { |
|
return 0, err |
|
} |
|
} |
|
} |
|
return len(dAtA) - i, nil |
|
} |
|
|
|
func (m *Histogram_CountInt) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *Histogram_CountInt) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
i = encodeVarintTypes(dAtA, i, uint64(m.CountInt)) |
|
i-- |
|
dAtA[i] = 0x8 |
|
return len(dAtA) - i, nil |
|
} |
|
func (m *Histogram_CountFloat) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *Histogram_CountFloat) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
i -= 8 |
|
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.CountFloat)))) |
|
i-- |
|
dAtA[i] = 0x11 |
|
return len(dAtA) - i, nil |
|
} |
|
func (m *Histogram_ZeroCountInt) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *Histogram_ZeroCountInt) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
i = encodeVarintTypes(dAtA, i, uint64(m.ZeroCountInt)) |
|
i-- |
|
dAtA[i] = 0x30 |
|
return len(dAtA) - i, nil |
|
} |
|
func (m *Histogram_ZeroCountFloat) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *Histogram_ZeroCountFloat) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
i -= 8 |
|
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ZeroCountFloat)))) |
|
i-- |
|
dAtA[i] = 0x39 |
|
return len(dAtA) - i, nil |
|
} |
|
func (m *BucketSpan) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *BucketSpan) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *BucketSpan) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i -= len(m.XXX_unrecognized) |
|
copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
if m.Length != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.Length)) |
|
i-- |
|
dAtA[i] = 0x10 |
|
} |
|
if m.Offset != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64((uint32(m.Offset)<<1)^uint32((m.Offset>>31)))) |
|
i-- |
|
dAtA[i] = 0x8 |
|
} |
|
return len(dAtA) - i, nil |
|
} |
|
|
|
func (m *TimeSeries) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *TimeSeries) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *TimeSeries) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i -= len(m.XXX_unrecognized) |
|
copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
if len(m.Histograms) > 0 { |
|
for iNdEx := len(m.Histograms) - 1; iNdEx >= 0; iNdEx-- { |
|
{ |
|
size, err := m.Histograms[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i -= size |
|
i = encodeVarintTypes(dAtA, i, uint64(size)) |
|
} |
|
i-- |
|
dAtA[i] = 0x22 |
|
} |
|
} |
|
if len(m.Exemplars) > 0 { |
|
for iNdEx := len(m.Exemplars) - 1; iNdEx >= 0; iNdEx-- { |
|
{ |
|
size, err := m.Exemplars[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i -= size |
|
i = encodeVarintTypes(dAtA, i, uint64(size)) |
|
} |
|
i-- |
|
dAtA[i] = 0x1a |
|
} |
|
} |
|
if len(m.Samples) > 0 { |
|
for iNdEx := len(m.Samples) - 1; iNdEx >= 0; iNdEx-- { |
|
{ |
|
size, err := m.Samples[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i -= size |
|
i = encodeVarintTypes(dAtA, i, uint64(size)) |
|
} |
|
i-- |
|
dAtA[i] = 0x12 |
|
} |
|
} |
|
if len(m.Labels) > 0 { |
|
for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- { |
|
{ |
|
size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i -= size |
|
i = encodeVarintTypes(dAtA, i, uint64(size)) |
|
} |
|
i-- |
|
dAtA[i] = 0xa |
|
} |
|
} |
|
return len(dAtA) - i, nil |
|
} |
|
|
|
func (m *Label) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *Label) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *Label) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i -= len(m.XXX_unrecognized) |
|
copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
if len(m.Value) > 0 { |
|
i -= len(m.Value) |
|
copy(dAtA[i:], m.Value) |
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Value))) |
|
i-- |
|
dAtA[i] = 0x12 |
|
} |
|
if len(m.Name) > 0 { |
|
i -= len(m.Name) |
|
copy(dAtA[i:], m.Name) |
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Name))) |
|
i-- |
|
dAtA[i] = 0xa |
|
} |
|
return len(dAtA) - i, nil |
|
} |
|
|
|
func (m *Labels) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *Labels) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *Labels) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i -= len(m.XXX_unrecognized) |
|
copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
if len(m.Labels) > 0 { |
|
for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- { |
|
{ |
|
size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i -= size |
|
i = encodeVarintTypes(dAtA, i, uint64(size)) |
|
} |
|
i-- |
|
dAtA[i] = 0xa |
|
} |
|
} |
|
return len(dAtA) - i, nil |
|
} |
|
|
|
func (m *LabelMatcher) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *LabelMatcher) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *LabelMatcher) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i -= len(m.XXX_unrecognized) |
|
copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
if len(m.Value) > 0 { |
|
i -= len(m.Value) |
|
copy(dAtA[i:], m.Value) |
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Value))) |
|
i-- |
|
dAtA[i] = 0x1a |
|
} |
|
if len(m.Name) > 0 { |
|
i -= len(m.Name) |
|
copy(dAtA[i:], m.Name) |
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Name))) |
|
i-- |
|
dAtA[i] = 0x12 |
|
} |
|
if m.Type != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.Type)) |
|
i-- |
|
dAtA[i] = 0x8 |
|
} |
|
return len(dAtA) - i, nil |
|
} |
|
|
|
func (m *ReadHints) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *ReadHints) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *ReadHints) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i -= len(m.XXX_unrecognized) |
|
copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
if m.RangeMs != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.RangeMs)) |
|
i-- |
|
dAtA[i] = 0x38 |
|
} |
|
if m.By { |
|
i-- |
|
if m.By { |
|
dAtA[i] = 1 |
|
} else { |
|
dAtA[i] = 0 |
|
} |
|
i-- |
|
dAtA[i] = 0x30 |
|
} |
|
if len(m.Grouping) > 0 { |
|
for iNdEx := len(m.Grouping) - 1; iNdEx >= 0; iNdEx-- { |
|
i -= len(m.Grouping[iNdEx]) |
|
copy(dAtA[i:], m.Grouping[iNdEx]) |
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Grouping[iNdEx]))) |
|
i-- |
|
dAtA[i] = 0x2a |
|
} |
|
} |
|
if m.EndMs != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.EndMs)) |
|
i-- |
|
dAtA[i] = 0x20 |
|
} |
|
if m.StartMs != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.StartMs)) |
|
i-- |
|
dAtA[i] = 0x18 |
|
} |
|
if len(m.Func) > 0 { |
|
i -= len(m.Func) |
|
copy(dAtA[i:], m.Func) |
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Func))) |
|
i-- |
|
dAtA[i] = 0x12 |
|
} |
|
if m.StepMs != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.StepMs)) |
|
i-- |
|
dAtA[i] = 0x8 |
|
} |
|
return len(dAtA) - i, nil |
|
} |
|
|
|
func (m *Chunk) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *Chunk) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *Chunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i -= len(m.XXX_unrecognized) |
|
copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
if len(m.Data) > 0 { |
|
i -= len(m.Data) |
|
copy(dAtA[i:], m.Data) |
|
i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) |
|
i-- |
|
dAtA[i] = 0x22 |
|
} |
|
if m.Type != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.Type)) |
|
i-- |
|
dAtA[i] = 0x18 |
|
} |
|
if m.MaxTimeMs != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.MaxTimeMs)) |
|
i-- |
|
dAtA[i] = 0x10 |
|
} |
|
if m.MinTimeMs != 0 { |
|
i = encodeVarintTypes(dAtA, i, uint64(m.MinTimeMs)) |
|
i-- |
|
dAtA[i] = 0x8 |
|
} |
|
return len(dAtA) - i, nil |
|
} |
|
|
|
func (m *ChunkedSeries) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *ChunkedSeries) MarshalTo(dAtA []byte) (int, error) { |
|
size := m.Size() |
|
return m.MarshalToSizedBuffer(dAtA[:size]) |
|
} |
|
|
|
func (m *ChunkedSeries) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
|
i := len(dAtA) |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i -= len(m.XXX_unrecognized) |
|
copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
if len(m.Chunks) > 0 { |
|
for iNdEx := len(m.Chunks) - 1; iNdEx >= 0; iNdEx-- { |
|
{ |
|
size, err := m.Chunks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i -= size |
|
i = encodeVarintTypes(dAtA, i, uint64(size)) |
|
} |
|
i-- |
|
dAtA[i] = 0x12 |
|
} |
|
} |
|
if len(m.Labels) > 0 { |
|
for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- { |
|
{ |
|
size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i -= size |
|
i = encodeVarintTypes(dAtA, i, uint64(size)) |
|
} |
|
i-- |
|
dAtA[i] = 0xa |
|
} |
|
} |
|
return len(dAtA) - i, nil |
|
} |
|
|
|
func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { |
|
offset -= sovTypes(v) |
|
base := offset |
|
for v >= 1<<7 { |
|
dAtA[offset] = uint8(v&0x7f | 0x80) |
|
v >>= 7 |
|
offset++ |
|
} |
|
dAtA[offset] = uint8(v) |
|
return base |
|
} |
|
func (m *MetricMetadata) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if m.Type != 0 { |
|
n += 1 + sovTypes(uint64(m.Type)) |
|
} |
|
l = len(m.MetricFamilyName) |
|
if l > 0 { |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
l = len(m.Help) |
|
if l > 0 { |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
l = len(m.Unit) |
|
if l > 0 { |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *Sample) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if m.Value != 0 { |
|
n += 9 |
|
} |
|
if m.Timestamp != 0 { |
|
n += 1 + sovTypes(uint64(m.Timestamp)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *Exemplar) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if len(m.Labels) > 0 { |
|
for _, e := range m.Labels { |
|
l = e.Size() |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
} |
|
if m.Value != 0 { |
|
n += 9 |
|
} |
|
if m.Timestamp != 0 { |
|
n += 1 + sovTypes(uint64(m.Timestamp)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *Histogram) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if m.Count != nil { |
|
n += m.Count.Size() |
|
} |
|
if m.Sum != 0 { |
|
n += 9 |
|
} |
|
if m.Schema != 0 { |
|
n += 1 + sozTypes(uint64(m.Schema)) |
|
} |
|
if m.ZeroThreshold != 0 { |
|
n += 9 |
|
} |
|
if m.ZeroCount != nil { |
|
n += m.ZeroCount.Size() |
|
} |
|
if len(m.NegativeSpans) > 0 { |
|
for _, e := range m.NegativeSpans { |
|
l = e.Size() |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
} |
|
if len(m.NegativeDeltas) > 0 { |
|
l = 0 |
|
for _, e := range m.NegativeDeltas { |
|
l += sozTypes(uint64(e)) |
|
} |
|
n += 1 + sovTypes(uint64(l)) + l |
|
} |
|
if len(m.NegativeCounts) > 0 { |
|
n += 1 + sovTypes(uint64(len(m.NegativeCounts)*8)) + len(m.NegativeCounts)*8 |
|
} |
|
if len(m.PositiveSpans) > 0 { |
|
for _, e := range m.PositiveSpans { |
|
l = e.Size() |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
} |
|
if len(m.PositiveDeltas) > 0 { |
|
l = 0 |
|
for _, e := range m.PositiveDeltas { |
|
l += sozTypes(uint64(e)) |
|
} |
|
n += 1 + sovTypes(uint64(l)) + l |
|
} |
|
if len(m.PositiveCounts) > 0 { |
|
n += 1 + sovTypes(uint64(len(m.PositiveCounts)*8)) + len(m.PositiveCounts)*8 |
|
} |
|
if m.ResetHint != 0 { |
|
n += 1 + sovTypes(uint64(m.ResetHint)) |
|
} |
|
if m.Timestamp != 0 { |
|
n += 1 + sovTypes(uint64(m.Timestamp)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *Histogram_CountInt) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
n += 1 + sovTypes(uint64(m.CountInt)) |
|
return n |
|
} |
|
func (m *Histogram_CountFloat) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
n += 9 |
|
return n |
|
} |
|
func (m *Histogram_ZeroCountInt) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
n += 1 + sovTypes(uint64(m.ZeroCountInt)) |
|
return n |
|
} |
|
func (m *Histogram_ZeroCountFloat) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
n += 9 |
|
return n |
|
} |
|
func (m *BucketSpan) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if m.Offset != 0 { |
|
n += 1 + sozTypes(uint64(m.Offset)) |
|
} |
|
if m.Length != 0 { |
|
n += 1 + sovTypes(uint64(m.Length)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *TimeSeries) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if len(m.Labels) > 0 { |
|
for _, e := range m.Labels { |
|
l = e.Size() |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
} |
|
if len(m.Samples) > 0 { |
|
for _, e := range m.Samples { |
|
l = e.Size() |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
} |
|
if len(m.Exemplars) > 0 { |
|
for _, e := range m.Exemplars { |
|
l = e.Size() |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
} |
|
if len(m.Histograms) > 0 { |
|
for _, e := range m.Histograms { |
|
l = e.Size() |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *Label) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
l = len(m.Name) |
|
if l > 0 { |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
l = len(m.Value) |
|
if l > 0 { |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *Labels) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if len(m.Labels) > 0 { |
|
for _, e := range m.Labels { |
|
l = e.Size() |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *LabelMatcher) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if m.Type != 0 { |
|
n += 1 + sovTypes(uint64(m.Type)) |
|
} |
|
l = len(m.Name) |
|
if l > 0 { |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
l = len(m.Value) |
|
if l > 0 { |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *ReadHints) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if m.StepMs != 0 { |
|
n += 1 + sovTypes(uint64(m.StepMs)) |
|
} |
|
l = len(m.Func) |
|
if l > 0 { |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
if m.StartMs != 0 { |
|
n += 1 + sovTypes(uint64(m.StartMs)) |
|
} |
|
if m.EndMs != 0 { |
|
n += 1 + sovTypes(uint64(m.EndMs)) |
|
} |
|
if len(m.Grouping) > 0 { |
|
for _, s := range m.Grouping { |
|
l = len(s) |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
} |
|
if m.By { |
|
n += 2 |
|
} |
|
if m.RangeMs != 0 { |
|
n += 1 + sovTypes(uint64(m.RangeMs)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *Chunk) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if m.MinTimeMs != 0 { |
|
n += 1 + sovTypes(uint64(m.MinTimeMs)) |
|
} |
|
if m.MaxTimeMs != 0 { |
|
n += 1 + sovTypes(uint64(m.MaxTimeMs)) |
|
} |
|
if m.Type != 0 { |
|
n += 1 + sovTypes(uint64(m.Type)) |
|
} |
|
l = len(m.Data) |
|
if l > 0 { |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *ChunkedSeries) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if len(m.Labels) > 0 { |
|
for _, e := range m.Labels { |
|
l = e.Size() |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
} |
|
if len(m.Chunks) > 0 { |
|
for _, e := range m.Chunks { |
|
l = e.Size() |
|
n += 1 + l + sovTypes(uint64(l)) |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func sovTypes(x uint64) (n int) { |
|
return (math_bits.Len64(x|1) + 6) / 7 |
|
} |
|
func sozTypes(x uint64) (n int) { |
|
return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63)))) |
|
} |
|
func (m *MetricMetadata) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: MetricMetadata: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: MetricMetadata: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) |
|
} |
|
m.Type = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Type |= MetricMetadata_MetricType(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field MetricFamilyName", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.MetricFamilyName = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 4: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Help", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Help = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 5: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Unit = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipTypes(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if (skippy < 0) || (iNdEx+skippy) < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *Sample) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: Sample: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: Sample: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 1 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) |
|
} |
|
var v uint64 |
|
if (iNdEx + 8) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
|
iNdEx += 8 |
|
m.Value = float64(math.Float64frombits(v)) |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) |
|
} |
|
m.Timestamp = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Timestamp |= int64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipTypes(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if (skippy < 0) || (iNdEx+skippy) < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *Exemplar) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: Exemplar: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: Exemplar: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Labels = append(m.Labels, Label{}) |
|
if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
case 2: |
|
if wireType != 1 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) |
|
} |
|
var v uint64 |
|
if (iNdEx + 8) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
|
iNdEx += 8 |
|
m.Value = float64(math.Float64frombits(v)) |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) |
|
} |
|
m.Timestamp = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Timestamp |= int64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipTypes(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if (skippy < 0) || (iNdEx+skippy) < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *Histogram) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: Histogram: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: Histogram: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field CountInt", wireType) |
|
} |
|
var v uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
m.Count = &Histogram_CountInt{v} |
|
case 2: |
|
if wireType != 1 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field CountFloat", wireType) |
|
} |
|
var v uint64 |
|
if (iNdEx + 8) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
|
iNdEx += 8 |
|
m.Count = &Histogram_CountFloat{float64(math.Float64frombits(v))} |
|
case 3: |
|
if wireType != 1 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Sum", wireType) |
|
} |
|
var v uint64 |
|
if (iNdEx + 8) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
|
iNdEx += 8 |
|
m.Sum = float64(math.Float64frombits(v)) |
|
case 4: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType) |
|
} |
|
var v int32 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= int32(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) |
|
m.Schema = v |
|
case 5: |
|
if wireType != 1 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ZeroThreshold", wireType) |
|
} |
|
var v uint64 |
|
if (iNdEx + 8) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
|
iNdEx += 8 |
|
m.ZeroThreshold = float64(math.Float64frombits(v)) |
|
case 6: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ZeroCountInt", wireType) |
|
} |
|
var v uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
m.ZeroCount = &Histogram_ZeroCountInt{v} |
|
case 7: |
|
if wireType != 1 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ZeroCountFloat", wireType) |
|
} |
|
var v uint64 |
|
if (iNdEx + 8) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
|
iNdEx += 8 |
|
m.ZeroCount = &Histogram_ZeroCountFloat{float64(math.Float64frombits(v))} |
|
case 8: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field NegativeSpans", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.NegativeSpans = append(m.NegativeSpans, BucketSpan{}) |
|
if err := m.NegativeSpans[len(m.NegativeSpans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
case 9: |
|
if wireType == 0 { |
|
var v uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) |
|
m.NegativeDeltas = append(m.NegativeDeltas, int64(v)) |
|
} else if wireType == 2 { |
|
var packedLen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
packedLen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if packedLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + packedLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
var elementCount int |
|
var count int |
|
for _, integer := range dAtA[iNdEx:postIndex] { |
|
if integer < 128 { |
|
count++ |
|
} |
|
} |
|
elementCount = count |
|
if elementCount != 0 && len(m.NegativeDeltas) == 0 { |
|
m.NegativeDeltas = make([]int64, 0, elementCount) |
|
} |
|
for iNdEx < postIndex { |
|
var v uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) |
|
m.NegativeDeltas = append(m.NegativeDeltas, int64(v)) |
|
} |
|
} else { |
|
return fmt.Errorf("proto: wrong wireType = %d for field NegativeDeltas", wireType) |
|
} |
|
case 10: |
|
if wireType == 1 { |
|
var v uint64 |
|
if (iNdEx + 8) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
|
iNdEx += 8 |
|
v2 := float64(math.Float64frombits(v)) |
|
m.NegativeCounts = append(m.NegativeCounts, v2) |
|
} else if wireType == 2 { |
|
var packedLen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
packedLen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if packedLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + packedLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
var elementCount int |
|
elementCount = packedLen / 8 |
|
if elementCount != 0 && len(m.NegativeCounts) == 0 { |
|
m.NegativeCounts = make([]float64, 0, elementCount) |
|
} |
|
for iNdEx < postIndex { |
|
var v uint64 |
|
if (iNdEx + 8) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
|
iNdEx += 8 |
|
v2 := float64(math.Float64frombits(v)) |
|
m.NegativeCounts = append(m.NegativeCounts, v2) |
|
} |
|
} else { |
|
return fmt.Errorf("proto: wrong wireType = %d for field NegativeCounts", wireType) |
|
} |
|
case 11: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field PositiveSpans", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.PositiveSpans = append(m.PositiveSpans, BucketSpan{}) |
|
if err := m.PositiveSpans[len(m.PositiveSpans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
case 12: |
|
if wireType == 0 { |
|
var v uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) |
|
m.PositiveDeltas = append(m.PositiveDeltas, int64(v)) |
|
} else if wireType == 2 { |
|
var packedLen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
packedLen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if packedLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + packedLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
var elementCount int |
|
var count int |
|
for _, integer := range dAtA[iNdEx:postIndex] { |
|
if integer < 128 { |
|
count++ |
|
} |
|
} |
|
elementCount = count |
|
if elementCount != 0 && len(m.PositiveDeltas) == 0 { |
|
m.PositiveDeltas = make([]int64, 0, elementCount) |
|
} |
|
for iNdEx < postIndex { |
|
var v uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) |
|
m.PositiveDeltas = append(m.PositiveDeltas, int64(v)) |
|
} |
|
} else { |
|
return fmt.Errorf("proto: wrong wireType = %d for field PositiveDeltas", wireType) |
|
} |
|
case 13: |
|
if wireType == 1 { |
|
var v uint64 |
|
if (iNdEx + 8) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
|
iNdEx += 8 |
|
v2 := float64(math.Float64frombits(v)) |
|
m.PositiveCounts = append(m.PositiveCounts, v2) |
|
} else if wireType == 2 { |
|
var packedLen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
packedLen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if packedLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + packedLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
var elementCount int |
|
elementCount = packedLen / 8 |
|
if elementCount != 0 && len(m.PositiveCounts) == 0 { |
|
m.PositiveCounts = make([]float64, 0, elementCount) |
|
} |
|
for iNdEx < postIndex { |
|
var v uint64 |
|
if (iNdEx + 8) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
|
iNdEx += 8 |
|
v2 := float64(math.Float64frombits(v)) |
|
m.PositiveCounts = append(m.PositiveCounts, v2) |
|
} |
|
} else { |
|
return fmt.Errorf("proto: wrong wireType = %d for field PositiveCounts", wireType) |
|
} |
|
case 14: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ResetHint", wireType) |
|
} |
|
m.ResetHint = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.ResetHint |= Histogram_ResetHint(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 15: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) |
|
} |
|
m.Timestamp = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Timestamp |= int64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipTypes(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if (skippy < 0) || (iNdEx+skippy) < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *BucketSpan) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: BucketSpan: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: BucketSpan: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType) |
|
} |
|
var v int32 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= int32(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) |
|
m.Offset = v |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType) |
|
} |
|
m.Length = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Length |= uint32(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipTypes(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if (skippy < 0) || (iNdEx+skippy) < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *TimeSeries) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: TimeSeries: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: TimeSeries: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Labels = append(m.Labels, Label{}) |
|
if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Samples", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Samples = append(m.Samples, Sample{}) |
|
if err := m.Samples[len(m.Samples)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
case 3: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Exemplars", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Exemplars = append(m.Exemplars, Exemplar{}) |
|
if err := m.Exemplars[len(m.Exemplars)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
case 4: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Histograms", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Histograms = append(m.Histograms, Histogram{}) |
|
if err := m.Histograms[len(m.Histograms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipTypes(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if (skippy < 0) || (iNdEx+skippy) < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *Label) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: Label: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: Label: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Name = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Value = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipTypes(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if (skippy < 0) || (iNdEx+skippy) < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *Labels) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: Labels: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: Labels: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Labels = append(m.Labels, Label{}) |
|
if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipTypes(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if (skippy < 0) || (iNdEx+skippy) < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *LabelMatcher) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: LabelMatcher: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: LabelMatcher: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) |
|
} |
|
m.Type = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Type |= LabelMatcher_Type(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Name = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 3: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Value = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipTypes(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if (skippy < 0) || (iNdEx+skippy) < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *ReadHints) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: ReadHints: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: ReadHints: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field StepMs", wireType) |
|
} |
|
m.StepMs = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.StepMs |= int64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Func", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Func = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field StartMs", wireType) |
|
} |
|
m.StartMs = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.StartMs |= int64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 4: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field EndMs", wireType) |
|
} |
|
m.EndMs = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.EndMs |= int64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 5: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Grouping", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Grouping = append(m.Grouping, string(dAtA[iNdEx:postIndex])) |
|
iNdEx = postIndex |
|
case 6: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field By", wireType) |
|
} |
|
var v int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
m.By = bool(v != 0) |
|
case 7: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field RangeMs", wireType) |
|
} |
|
m.RangeMs = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.RangeMs |= int64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipTypes(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if (skippy < 0) || (iNdEx+skippy) < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *Chunk) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: Chunk: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: Chunk: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field MinTimeMs", wireType) |
|
} |
|
m.MinTimeMs = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.MinTimeMs |= int64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field MaxTimeMs", wireType) |
|
} |
|
m.MaxTimeMs = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.MaxTimeMs |= int64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) |
|
} |
|
m.Type = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Type |= Chunk_Encoding(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 4: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) |
|
} |
|
var byteLen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
byteLen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if byteLen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + byteLen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) |
|
if m.Data == nil { |
|
m.Data = []byte{} |
|
} |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipTypes(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if (skippy < 0) || (iNdEx+skippy) < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *ChunkedSeries) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= uint64(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: ChunkedSeries: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: ChunkedSeries: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Labels = append(m.Labels, Label{}) |
|
if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= int(b&0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Chunks = append(m.Chunks, Chunk{}) |
|
if err := m.Chunks[len(m.Chunks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipTypes(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if (skippy < 0) || (iNdEx+skippy) < 0 { |
|
return ErrInvalidLengthTypes |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func skipTypes(dAtA []byte) (n int, err error) { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
depth := 0 |
|
for iNdEx < l { |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return 0, ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return 0, io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
wireType := int(wire & 0x7) |
|
switch wireType { |
|
case 0: |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return 0, ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return 0, io.ErrUnexpectedEOF |
|
} |
|
iNdEx++ |
|
if dAtA[iNdEx-1] < 0x80 { |
|
break |
|
} |
|
} |
|
case 1: |
|
iNdEx += 8 |
|
case 2: |
|
var length int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return 0, ErrIntOverflowTypes |
|
} |
|
if iNdEx >= l { |
|
return 0, io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
length |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if length < 0 { |
|
return 0, ErrInvalidLengthTypes |
|
} |
|
iNdEx += length |
|
case 3: |
|
depth++ |
|
case 4: |
|
if depth == 0 { |
|
return 0, ErrUnexpectedEndOfGroupTypes |
|
} |
|
depth-- |
|
case 5: |
|
iNdEx += 4 |
|
default: |
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType) |
|
} |
|
if iNdEx < 0 { |
|
return 0, ErrInvalidLengthTypes |
|
} |
|
if depth == 0 { |
|
return iNdEx, nil |
|
} |
|
} |
|
return 0, io.ErrUnexpectedEOF |
|
} |
|
|
|
var ( |
|
ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling") |
|
ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow") |
|
ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group") |
|
)
|
|
|