3872 lines
97 KiB
Go
3872 lines
97 KiB
Go
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
|
// source: storage.proto
|
|
|
|
/*
|
|
Package storage is a generated protocol buffer package.
|
|
|
|
It is generated from these files:
|
|
storage.proto
|
|
predicate.proto
|
|
|
|
It has these top-level messages:
|
|
ReadRequest
|
|
Aggregate
|
|
Tag
|
|
ReadResponse
|
|
CapabilitiesResponse
|
|
HintsResponse
|
|
TimestampRange
|
|
Node
|
|
Predicate
|
|
*/
|
|
package storage
|
|
|
|
import proto "github.com/gogo/protobuf/proto"
|
|
import fmt "fmt"
|
|
import math "math"
|
|
import _ "github.com/gogo/protobuf/gogoproto"
|
|
import _ "github.com/gogo/protobuf/types"
|
|
import _ "github.com/influxdata/yarpc/yarpcproto"
|
|
|
|
import io "io"
|
|
|
|
// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package
|
|
|
|
type Aggregate_AggregateType int32
|
|
|
|
const (
|
|
AggregateTypeNone Aggregate_AggregateType = 0
|
|
AggregateTypeSum Aggregate_AggregateType = 1
|
|
AggregateTypeCount Aggregate_AggregateType = 2
|
|
)
|
|
|
|
var Aggregate_AggregateType_name = map[int32]string{
|
|
0: "NONE",
|
|
1: "SUM",
|
|
2: "COUNT",
|
|
}
|
|
var Aggregate_AggregateType_value = map[string]int32{
|
|
"NONE": 0,
|
|
"SUM": 1,
|
|
"COUNT": 2,
|
|
}
|
|
|
|
func (x Aggregate_AggregateType) String() string {
|
|
return proto.EnumName(Aggregate_AggregateType_name, int32(x))
|
|
}
|
|
func (Aggregate_AggregateType) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptorStorage, []int{1, 0}
|
|
}
|
|
|
|
type ReadResponse_FrameType int32
|
|
|
|
const (
|
|
FrameTypeSeries ReadResponse_FrameType = 0
|
|
FrameTypePoints ReadResponse_FrameType = 1
|
|
)
|
|
|
|
var ReadResponse_FrameType_name = map[int32]string{
|
|
0: "SERIES",
|
|
1: "POINTS",
|
|
}
|
|
var ReadResponse_FrameType_value = map[string]int32{
|
|
"SERIES": 0,
|
|
"POINTS": 1,
|
|
}
|
|
|
|
func (x ReadResponse_FrameType) String() string {
|
|
return proto.EnumName(ReadResponse_FrameType_name, int32(x))
|
|
}
|
|
func (ReadResponse_FrameType) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptorStorage, []int{3, 0}
|
|
}
|
|
|
|
type ReadResponse_DataType int32
|
|
|
|
const (
|
|
DataTypeFloat ReadResponse_DataType = 0
|
|
DataTypeInteger ReadResponse_DataType = 1
|
|
DataTypeUnsigned ReadResponse_DataType = 2
|
|
DataTypeBoolean ReadResponse_DataType = 3
|
|
DataTypeString ReadResponse_DataType = 4
|
|
)
|
|
|
|
var ReadResponse_DataType_name = map[int32]string{
|
|
0: "FLOAT",
|
|
1: "INTEGER",
|
|
2: "UNSIGNED",
|
|
3: "BOOLEAN",
|
|
4: "STRING",
|
|
}
|
|
var ReadResponse_DataType_value = map[string]int32{
|
|
"FLOAT": 0,
|
|
"INTEGER": 1,
|
|
"UNSIGNED": 2,
|
|
"BOOLEAN": 3,
|
|
"STRING": 4,
|
|
}
|
|
|
|
func (x ReadResponse_DataType) String() string {
|
|
return proto.EnumName(ReadResponse_DataType_name, int32(x))
|
|
}
|
|
func (ReadResponse_DataType) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptorStorage, []int{3, 1}
|
|
}
|
|
|
|
// Request message for Storage.Read.
|
|
type ReadRequest struct {
|
|
// Database specifies the name of the database to issue the read request.
|
|
Database string `protobuf:"bytes,1,opt,name=database,proto3" json:"database,omitempty"`
|
|
TimestampRange TimestampRange `protobuf:"bytes,2,opt,name=timestamp_range,json=timestampRange" json:"timestamp_range"`
|
|
// Descending indicates whether points should be returned in descending order.
|
|
Descending bool `protobuf:"varint,3,opt,name=descending,proto3" json:"descending,omitempty"`
|
|
// Grouping specifies a list of tags used to order the data
|
|
Grouping []string `protobuf:"bytes,4,rep,name=grouping" json:"grouping,omitempty"`
|
|
// Aggregate specifies an optional aggregate to apply to the data.
|
|
// TODO(sgc): switch to slice for multiple aggregates in a single request
|
|
Aggregate *Aggregate `protobuf:"bytes,9,opt,name=aggregate" json:"aggregate,omitempty"`
|
|
Predicate *Predicate `protobuf:"bytes,5,opt,name=predicate" json:"predicate,omitempty"`
|
|
// SeriesLimit determines the maximum number of series to be returned for the request. Specify 0 for no limit.
|
|
SeriesLimit uint64 `protobuf:"varint,6,opt,name=series_limit,json=seriesLimit,proto3" json:"series_limit,omitempty"`
|
|
// SeriesOffset determines how many series to skip before processing the request.
|
|
SeriesOffset uint64 `protobuf:"varint,7,opt,name=series_offset,json=seriesOffset,proto3" json:"series_offset,omitempty"`
|
|
// PointsLimit determines the maximum number of values per series to be returned for the request.
|
|
// Specify 0 for no limit.
|
|
PointsLimit uint64 `protobuf:"varint,8,opt,name=points_limit,json=pointsLimit,proto3" json:"points_limit,omitempty"`
|
|
// Trace contains opaque data if a trace is active.
|
|
Trace map[string]string `protobuf:"bytes,10,rep,name=trace" json:"trace,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
|
}
|
|
|
|
func (m *ReadRequest) Reset() { *m = ReadRequest{} }
|
|
func (m *ReadRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*ReadRequest) ProtoMessage() {}
|
|
func (*ReadRequest) Descriptor() ([]byte, []int) { return fileDescriptorStorage, []int{0} }
|
|
|
|
type Aggregate struct {
|
|
Type Aggregate_AggregateType `protobuf:"varint,1,opt,name=type,proto3,enum=storage.Aggregate_AggregateType" json:"type,omitempty"`
|
|
}
|
|
|
|
func (m *Aggregate) Reset() { *m = Aggregate{} }
|
|
func (m *Aggregate) String() string { return proto.CompactTextString(m) }
|
|
func (*Aggregate) ProtoMessage() {}
|
|
func (*Aggregate) Descriptor() ([]byte, []int) { return fileDescriptorStorage, []int{1} }
|
|
|
|
type Tag struct {
|
|
Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
|
|
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
|
|
}
|
|
|
|
func (m *Tag) Reset() { *m = Tag{} }
|
|
func (m *Tag) String() string { return proto.CompactTextString(m) }
|
|
func (*Tag) ProtoMessage() {}
|
|
func (*Tag) Descriptor() ([]byte, []int) { return fileDescriptorStorage, []int{2} }
|
|
|
|
// Response message for Storage.Read.
|
|
type ReadResponse struct {
|
|
Frames []ReadResponse_Frame `protobuf:"bytes,1,rep,name=frames" json:"frames"`
|
|
}
|
|
|
|
func (m *ReadResponse) Reset() { *m = ReadResponse{} }
|
|
func (m *ReadResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*ReadResponse) ProtoMessage() {}
|
|
func (*ReadResponse) Descriptor() ([]byte, []int) { return fileDescriptorStorage, []int{3} }
|
|
|
|
type ReadResponse_Frame struct {
|
|
// Types that are valid to be assigned to Data:
|
|
// *ReadResponse_Frame_Series
|
|
// *ReadResponse_Frame_FloatPoints
|
|
// *ReadResponse_Frame_IntegerPoints
|
|
// *ReadResponse_Frame_UnsignedPoints
|
|
// *ReadResponse_Frame_BooleanPoints
|
|
// *ReadResponse_Frame_StringPoints
|
|
Data isReadResponse_Frame_Data `protobuf_oneof:"data"`
|
|
}
|
|
|
|
func (m *ReadResponse_Frame) Reset() { *m = ReadResponse_Frame{} }
|
|
func (m *ReadResponse_Frame) String() string { return proto.CompactTextString(m) }
|
|
func (*ReadResponse_Frame) ProtoMessage() {}
|
|
func (*ReadResponse_Frame) Descriptor() ([]byte, []int) { return fileDescriptorStorage, []int{3, 0} }
|
|
|
|
type isReadResponse_Frame_Data interface {
|
|
isReadResponse_Frame_Data()
|
|
MarshalTo([]byte) (int, error)
|
|
Size() int
|
|
}
|
|
|
|
type ReadResponse_Frame_Series struct {
|
|
Series *ReadResponse_SeriesFrame `protobuf:"bytes,1,opt,name=series,oneof"`
|
|
}
|
|
type ReadResponse_Frame_FloatPoints struct {
|
|
FloatPoints *ReadResponse_FloatPointsFrame `protobuf:"bytes,2,opt,name=float_points,json=floatPoints,oneof"`
|
|
}
|
|
type ReadResponse_Frame_IntegerPoints struct {
|
|
IntegerPoints *ReadResponse_IntegerPointsFrame `protobuf:"bytes,3,opt,name=integer_points,json=integerPoints,oneof"`
|
|
}
|
|
type ReadResponse_Frame_UnsignedPoints struct {
|
|
UnsignedPoints *ReadResponse_UnsignedPointsFrame `protobuf:"bytes,4,opt,name=unsigned_points,json=unsignedPoints,oneof"`
|
|
}
|
|
type ReadResponse_Frame_BooleanPoints struct {
|
|
BooleanPoints *ReadResponse_BooleanPointsFrame `protobuf:"bytes,5,opt,name=boolean_points,json=booleanPoints,oneof"`
|
|
}
|
|
type ReadResponse_Frame_StringPoints struct {
|
|
StringPoints *ReadResponse_StringPointsFrame `protobuf:"bytes,6,opt,name=string_points,json=stringPoints,oneof"`
|
|
}
|
|
|
|
func (*ReadResponse_Frame_Series) isReadResponse_Frame_Data() {}
|
|
func (*ReadResponse_Frame_FloatPoints) isReadResponse_Frame_Data() {}
|
|
func (*ReadResponse_Frame_IntegerPoints) isReadResponse_Frame_Data() {}
|
|
func (*ReadResponse_Frame_UnsignedPoints) isReadResponse_Frame_Data() {}
|
|
func (*ReadResponse_Frame_BooleanPoints) isReadResponse_Frame_Data() {}
|
|
func (*ReadResponse_Frame_StringPoints) isReadResponse_Frame_Data() {}
|
|
|
|
func (m *ReadResponse_Frame) GetData() isReadResponse_Frame_Data {
|
|
if m != nil {
|
|
return m.Data
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ReadResponse_Frame) GetSeries() *ReadResponse_SeriesFrame {
|
|
if x, ok := m.GetData().(*ReadResponse_Frame_Series); ok {
|
|
return x.Series
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ReadResponse_Frame) GetFloatPoints() *ReadResponse_FloatPointsFrame {
|
|
if x, ok := m.GetData().(*ReadResponse_Frame_FloatPoints); ok {
|
|
return x.FloatPoints
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ReadResponse_Frame) GetIntegerPoints() *ReadResponse_IntegerPointsFrame {
|
|
if x, ok := m.GetData().(*ReadResponse_Frame_IntegerPoints); ok {
|
|
return x.IntegerPoints
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ReadResponse_Frame) GetUnsignedPoints() *ReadResponse_UnsignedPointsFrame {
|
|
if x, ok := m.GetData().(*ReadResponse_Frame_UnsignedPoints); ok {
|
|
return x.UnsignedPoints
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ReadResponse_Frame) GetBooleanPoints() *ReadResponse_BooleanPointsFrame {
|
|
if x, ok := m.GetData().(*ReadResponse_Frame_BooleanPoints); ok {
|
|
return x.BooleanPoints
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ReadResponse_Frame) GetStringPoints() *ReadResponse_StringPointsFrame {
|
|
if x, ok := m.GetData().(*ReadResponse_Frame_StringPoints); ok {
|
|
return x.StringPoints
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// XXX_OneofFuncs is for the internal use of the proto package.
|
|
func (*ReadResponse_Frame) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
|
|
return _ReadResponse_Frame_OneofMarshaler, _ReadResponse_Frame_OneofUnmarshaler, _ReadResponse_Frame_OneofSizer, []interface{}{
|
|
(*ReadResponse_Frame_Series)(nil),
|
|
(*ReadResponse_Frame_FloatPoints)(nil),
|
|
(*ReadResponse_Frame_IntegerPoints)(nil),
|
|
(*ReadResponse_Frame_UnsignedPoints)(nil),
|
|
(*ReadResponse_Frame_BooleanPoints)(nil),
|
|
(*ReadResponse_Frame_StringPoints)(nil),
|
|
}
|
|
}
|
|
|
|
func _ReadResponse_Frame_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
|
|
m := msg.(*ReadResponse_Frame)
|
|
// data
|
|
switch x := m.Data.(type) {
|
|
case *ReadResponse_Frame_Series:
|
|
_ = b.EncodeVarint(1<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.Series); err != nil {
|
|
return err
|
|
}
|
|
case *ReadResponse_Frame_FloatPoints:
|
|
_ = b.EncodeVarint(2<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.FloatPoints); err != nil {
|
|
return err
|
|
}
|
|
case *ReadResponse_Frame_IntegerPoints:
|
|
_ = b.EncodeVarint(3<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.IntegerPoints); err != nil {
|
|
return err
|
|
}
|
|
case *ReadResponse_Frame_UnsignedPoints:
|
|
_ = b.EncodeVarint(4<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.UnsignedPoints); err != nil {
|
|
return err
|
|
}
|
|
case *ReadResponse_Frame_BooleanPoints:
|
|
_ = b.EncodeVarint(5<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.BooleanPoints); err != nil {
|
|
return err
|
|
}
|
|
case *ReadResponse_Frame_StringPoints:
|
|
_ = b.EncodeVarint(6<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.StringPoints); err != nil {
|
|
return err
|
|
}
|
|
case nil:
|
|
default:
|
|
return fmt.Errorf("ReadResponse_Frame.Data has unexpected type %T", x)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _ReadResponse_Frame_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
|
|
m := msg.(*ReadResponse_Frame)
|
|
switch tag {
|
|
case 1: // data.series
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(ReadResponse_SeriesFrame)
|
|
err := b.DecodeMessage(msg)
|
|
m.Data = &ReadResponse_Frame_Series{msg}
|
|
return true, err
|
|
case 2: // data.float_points
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(ReadResponse_FloatPointsFrame)
|
|
err := b.DecodeMessage(msg)
|
|
m.Data = &ReadResponse_Frame_FloatPoints{msg}
|
|
return true, err
|
|
case 3: // data.integer_points
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(ReadResponse_IntegerPointsFrame)
|
|
err := b.DecodeMessage(msg)
|
|
m.Data = &ReadResponse_Frame_IntegerPoints{msg}
|
|
return true, err
|
|
case 4: // data.unsigned_points
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(ReadResponse_UnsignedPointsFrame)
|
|
err := b.DecodeMessage(msg)
|
|
m.Data = &ReadResponse_Frame_UnsignedPoints{msg}
|
|
return true, err
|
|
case 5: // data.boolean_points
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(ReadResponse_BooleanPointsFrame)
|
|
err := b.DecodeMessage(msg)
|
|
m.Data = &ReadResponse_Frame_BooleanPoints{msg}
|
|
return true, err
|
|
case 6: // data.string_points
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(ReadResponse_StringPointsFrame)
|
|
err := b.DecodeMessage(msg)
|
|
m.Data = &ReadResponse_Frame_StringPoints{msg}
|
|
return true, err
|
|
default:
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
func _ReadResponse_Frame_OneofSizer(msg proto.Message) (n int) {
|
|
m := msg.(*ReadResponse_Frame)
|
|
// data
|
|
switch x := m.Data.(type) {
|
|
case *ReadResponse_Frame_Series:
|
|
s := proto.Size(x.Series)
|
|
n += proto.SizeVarint(1<<3 | proto.WireBytes)
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *ReadResponse_Frame_FloatPoints:
|
|
s := proto.Size(x.FloatPoints)
|
|
n += proto.SizeVarint(2<<3 | proto.WireBytes)
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *ReadResponse_Frame_IntegerPoints:
|
|
s := proto.Size(x.IntegerPoints)
|
|
n += proto.SizeVarint(3<<3 | proto.WireBytes)
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *ReadResponse_Frame_UnsignedPoints:
|
|
s := proto.Size(x.UnsignedPoints)
|
|
n += proto.SizeVarint(4<<3 | proto.WireBytes)
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *ReadResponse_Frame_BooleanPoints:
|
|
s := proto.Size(x.BooleanPoints)
|
|
n += proto.SizeVarint(5<<3 | proto.WireBytes)
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *ReadResponse_Frame_StringPoints:
|
|
s := proto.Size(x.StringPoints)
|
|
n += proto.SizeVarint(6<<3 | proto.WireBytes)
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case nil:
|
|
default:
|
|
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
|
|
}
|
|
return n
|
|
}
|
|
|
|
type ReadResponse_SeriesFrame struct {
|
|
Tags []Tag `protobuf:"bytes,1,rep,name=tags" json:"tags"`
|
|
DataType ReadResponse_DataType `protobuf:"varint,2,opt,name=data_type,json=dataType,proto3,enum=storage.ReadResponse_DataType" json:"data_type,omitempty"`
|
|
}
|
|
|
|
func (m *ReadResponse_SeriesFrame) Reset() { *m = ReadResponse_SeriesFrame{} }
|
|
func (m *ReadResponse_SeriesFrame) String() string { return proto.CompactTextString(m) }
|
|
func (*ReadResponse_SeriesFrame) ProtoMessage() {}
|
|
func (*ReadResponse_SeriesFrame) Descriptor() ([]byte, []int) {
|
|
return fileDescriptorStorage, []int{3, 1}
|
|
}
|
|
|
|
type ReadResponse_FloatPointsFrame struct {
|
|
Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps" json:"timestamps,omitempty"`
|
|
Values []float64 `protobuf:"fixed64,2,rep,packed,name=values" json:"values,omitempty"`
|
|
}
|
|
|
|
func (m *ReadResponse_FloatPointsFrame) Reset() { *m = ReadResponse_FloatPointsFrame{} }
|
|
func (m *ReadResponse_FloatPointsFrame) String() string { return proto.CompactTextString(m) }
|
|
func (*ReadResponse_FloatPointsFrame) ProtoMessage() {}
|
|
func (*ReadResponse_FloatPointsFrame) Descriptor() ([]byte, []int) {
|
|
return fileDescriptorStorage, []int{3, 2}
|
|
}
|
|
|
|
type ReadResponse_IntegerPointsFrame struct {
|
|
Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps" json:"timestamps,omitempty"`
|
|
Values []int64 `protobuf:"varint,2,rep,packed,name=values" json:"values,omitempty"`
|
|
}
|
|
|
|
func (m *ReadResponse_IntegerPointsFrame) Reset() { *m = ReadResponse_IntegerPointsFrame{} }
|
|
func (m *ReadResponse_IntegerPointsFrame) String() string { return proto.CompactTextString(m) }
|
|
func (*ReadResponse_IntegerPointsFrame) ProtoMessage() {}
|
|
func (*ReadResponse_IntegerPointsFrame) Descriptor() ([]byte, []int) {
|
|
return fileDescriptorStorage, []int{3, 3}
|
|
}
|
|
|
|
type ReadResponse_UnsignedPointsFrame struct {
|
|
Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps" json:"timestamps,omitempty"`
|
|
Values []uint64 `protobuf:"varint,2,rep,packed,name=values" json:"values,omitempty"`
|
|
}
|
|
|
|
func (m *ReadResponse_UnsignedPointsFrame) Reset() { *m = ReadResponse_UnsignedPointsFrame{} }
|
|
func (m *ReadResponse_UnsignedPointsFrame) String() string { return proto.CompactTextString(m) }
|
|
func (*ReadResponse_UnsignedPointsFrame) ProtoMessage() {}
|
|
func (*ReadResponse_UnsignedPointsFrame) Descriptor() ([]byte, []int) {
|
|
return fileDescriptorStorage, []int{3, 4}
|
|
}
|
|
|
|
type ReadResponse_BooleanPointsFrame struct {
|
|
Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps" json:"timestamps,omitempty"`
|
|
Values []bool `protobuf:"varint,2,rep,packed,name=values" json:"values,omitempty"`
|
|
}
|
|
|
|
func (m *ReadResponse_BooleanPointsFrame) Reset() { *m = ReadResponse_BooleanPointsFrame{} }
|
|
func (m *ReadResponse_BooleanPointsFrame) String() string { return proto.CompactTextString(m) }
|
|
func (*ReadResponse_BooleanPointsFrame) ProtoMessage() {}
|
|
func (*ReadResponse_BooleanPointsFrame) Descriptor() ([]byte, []int) {
|
|
return fileDescriptorStorage, []int{3, 5}
|
|
}
|
|
|
|
type ReadResponse_StringPointsFrame struct {
|
|
Timestamps []int64 `protobuf:"fixed64,1,rep,packed,name=timestamps" json:"timestamps,omitempty"`
|
|
Values []string `protobuf:"bytes,2,rep,name=values" json:"values,omitempty"`
|
|
}
|
|
|
|
func (m *ReadResponse_StringPointsFrame) Reset() { *m = ReadResponse_StringPointsFrame{} }
|
|
func (m *ReadResponse_StringPointsFrame) String() string { return proto.CompactTextString(m) }
|
|
func (*ReadResponse_StringPointsFrame) ProtoMessage() {}
|
|
func (*ReadResponse_StringPointsFrame) Descriptor() ([]byte, []int) {
|
|
return fileDescriptorStorage, []int{3, 6}
|
|
}
|
|
|
|
type CapabilitiesResponse struct {
|
|
Caps map[string]string `protobuf:"bytes,1,rep,name=caps" json:"caps,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
|
}
|
|
|
|
func (m *CapabilitiesResponse) Reset() { *m = CapabilitiesResponse{} }
|
|
func (m *CapabilitiesResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*CapabilitiesResponse) ProtoMessage() {}
|
|
func (*CapabilitiesResponse) Descriptor() ([]byte, []int) { return fileDescriptorStorage, []int{4} }
|
|
|
|
type HintsResponse struct {
|
|
}
|
|
|
|
func (m *HintsResponse) Reset() { *m = HintsResponse{} }
|
|
func (m *HintsResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*HintsResponse) ProtoMessage() {}
|
|
func (*HintsResponse) Descriptor() ([]byte, []int) { return fileDescriptorStorage, []int{5} }
|
|
|
|
// Specifies a continuous range of nanosecond timestamps.
|
|
type TimestampRange struct {
|
|
// Start defines the inclusive lower bound.
|
|
Start int64 `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"`
|
|
// End defines the inclusive upper bound.
|
|
End int64 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"`
|
|
}
|
|
|
|
func (m *TimestampRange) Reset() { *m = TimestampRange{} }
|
|
func (m *TimestampRange) String() string { return proto.CompactTextString(m) }
|
|
func (*TimestampRange) ProtoMessage() {}
|
|
func (*TimestampRange) Descriptor() ([]byte, []int) { return fileDescriptorStorage, []int{6} }
|
|
|
|
func init() {
|
|
proto.RegisterType((*ReadRequest)(nil), "storage.ReadRequest")
|
|
proto.RegisterType((*Aggregate)(nil), "storage.Aggregate")
|
|
proto.RegisterType((*Tag)(nil), "storage.Tag")
|
|
proto.RegisterType((*ReadResponse)(nil), "storage.ReadResponse")
|
|
proto.RegisterType((*ReadResponse_Frame)(nil), "storage.ReadResponse.Frame")
|
|
proto.RegisterType((*ReadResponse_SeriesFrame)(nil), "storage.ReadResponse.SeriesFrame")
|
|
proto.RegisterType((*ReadResponse_FloatPointsFrame)(nil), "storage.ReadResponse.FloatPointsFrame")
|
|
proto.RegisterType((*ReadResponse_IntegerPointsFrame)(nil), "storage.ReadResponse.IntegerPointsFrame")
|
|
proto.RegisterType((*ReadResponse_UnsignedPointsFrame)(nil), "storage.ReadResponse.UnsignedPointsFrame")
|
|
proto.RegisterType((*ReadResponse_BooleanPointsFrame)(nil), "storage.ReadResponse.BooleanPointsFrame")
|
|
proto.RegisterType((*ReadResponse_StringPointsFrame)(nil), "storage.ReadResponse.StringPointsFrame")
|
|
proto.RegisterType((*CapabilitiesResponse)(nil), "storage.CapabilitiesResponse")
|
|
proto.RegisterType((*HintsResponse)(nil), "storage.HintsResponse")
|
|
proto.RegisterType((*TimestampRange)(nil), "storage.TimestampRange")
|
|
proto.RegisterEnum("storage.Aggregate_AggregateType", Aggregate_AggregateType_name, Aggregate_AggregateType_value)
|
|
proto.RegisterEnum("storage.ReadResponse_FrameType", ReadResponse_FrameType_name, ReadResponse_FrameType_value)
|
|
proto.RegisterEnum("storage.ReadResponse_DataType", ReadResponse_DataType_name, ReadResponse_DataType_value)
|
|
}
|
|
func (m *ReadRequest) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ReadRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Database) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(m.Database)))
|
|
i += copy(dAtA[i:], m.Database)
|
|
}
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.TimestampRange.Size()))
|
|
n1, err := m.TimestampRange.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n1
|
|
if m.Descending {
|
|
dAtA[i] = 0x18
|
|
i++
|
|
if m.Descending {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if len(m.Grouping) > 0 {
|
|
for _, s := range m.Grouping {
|
|
dAtA[i] = 0x22
|
|
i++
|
|
l = len(s)
|
|
for l >= 1<<7 {
|
|
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
|
|
l >>= 7
|
|
i++
|
|
}
|
|
dAtA[i] = uint8(l)
|
|
i++
|
|
i += copy(dAtA[i:], s)
|
|
}
|
|
}
|
|
if m.Predicate != nil {
|
|
dAtA[i] = 0x2a
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.Predicate.Size()))
|
|
n2, err := m.Predicate.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n2
|
|
}
|
|
if m.SeriesLimit != 0 {
|
|
dAtA[i] = 0x30
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.SeriesLimit))
|
|
}
|
|
if m.SeriesOffset != 0 {
|
|
dAtA[i] = 0x38
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.SeriesOffset))
|
|
}
|
|
if m.PointsLimit != 0 {
|
|
dAtA[i] = 0x40
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.PointsLimit))
|
|
}
|
|
if m.Aggregate != nil {
|
|
dAtA[i] = 0x4a
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.Aggregate.Size()))
|
|
n3, err := m.Aggregate.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n3
|
|
}
|
|
if len(m.Trace) > 0 {
|
|
for k, _ := range m.Trace {
|
|
dAtA[i] = 0x52
|
|
i++
|
|
v := m.Trace[k]
|
|
mapSize := 1 + len(k) + sovStorage(uint64(len(k))) + 1 + len(v) + sovStorage(uint64(len(v)))
|
|
i = encodeVarintStorage(dAtA, i, uint64(mapSize))
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(k)))
|
|
i += copy(dAtA[i:], k)
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(v)))
|
|
i += copy(dAtA[i:], v)
|
|
}
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *Aggregate) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *Aggregate) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Type != 0 {
|
|
dAtA[i] = 0x8
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.Type))
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *Tag) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *Tag) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Key) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(m.Key)))
|
|
i += copy(dAtA[i:], m.Key)
|
|
}
|
|
if len(m.Value) > 0 {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(m.Value)))
|
|
i += copy(dAtA[i:], m.Value)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ReadResponse) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ReadResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Frames) > 0 {
|
|
for _, msg := range m.Frames {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ReadResponse_Frame) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ReadResponse_Frame) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Data != nil {
|
|
nn4, err := m.Data.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += nn4
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ReadResponse_Frame_Series) MarshalTo(dAtA []byte) (int, error) {
|
|
i := 0
|
|
if m.Series != nil {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.Series.Size()))
|
|
n5, err := m.Series.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n5
|
|
}
|
|
return i, nil
|
|
}
|
|
func (m *ReadResponse_Frame_FloatPoints) MarshalTo(dAtA []byte) (int, error) {
|
|
i := 0
|
|
if m.FloatPoints != nil {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.FloatPoints.Size()))
|
|
n6, err := m.FloatPoints.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n6
|
|
}
|
|
return i, nil
|
|
}
|
|
func (m *ReadResponse_Frame_IntegerPoints) MarshalTo(dAtA []byte) (int, error) {
|
|
i := 0
|
|
if m.IntegerPoints != nil {
|
|
dAtA[i] = 0x1a
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.IntegerPoints.Size()))
|
|
n7, err := m.IntegerPoints.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n7
|
|
}
|
|
return i, nil
|
|
}
|
|
func (m *ReadResponse_Frame_UnsignedPoints) MarshalTo(dAtA []byte) (int, error) {
|
|
i := 0
|
|
if m.UnsignedPoints != nil {
|
|
dAtA[i] = 0x22
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.UnsignedPoints.Size()))
|
|
n8, err := m.UnsignedPoints.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n8
|
|
}
|
|
return i, nil
|
|
}
|
|
func (m *ReadResponse_Frame_BooleanPoints) MarshalTo(dAtA []byte) (int, error) {
|
|
i := 0
|
|
if m.BooleanPoints != nil {
|
|
dAtA[i] = 0x2a
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.BooleanPoints.Size()))
|
|
n9, err := m.BooleanPoints.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n9
|
|
}
|
|
return i, nil
|
|
}
|
|
func (m *ReadResponse_Frame_StringPoints) MarshalTo(dAtA []byte) (int, error) {
|
|
i := 0
|
|
if m.StringPoints != nil {
|
|
dAtA[i] = 0x32
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.StringPoints.Size()))
|
|
n10, err := m.StringPoints.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n10
|
|
}
|
|
return i, nil
|
|
}
|
|
func (m *ReadResponse_SeriesFrame) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ReadResponse_SeriesFrame) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Tags) > 0 {
|
|
for _, msg := range m.Tags {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if m.DataType != 0 {
|
|
dAtA[i] = 0x10
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.DataType))
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ReadResponse_FloatPointsFrame) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ReadResponse_FloatPointsFrame) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Timestamps) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(m.Timestamps)*8))
|
|
for _, num := range m.Timestamps {
|
|
dAtA[i] = uint8(num)
|
|
i++
|
|
dAtA[i] = uint8(num >> 8)
|
|
i++
|
|
dAtA[i] = uint8(num >> 16)
|
|
i++
|
|
dAtA[i] = uint8(num >> 24)
|
|
i++
|
|
dAtA[i] = uint8(num >> 32)
|
|
i++
|
|
dAtA[i] = uint8(num >> 40)
|
|
i++
|
|
dAtA[i] = uint8(num >> 48)
|
|
i++
|
|
dAtA[i] = uint8(num >> 56)
|
|
i++
|
|
}
|
|
}
|
|
if len(m.Values) > 0 {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(m.Values)*8))
|
|
for _, num := range m.Values {
|
|
f11 := math.Float64bits(float64(num))
|
|
dAtA[i] = uint8(f11)
|
|
i++
|
|
dAtA[i] = uint8(f11 >> 8)
|
|
i++
|
|
dAtA[i] = uint8(f11 >> 16)
|
|
i++
|
|
dAtA[i] = uint8(f11 >> 24)
|
|
i++
|
|
dAtA[i] = uint8(f11 >> 32)
|
|
i++
|
|
dAtA[i] = uint8(f11 >> 40)
|
|
i++
|
|
dAtA[i] = uint8(f11 >> 48)
|
|
i++
|
|
dAtA[i] = uint8(f11 >> 56)
|
|
i++
|
|
}
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ReadResponse_IntegerPointsFrame) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ReadResponse_IntegerPointsFrame) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Timestamps) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(m.Timestamps)*8))
|
|
for _, num := range m.Timestamps {
|
|
dAtA[i] = uint8(num)
|
|
i++
|
|
dAtA[i] = uint8(num >> 8)
|
|
i++
|
|
dAtA[i] = uint8(num >> 16)
|
|
i++
|
|
dAtA[i] = uint8(num >> 24)
|
|
i++
|
|
dAtA[i] = uint8(num >> 32)
|
|
i++
|
|
dAtA[i] = uint8(num >> 40)
|
|
i++
|
|
dAtA[i] = uint8(num >> 48)
|
|
i++
|
|
dAtA[i] = uint8(num >> 56)
|
|
i++
|
|
}
|
|
}
|
|
if len(m.Values) > 0 {
|
|
dAtA13 := make([]byte, len(m.Values)*10)
|
|
var j12 int
|
|
for _, num1 := range m.Values {
|
|
num := uint64(num1)
|
|
for num >= 1<<7 {
|
|
dAtA13[j12] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j12++
|
|
}
|
|
dAtA13[j12] = uint8(num)
|
|
j12++
|
|
}
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(j12))
|
|
i += copy(dAtA[i:], dAtA13[:j12])
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ReadResponse_UnsignedPointsFrame) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ReadResponse_UnsignedPointsFrame) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Timestamps) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(m.Timestamps)*8))
|
|
for _, num := range m.Timestamps {
|
|
dAtA[i] = uint8(num)
|
|
i++
|
|
dAtA[i] = uint8(num >> 8)
|
|
i++
|
|
dAtA[i] = uint8(num >> 16)
|
|
i++
|
|
dAtA[i] = uint8(num >> 24)
|
|
i++
|
|
dAtA[i] = uint8(num >> 32)
|
|
i++
|
|
dAtA[i] = uint8(num >> 40)
|
|
i++
|
|
dAtA[i] = uint8(num >> 48)
|
|
i++
|
|
dAtA[i] = uint8(num >> 56)
|
|
i++
|
|
}
|
|
}
|
|
if len(m.Values) > 0 {
|
|
dAtA15 := make([]byte, len(m.Values)*10)
|
|
var j14 int
|
|
for _, num := range m.Values {
|
|
for num >= 1<<7 {
|
|
dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j14++
|
|
}
|
|
dAtA15[j14] = uint8(num)
|
|
j14++
|
|
}
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(j14))
|
|
i += copy(dAtA[i:], dAtA15[:j14])
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ReadResponse_BooleanPointsFrame) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ReadResponse_BooleanPointsFrame) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Timestamps) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(m.Timestamps)*8))
|
|
for _, num := range m.Timestamps {
|
|
dAtA[i] = uint8(num)
|
|
i++
|
|
dAtA[i] = uint8(num >> 8)
|
|
i++
|
|
dAtA[i] = uint8(num >> 16)
|
|
i++
|
|
dAtA[i] = uint8(num >> 24)
|
|
i++
|
|
dAtA[i] = uint8(num >> 32)
|
|
i++
|
|
dAtA[i] = uint8(num >> 40)
|
|
i++
|
|
dAtA[i] = uint8(num >> 48)
|
|
i++
|
|
dAtA[i] = uint8(num >> 56)
|
|
i++
|
|
}
|
|
}
|
|
if len(m.Values) > 0 {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(m.Values)))
|
|
for _, b := range m.Values {
|
|
if b {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ReadResponse_StringPointsFrame) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ReadResponse_StringPointsFrame) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Timestamps) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(m.Timestamps)*8))
|
|
for _, num := range m.Timestamps {
|
|
dAtA[i] = uint8(num)
|
|
i++
|
|
dAtA[i] = uint8(num >> 8)
|
|
i++
|
|
dAtA[i] = uint8(num >> 16)
|
|
i++
|
|
dAtA[i] = uint8(num >> 24)
|
|
i++
|
|
dAtA[i] = uint8(num >> 32)
|
|
i++
|
|
dAtA[i] = uint8(num >> 40)
|
|
i++
|
|
dAtA[i] = uint8(num >> 48)
|
|
i++
|
|
dAtA[i] = uint8(num >> 56)
|
|
i++
|
|
}
|
|
}
|
|
if len(m.Values) > 0 {
|
|
for _, s := range m.Values {
|
|
dAtA[i] = 0x12
|
|
i++
|
|
l = len(s)
|
|
for l >= 1<<7 {
|
|
dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
|
|
l >>= 7
|
|
i++
|
|
}
|
|
dAtA[i] = uint8(l)
|
|
i++
|
|
i += copy(dAtA[i:], s)
|
|
}
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *CapabilitiesResponse) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *CapabilitiesResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Caps) > 0 {
|
|
for k, _ := range m.Caps {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
v := m.Caps[k]
|
|
mapSize := 1 + len(k) + sovStorage(uint64(len(k))) + 1 + len(v) + sovStorage(uint64(len(v)))
|
|
i = encodeVarintStorage(dAtA, i, uint64(mapSize))
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(k)))
|
|
i += copy(dAtA[i:], k)
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(len(v)))
|
|
i += copy(dAtA[i:], v)
|
|
}
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *HintsResponse) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *HintsResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
return i, nil
|
|
}
|
|
|
|
func (m *TimestampRange) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalTo(dAtA)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *TimestampRange) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Start != 0 {
|
|
dAtA[i] = 0x8
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.Start))
|
|
}
|
|
if m.End != 0 {
|
|
dAtA[i] = 0x10
|
|
i++
|
|
i = encodeVarintStorage(dAtA, i, uint64(m.End))
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func encodeFixed64Storage(dAtA []byte, offset int, v uint64) int {
|
|
dAtA[offset] = uint8(v)
|
|
dAtA[offset+1] = uint8(v >> 8)
|
|
dAtA[offset+2] = uint8(v >> 16)
|
|
dAtA[offset+3] = uint8(v >> 24)
|
|
dAtA[offset+4] = uint8(v >> 32)
|
|
dAtA[offset+5] = uint8(v >> 40)
|
|
dAtA[offset+6] = uint8(v >> 48)
|
|
dAtA[offset+7] = uint8(v >> 56)
|
|
return offset + 8
|
|
}
|
|
func encodeFixed32Storage(dAtA []byte, offset int, v uint32) int {
|
|
dAtA[offset] = uint8(v)
|
|
dAtA[offset+1] = uint8(v >> 8)
|
|
dAtA[offset+2] = uint8(v >> 16)
|
|
dAtA[offset+3] = uint8(v >> 24)
|
|
return offset + 4
|
|
}
|
|
func encodeVarintStorage(dAtA []byte, offset int, v uint64) int {
|
|
for v >= 1<<7 {
|
|
dAtA[offset] = uint8(v&0x7f | 0x80)
|
|
v >>= 7
|
|
offset++
|
|
}
|
|
dAtA[offset] = uint8(v)
|
|
return offset + 1
|
|
}
|
|
func (m *ReadRequest) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
l = len(m.Database)
|
|
if l > 0 {
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
l = m.TimestampRange.Size()
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
if m.Descending {
|
|
n += 2
|
|
}
|
|
if len(m.Grouping) > 0 {
|
|
for _, s := range m.Grouping {
|
|
l = len(s)
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
}
|
|
if m.Predicate != nil {
|
|
l = m.Predicate.Size()
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
if m.SeriesLimit != 0 {
|
|
n += 1 + sovStorage(uint64(m.SeriesLimit))
|
|
}
|
|
if m.SeriesOffset != 0 {
|
|
n += 1 + sovStorage(uint64(m.SeriesOffset))
|
|
}
|
|
if m.PointsLimit != 0 {
|
|
n += 1 + sovStorage(uint64(m.PointsLimit))
|
|
}
|
|
if m.Aggregate != nil {
|
|
l = m.Aggregate.Size()
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
if len(m.Trace) > 0 {
|
|
for k, v := range m.Trace {
|
|
_ = k
|
|
_ = v
|
|
mapEntrySize := 1 + len(k) + sovStorage(uint64(len(k))) + 1 + len(v) + sovStorage(uint64(len(v)))
|
|
n += mapEntrySize + 1 + sovStorage(uint64(mapEntrySize))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Aggregate) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Type != 0 {
|
|
n += 1 + sovStorage(uint64(m.Type))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Tag) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
l = len(m.Key)
|
|
if l > 0 {
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
l = len(m.Value)
|
|
if l > 0 {
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ReadResponse) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if len(m.Frames) > 0 {
|
|
for _, e := range m.Frames {
|
|
l = e.Size()
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ReadResponse_Frame) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Data != nil {
|
|
n += m.Data.Size()
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ReadResponse_Frame_Series) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Series != nil {
|
|
l = m.Series.Size()
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *ReadResponse_Frame_FloatPoints) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.FloatPoints != nil {
|
|
l = m.FloatPoints.Size()
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *ReadResponse_Frame_IntegerPoints) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.IntegerPoints != nil {
|
|
l = m.IntegerPoints.Size()
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *ReadResponse_Frame_UnsignedPoints) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.UnsignedPoints != nil {
|
|
l = m.UnsignedPoints.Size()
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *ReadResponse_Frame_BooleanPoints) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.BooleanPoints != nil {
|
|
l = m.BooleanPoints.Size()
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *ReadResponse_Frame_StringPoints) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.StringPoints != nil {
|
|
l = m.StringPoints.Size()
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *ReadResponse_SeriesFrame) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if len(m.Tags) > 0 {
|
|
for _, e := range m.Tags {
|
|
l = e.Size()
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
}
|
|
if m.DataType != 0 {
|
|
n += 1 + sovStorage(uint64(m.DataType))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ReadResponse_FloatPointsFrame) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if len(m.Timestamps) > 0 {
|
|
n += 1 + sovStorage(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8
|
|
}
|
|
if len(m.Values) > 0 {
|
|
n += 1 + sovStorage(uint64(len(m.Values)*8)) + len(m.Values)*8
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ReadResponse_IntegerPointsFrame) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if len(m.Timestamps) > 0 {
|
|
n += 1 + sovStorage(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8
|
|
}
|
|
if len(m.Values) > 0 {
|
|
l = 0
|
|
for _, e := range m.Values {
|
|
l += sovStorage(uint64(e))
|
|
}
|
|
n += 1 + sovStorage(uint64(l)) + l
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ReadResponse_UnsignedPointsFrame) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if len(m.Timestamps) > 0 {
|
|
n += 1 + sovStorage(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8
|
|
}
|
|
if len(m.Values) > 0 {
|
|
l = 0
|
|
for _, e := range m.Values {
|
|
l += sovStorage(uint64(e))
|
|
}
|
|
n += 1 + sovStorage(uint64(l)) + l
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ReadResponse_BooleanPointsFrame) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if len(m.Timestamps) > 0 {
|
|
n += 1 + sovStorage(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8
|
|
}
|
|
if len(m.Values) > 0 {
|
|
n += 1 + sovStorage(uint64(len(m.Values))) + len(m.Values)*1
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ReadResponse_StringPointsFrame) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if len(m.Timestamps) > 0 {
|
|
n += 1 + sovStorage(uint64(len(m.Timestamps)*8)) + len(m.Timestamps)*8
|
|
}
|
|
if len(m.Values) > 0 {
|
|
for _, s := range m.Values {
|
|
l = len(s)
|
|
n += 1 + l + sovStorage(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *CapabilitiesResponse) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if len(m.Caps) > 0 {
|
|
for k, v := range m.Caps {
|
|
_ = k
|
|
_ = v
|
|
mapEntrySize := 1 + len(k) + sovStorage(uint64(len(k))) + 1 + len(v) + sovStorage(uint64(len(v)))
|
|
n += mapEntrySize + 1 + sovStorage(uint64(mapEntrySize))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *HintsResponse) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
return n
|
|
}
|
|
|
|
func (m *TimestampRange) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Start != 0 {
|
|
n += 1 + sovStorage(uint64(m.Start))
|
|
}
|
|
if m.End != 0 {
|
|
n += 1 + sovStorage(uint64(m.End))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func sovStorage(x uint64) (n int) {
|
|
for {
|
|
n++
|
|
x >>= 7
|
|
if x == 0 {
|
|
break
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
func sozStorage(x uint64) (n int) {
|
|
return sovStorage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
|
}
|
|
func (m *ReadRequest) 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 ErrIntOverflowStorage
|
|
}
|
|
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: ReadRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ReadRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
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 ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Database = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field TimestampRange", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := m.TimestampRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Descending", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Descending = bool(v != 0)
|
|
case 4:
|
|
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 ErrIntOverflowStorage
|
|
}
|
|
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 ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Grouping = append(m.Grouping, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Predicate == nil {
|
|
m.Predicate = &Predicate{}
|
|
}
|
|
if err := m.Predicate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 6:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field SeriesLimit", wireType)
|
|
}
|
|
m.SeriesLimit = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.SeriesLimit |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 7:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field SeriesOffset", wireType)
|
|
}
|
|
m.SeriesOffset = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.SeriesOffset |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 8:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field PointsLimit", wireType)
|
|
}
|
|
m.PointsLimit = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.PointsLimit |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 9:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Aggregate", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Aggregate == nil {
|
|
m.Aggregate = &Aggregate{}
|
|
}
|
|
if err := m.Aggregate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 10:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Trace", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Trace == nil {
|
|
m.Trace = make(map[string]string)
|
|
}
|
|
var mapkey string
|
|
var mapvalue string
|
|
for iNdEx < postIndex {
|
|
entryPreIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
if fieldNum == 1 {
|
|
var stringLenmapkey uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLenmapkey |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLenmapkey := int(stringLenmapkey)
|
|
if intStringLenmapkey < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postStringIndexmapkey := iNdEx + intStringLenmapkey
|
|
if postStringIndexmapkey > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
|
|
iNdEx = postStringIndexmapkey
|
|
} else if fieldNum == 2 {
|
|
var stringLenmapvalue uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLenmapvalue |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLenmapvalue := int(stringLenmapvalue)
|
|
if intStringLenmapvalue < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
|
|
if postStringIndexmapvalue > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
|
|
iNdEx = postStringIndexmapvalue
|
|
} else {
|
|
iNdEx = entryPreIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > postIndex {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
m.Trace[mapkey] = mapvalue
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Aggregate) 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 ErrIntOverflowStorage
|
|
}
|
|
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: Aggregate: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Aggregate: 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 ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Type |= (Aggregate_AggregateType(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Tag) 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 ErrIntOverflowStorage
|
|
}
|
|
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: Tag: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Tag: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.Key == nil {
|
|
m.Key = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.Value == nil {
|
|
m.Value = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ReadResponse) 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 ErrIntOverflowStorage
|
|
}
|
|
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: ReadResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ReadResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Frames", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Frames = append(m.Frames, ReadResponse_Frame{})
|
|
if err := m.Frames[len(m.Frames)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ReadResponse_Frame) 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 ErrIntOverflowStorage
|
|
}
|
|
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: Frame: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Frame: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Series", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &ReadResponse_SeriesFrame{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Data = &ReadResponse_Frame_Series{v}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field FloatPoints", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &ReadResponse_FloatPointsFrame{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Data = &ReadResponse_Frame_FloatPoints{v}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field IntegerPoints", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &ReadResponse_IntegerPointsFrame{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Data = &ReadResponse_Frame_IntegerPoints{v}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field UnsignedPoints", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &ReadResponse_UnsignedPointsFrame{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Data = &ReadResponse_Frame_UnsignedPoints{v}
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field BooleanPoints", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &ReadResponse_BooleanPointsFrame{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Data = &ReadResponse_Frame_BooleanPoints{v}
|
|
iNdEx = postIndex
|
|
case 6:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field StringPoints", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &ReadResponse_StringPointsFrame{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Data = &ReadResponse_Frame_StringPoints{v}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ReadResponse_SeriesFrame) 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 ErrIntOverflowStorage
|
|
}
|
|
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: SeriesFrame: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: SeriesFrame: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Tags = append(m.Tags, Tag{})
|
|
if err := m.Tags[len(m.Tags)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field DataType", wireType)
|
|
}
|
|
m.DataType = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.DataType |= (ReadResponse_DataType(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ReadResponse_FloatPointsFrame) 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 ErrIntOverflowStorage
|
|
}
|
|
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: FloatPointsFrame: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: FloatPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType == 1 {
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(dAtA[iNdEx-8])
|
|
v |= int64(dAtA[iNdEx-7]) << 8
|
|
v |= int64(dAtA[iNdEx-6]) << 16
|
|
v |= int64(dAtA[iNdEx-5]) << 24
|
|
v |= int64(dAtA[iNdEx-4]) << 32
|
|
v |= int64(dAtA[iNdEx-3]) << 40
|
|
v |= int64(dAtA[iNdEx-2]) << 48
|
|
v |= int64(dAtA[iNdEx-1]) << 56
|
|
m.Timestamps = append(m.Timestamps, v)
|
|
} else if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(dAtA[iNdEx-8])
|
|
v |= int64(dAtA[iNdEx-7]) << 8
|
|
v |= int64(dAtA[iNdEx-6]) << 16
|
|
v |= int64(dAtA[iNdEx-5]) << 24
|
|
v |= int64(dAtA[iNdEx-4]) << 32
|
|
v |= int64(dAtA[iNdEx-3]) << 40
|
|
v |= int64(dAtA[iNdEx-2]) << 48
|
|
v |= int64(dAtA[iNdEx-1]) << 56
|
|
m.Timestamps = append(m.Timestamps, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
|
|
}
|
|
case 2:
|
|
if wireType == 1 {
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = uint64(dAtA[iNdEx-8])
|
|
v |= uint64(dAtA[iNdEx-7]) << 8
|
|
v |= uint64(dAtA[iNdEx-6]) << 16
|
|
v |= uint64(dAtA[iNdEx-5]) << 24
|
|
v |= uint64(dAtA[iNdEx-4]) << 32
|
|
v |= uint64(dAtA[iNdEx-3]) << 40
|
|
v |= uint64(dAtA[iNdEx-2]) << 48
|
|
v |= uint64(dAtA[iNdEx-1]) << 56
|
|
v2 := float64(math.Float64frombits(v))
|
|
m.Values = append(m.Values, v2)
|
|
} else if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v uint64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = uint64(dAtA[iNdEx-8])
|
|
v |= uint64(dAtA[iNdEx-7]) << 8
|
|
v |= uint64(dAtA[iNdEx-6]) << 16
|
|
v |= uint64(dAtA[iNdEx-5]) << 24
|
|
v |= uint64(dAtA[iNdEx-4]) << 32
|
|
v |= uint64(dAtA[iNdEx-3]) << 40
|
|
v |= uint64(dAtA[iNdEx-2]) << 48
|
|
v |= uint64(dAtA[iNdEx-1]) << 56
|
|
v2 := float64(math.Float64frombits(v))
|
|
m.Values = append(m.Values, v2)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ReadResponse_IntegerPointsFrame) 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 ErrIntOverflowStorage
|
|
}
|
|
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: IntegerPointsFrame: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: IntegerPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType == 1 {
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(dAtA[iNdEx-8])
|
|
v |= int64(dAtA[iNdEx-7]) << 8
|
|
v |= int64(dAtA[iNdEx-6]) << 16
|
|
v |= int64(dAtA[iNdEx-5]) << 24
|
|
v |= int64(dAtA[iNdEx-4]) << 32
|
|
v |= int64(dAtA[iNdEx-3]) << 40
|
|
v |= int64(dAtA[iNdEx-2]) << 48
|
|
v |= int64(dAtA[iNdEx-1]) << 56
|
|
m.Timestamps = append(m.Timestamps, v)
|
|
} else if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(dAtA[iNdEx-8])
|
|
v |= int64(dAtA[iNdEx-7]) << 8
|
|
v |= int64(dAtA[iNdEx-6]) << 16
|
|
v |= int64(dAtA[iNdEx-5]) << 24
|
|
v |= int64(dAtA[iNdEx-4]) << 32
|
|
v |= int64(dAtA[iNdEx-3]) << 40
|
|
v |= int64(dAtA[iNdEx-2]) << 48
|
|
v |= int64(dAtA[iNdEx-1]) << 56
|
|
m.Timestamps = append(m.Timestamps, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
|
|
}
|
|
case 2:
|
|
if wireType == 0 {
|
|
var v int64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Values = append(m.Values, v)
|
|
} else if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Values = append(m.Values, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ReadResponse_UnsignedPointsFrame) 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 ErrIntOverflowStorage
|
|
}
|
|
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: UnsignedPointsFrame: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: UnsignedPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType == 1 {
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(dAtA[iNdEx-8])
|
|
v |= int64(dAtA[iNdEx-7]) << 8
|
|
v |= int64(dAtA[iNdEx-6]) << 16
|
|
v |= int64(dAtA[iNdEx-5]) << 24
|
|
v |= int64(dAtA[iNdEx-4]) << 32
|
|
v |= int64(dAtA[iNdEx-3]) << 40
|
|
v |= int64(dAtA[iNdEx-2]) << 48
|
|
v |= int64(dAtA[iNdEx-1]) << 56
|
|
m.Timestamps = append(m.Timestamps, v)
|
|
} else if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(dAtA[iNdEx-8])
|
|
v |= int64(dAtA[iNdEx-7]) << 8
|
|
v |= int64(dAtA[iNdEx-6]) << 16
|
|
v |= int64(dAtA[iNdEx-5]) << 24
|
|
v |= int64(dAtA[iNdEx-4]) << 32
|
|
v |= int64(dAtA[iNdEx-3]) << 40
|
|
v |= int64(dAtA[iNdEx-2]) << 48
|
|
v |= int64(dAtA[iNdEx-1]) << 56
|
|
m.Timestamps = append(m.Timestamps, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
|
|
}
|
|
case 2:
|
|
if wireType == 0 {
|
|
var v uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Values = append(m.Values, v)
|
|
} else if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Values = append(m.Values, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ReadResponse_BooleanPointsFrame) 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 ErrIntOverflowStorage
|
|
}
|
|
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: BooleanPointsFrame: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BooleanPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType == 1 {
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(dAtA[iNdEx-8])
|
|
v |= int64(dAtA[iNdEx-7]) << 8
|
|
v |= int64(dAtA[iNdEx-6]) << 16
|
|
v |= int64(dAtA[iNdEx-5]) << 24
|
|
v |= int64(dAtA[iNdEx-4]) << 32
|
|
v |= int64(dAtA[iNdEx-3]) << 40
|
|
v |= int64(dAtA[iNdEx-2]) << 48
|
|
v |= int64(dAtA[iNdEx-1]) << 56
|
|
m.Timestamps = append(m.Timestamps, v)
|
|
} else if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(dAtA[iNdEx-8])
|
|
v |= int64(dAtA[iNdEx-7]) << 8
|
|
v |= int64(dAtA[iNdEx-6]) << 16
|
|
v |= int64(dAtA[iNdEx-5]) << 24
|
|
v |= int64(dAtA[iNdEx-4]) << 32
|
|
v |= int64(dAtA[iNdEx-3]) << 40
|
|
v |= int64(dAtA[iNdEx-2]) << 48
|
|
v |= int64(dAtA[iNdEx-1]) << 56
|
|
m.Timestamps = append(m.Timestamps, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
|
|
}
|
|
case 2:
|
|
if wireType == 0 {
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Values = append(m.Values, bool(v != 0))
|
|
} else if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Values = append(m.Values, bool(v != 0))
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ReadResponse_StringPointsFrame) 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 ErrIntOverflowStorage
|
|
}
|
|
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: StringPointsFrame: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: StringPointsFrame: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType == 1 {
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(dAtA[iNdEx-8])
|
|
v |= int64(dAtA[iNdEx-7]) << 8
|
|
v |= int64(dAtA[iNdEx-6]) << 16
|
|
v |= int64(dAtA[iNdEx-5]) << 24
|
|
v |= int64(dAtA[iNdEx-4]) << 32
|
|
v |= int64(dAtA[iNdEx-3]) << 40
|
|
v |= int64(dAtA[iNdEx-2]) << 48
|
|
v |= int64(dAtA[iNdEx-1]) << 56
|
|
m.Timestamps = append(m.Timestamps, v)
|
|
} else if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
packedLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v int64
|
|
if (iNdEx + 8) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += 8
|
|
v = int64(dAtA[iNdEx-8])
|
|
v |= int64(dAtA[iNdEx-7]) << 8
|
|
v |= int64(dAtA[iNdEx-6]) << 16
|
|
v |= int64(dAtA[iNdEx-5]) << 24
|
|
v |= int64(dAtA[iNdEx-4]) << 32
|
|
v |= int64(dAtA[iNdEx-3]) << 40
|
|
v |= int64(dAtA[iNdEx-2]) << 48
|
|
v |= int64(dAtA[iNdEx-1]) << 56
|
|
m.Timestamps = append(m.Timestamps, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Timestamps", wireType)
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
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 ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Values = append(m.Values, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *CapabilitiesResponse) 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 ErrIntOverflowStorage
|
|
}
|
|
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: CapabilitiesResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: CapabilitiesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Caps", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Caps == nil {
|
|
m.Caps = make(map[string]string)
|
|
}
|
|
var mapkey string
|
|
var mapvalue string
|
|
for iNdEx < postIndex {
|
|
entryPreIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
if fieldNum == 1 {
|
|
var stringLenmapkey uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLenmapkey |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLenmapkey := int(stringLenmapkey)
|
|
if intStringLenmapkey < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postStringIndexmapkey := iNdEx + intStringLenmapkey
|
|
if postStringIndexmapkey > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
|
|
iNdEx = postStringIndexmapkey
|
|
} else if fieldNum == 2 {
|
|
var stringLenmapvalue uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLenmapvalue |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLenmapvalue := int(stringLenmapvalue)
|
|
if intStringLenmapvalue < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
|
|
if postStringIndexmapvalue > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
|
|
iNdEx = postStringIndexmapvalue
|
|
} else {
|
|
iNdEx = entryPreIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > postIndex {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
m.Caps[mapkey] = mapvalue
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *HintsResponse) 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 ErrIntOverflowStorage
|
|
}
|
|
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: HintsResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: HintsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *TimestampRange) 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 ErrIntOverflowStorage
|
|
}
|
|
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: TimestampRange: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: TimestampRange: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
|
|
}
|
|
m.Start = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Start |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
|
|
}
|
|
m.End = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.End |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipStorage(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthStorage
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func skipStorage(dAtA []byte) (n int, err error) {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowStorage
|
|
}
|
|
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, ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx++
|
|
if dAtA[iNdEx-1] < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
return iNdEx, nil
|
|
case 1:
|
|
iNdEx += 8
|
|
return iNdEx, nil
|
|
case 2:
|
|
var length int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
length |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx += length
|
|
if length < 0 {
|
|
return 0, ErrInvalidLengthStorage
|
|
}
|
|
return iNdEx, nil
|
|
case 3:
|
|
for {
|
|
var innerWire uint64
|
|
var start int = iNdEx
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowStorage
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
innerWire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
innerWireType := int(innerWire & 0x7)
|
|
if innerWireType == 4 {
|
|
break
|
|
}
|
|
next, err := skipStorage(dAtA[start:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
iNdEx = start + next
|
|
}
|
|
return iNdEx, nil
|
|
case 4:
|
|
return iNdEx, nil
|
|
case 5:
|
|
iNdEx += 4
|
|
return iNdEx, nil
|
|
default:
|
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
|
}
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
var (
|
|
ErrInvalidLengthStorage = fmt.Errorf("proto: negative length found during unmarshaling")
|
|
ErrIntOverflowStorage = fmt.Errorf("proto: integer overflow")
|
|
)
|
|
|
|
func init() { proto.RegisterFile("storage.proto", fileDescriptorStorage) }
|
|
|
|
var fileDescriptorStorage = []byte{
|
|
// 1206 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x41, 0x8f, 0xdb, 0x44,
|
|
0x14, 0xb6, 0xd7, 0x4e, 0x76, 0xf3, 0x92, 0xec, 0x7a, 0xa7, 0xdb, 0x25, 0x72, 0x69, 0xe2, 0xe6,
|
|
0x50, 0xc2, 0xa1, 0x69, 0x15, 0x40, 0x14, 0x2a, 0x24, 0x9a, 0x36, 0xed, 0x2e, 0xdd, 0x26, 0xd5,
|
|
0x24, 0x2b, 0x71, 0x40, 0x5a, 0x26, 0x9b, 0x89, 0x6b, 0x91, 0xd8, 0xc6, 0x9e, 0xa0, 0xee, 0x8d,
|
|
0x23, 0x5a, 0x71, 0xe0, 0xc0, 0x35, 0x27, 0x7e, 0x03, 0x5c, 0x90, 0x38, 0x70, 0xea, 0x91, 0x23,
|
|
0xa7, 0x08, 0xc2, 0x1f, 0x41, 0x33, 0x63, 0x3b, 0xf6, 0x6e, 0x5a, 0x69, 0x2f, 0xd1, 0xbc, 0xf7,
|
|
0xbe, 0xf7, 0xbd, 0xf7, 0x66, 0xde, 0x7b, 0x31, 0x94, 0x43, 0xe6, 0x05, 0xc4, 0xa6, 0x4d, 0x3f,
|
|
0xf0, 0x98, 0x87, 0x36, 0x23, 0xd1, 0xbc, 0x63, 0x3b, 0xec, 0xe5, 0x6c, 0xd8, 0x3c, 0xf5, 0xa6,
|
|
0x77, 0x6d, 0xcf, 0xf6, 0xee, 0x0a, 0xfb, 0x70, 0x36, 0x16, 0x92, 0x10, 0xc4, 0x49, 0xfa, 0x99,
|
|
0x37, 0x6c, 0xcf, 0xb3, 0x27, 0x74, 0x85, 0xa2, 0x53, 0x9f, 0x9d, 0x45, 0xc6, 0x56, 0x8a, 0xcb,
|
|
0x71, 0xc7, 0x93, 0xd9, 0xab, 0x11, 0x61, 0xe4, 0xee, 0x19, 0x09, 0xfc, 0x53, 0xf9, 0x2b, 0xf9,
|
|
0xc4, 0x31, 0xf2, 0xd9, 0xf1, 0x03, 0x3a, 0x72, 0x4e, 0x09, 0x8b, 0x32, 0xab, 0xff, 0xa1, 0x43,
|
|
0x11, 0x53, 0x32, 0xc2, 0xf4, 0xdb, 0x19, 0x0d, 0x19, 0x32, 0x61, 0x8b, 0xb3, 0x0c, 0x49, 0x48,
|
|
0x2b, 0xaa, 0xa5, 0x36, 0x0a, 0x38, 0x91, 0xd1, 0x97, 0xb0, 0xc3, 0x9c, 0x29, 0x0d, 0x19, 0x99,
|
|
0xfa, 0x27, 0x01, 0x71, 0x6d, 0x5a, 0xd9, 0xb0, 0xd4, 0x46, 0xb1, 0xf5, 0x4e, 0x33, 0x2e, 0x77,
|
|
0x10, 0xdb, 0x31, 0x37, 0xb7, 0xf7, 0x5f, 0x2f, 0x6a, 0xca, 0x72, 0x51, 0xdb, 0xce, 0xea, 0xf1,
|
|
0x36, 0xcb, 0xc8, 0xa8, 0x0a, 0x30, 0xa2, 0xe1, 0x29, 0x75, 0x47, 0x8e, 0x6b, 0x57, 0x34, 0x4b,
|
|
0x6d, 0x6c, 0xe1, 0x94, 0x86, 0x67, 0x65, 0x07, 0xde, 0xcc, 0xe7, 0x56, 0xdd, 0xd2, 0x78, 0x56,
|
|
0xb1, 0x8c, 0xee, 0x41, 0x21, 0x29, 0xaa, 0x92, 0x13, 0xf9, 0xa0, 0x24, 0x9f, 0x17, 0xb1, 0x05,
|
|
0xaf, 0x40, 0xa8, 0x05, 0xa5, 0x90, 0x06, 0x0e, 0x0d, 0x4f, 0x26, 0xce, 0xd4, 0x61, 0x95, 0xbc,
|
|
0xa5, 0x36, 0xf4, 0xf6, 0xce, 0x72, 0x51, 0x2b, 0xf6, 0x85, 0xfe, 0x88, 0xab, 0x71, 0x31, 0x5c,
|
|
0x09, 0xe8, 0x23, 0x28, 0x47, 0x3e, 0xde, 0x78, 0x1c, 0x52, 0x56, 0xd9, 0x14, 0x4e, 0xc6, 0x72,
|
|
0x51, 0x2b, 0x49, 0xa7, 0x9e, 0xd0, 0xe3, 0x88, 0x5a, 0x4a, 0x3c, 0x94, 0xef, 0x39, 0x2e, 0x8b,
|
|
0x43, 0x6d, 0xad, 0x42, 0xbd, 0x10, 0xfa, 0x28, 0x94, 0xbf, 0x12, 0x78, 0x41, 0xc4, 0xb6, 0x03,
|
|
0x6a, 0xf3, 0x82, 0x0a, 0x17, 0x0a, 0x7a, 0x18, 0x5b, 0xf0, 0x0a, 0x84, 0x3e, 0x87, 0x1c, 0x0b,
|
|
0xc8, 0x29, 0xad, 0x80, 0xa5, 0x35, 0x8a, 0xad, 0x5a, 0x82, 0x4e, 0xbd, 0x6c, 0x73, 0xc0, 0x11,
|
|
0x1d, 0x97, 0x05, 0x67, 0xed, 0xc2, 0x72, 0x51, 0xcb, 0x09, 0x19, 0x4b, 0x47, 0xf3, 0x3e, 0xc0,
|
|
0xca, 0x8e, 0x0c, 0xd0, 0xbe, 0xa1, 0x67, 0xd1, 0xfb, 0xf3, 0x23, 0xda, 0x83, 0xdc, 0x77, 0x64,
|
|
0x32, 0x93, 0x0f, 0x5e, 0xc0, 0x52, 0xf8, 0x74, 0xe3, 0xbe, 0x5a, 0xff, 0x5d, 0x85, 0x42, 0x92,
|
|
0x14, 0xfa, 0x10, 0x74, 0x76, 0xe6, 0xcb, 0xd6, 0xd9, 0x6e, 0x59, 0x97, 0xd3, 0x5e, 0x9d, 0x06,
|
|
0x67, 0x3e, 0xc5, 0x02, 0x5d, 0x7f, 0x05, 0xe5, 0x8c, 0x1a, 0xd5, 0x40, 0xef, 0xf6, 0xba, 0x1d,
|
|
0x43, 0x31, 0xaf, 0x9f, 0xcf, 0xad, 0xdd, 0x8c, 0xb1, 0xeb, 0xb9, 0x14, 0xdd, 0x04, 0xad, 0x7f,
|
|
0xfc, 0xdc, 0x50, 0xcd, 0xbd, 0xf3, 0xb9, 0x65, 0x64, 0xec, 0xfd, 0xd9, 0x14, 0xdd, 0x82, 0xdc,
|
|
0xa3, 0xde, 0x71, 0x77, 0x60, 0x6c, 0x98, 0xfb, 0xe7, 0x73, 0x0b, 0x65, 0x00, 0x8f, 0xbc, 0x99,
|
|
0xcb, 0x4c, 0xfd, 0x87, 0x5f, 0xaa, 0x4a, 0xfd, 0x0e, 0x68, 0x03, 0x62, 0xa7, 0x0b, 0x2e, 0xad,
|
|
0x29, 0xb8, 0x14, 0x15, 0x5c, 0xff, 0xb9, 0x08, 0x25, 0x79, 0xa7, 0xa1, 0xef, 0xb9, 0x21, 0x45,
|
|
0x9f, 0x40, 0x7e, 0x1c, 0x90, 0x29, 0x0d, 0x2b, 0xaa, 0xb8, 0xfa, 0x1b, 0x17, 0xae, 0x5e, 0xc2,
|
|
0x9a, 0x4f, 0x38, 0xa6, 0xad, 0xf3, 0x69, 0xc0, 0x91, 0x83, 0xf9, 0xa7, 0x0e, 0x39, 0xa1, 0x47,
|
|
0x0f, 0x20, 0x2f, 0x9b, 0x46, 0x24, 0x50, 0x6c, 0xdd, 0x5a, 0x4f, 0x22, 0xdb, 0x4c, 0xb8, 0x1c,
|
|
0x28, 0x38, 0x72, 0x41, 0x5f, 0x41, 0x69, 0x3c, 0xf1, 0x08, 0x3b, 0x91, 0x2d, 0x14, 0x4d, 0xe4,
|
|
0xed, 0x37, 0xe4, 0xc1, 0x91, 0xb2, 0xf1, 0x64, 0x4a, 0xa2, 0x13, 0x53, 0xda, 0x03, 0x05, 0x17,
|
|
0xc7, 0x2b, 0x11, 0x8d, 0x60, 0xdb, 0x71, 0x19, 0xb5, 0x69, 0x10, 0xf3, 0x6b, 0x82, 0xbf, 0xb1,
|
|
0x9e, 0xff, 0x50, 0x62, 0xd3, 0x11, 0x76, 0x97, 0x8b, 0x5a, 0x39, 0xa3, 0x3f, 0x50, 0x70, 0xd9,
|
|
0x49, 0x2b, 0xd0, 0x4b, 0xd8, 0x99, 0xb9, 0xa1, 0x63, 0xbb, 0x74, 0x14, 0x87, 0xd1, 0x45, 0x98,
|
|
0xf7, 0xd7, 0x87, 0x39, 0x8e, 0xc0, 0xe9, 0x38, 0x88, 0xaf, 0x99, 0xac, 0xe1, 0x40, 0xc1, 0xdb,
|
|
0xb3, 0x8c, 0x86, 0xd7, 0x33, 0xf4, 0xbc, 0x09, 0x25, 0x6e, 0x1c, 0x28, 0xf7, 0xb6, 0x7a, 0xda,
|
|
0x12, 0x7b, 0xa9, 0x9e, 0x8c, 0x9e, 0xd7, 0x33, 0x4c, 0x2b, 0xd0, 0xd7, 0x7c, 0xff, 0x07, 0x8e,
|
|
0x6b, 0xc7, 0x41, 0xf2, 0x22, 0xc8, 0x7b, 0x6f, 0x78, 0x57, 0x01, 0x4d, 0xc7, 0x90, 0x5b, 0x25,
|
|
0xa5, 0x3e, 0x50, 0x70, 0x29, 0x4c, 0xc9, 0xed, 0x3c, 0xe8, 0x7c, 0x2d, 0x9b, 0x01, 0x14, 0x53,
|
|
0x6d, 0x81, 0x6e, 0x83, 0xce, 0x88, 0x1d, 0x37, 0x63, 0x69, 0xb5, 0x96, 0x89, 0x1d, 0x75, 0x9f,
|
|
0xb0, 0xa3, 0x07, 0x50, 0xe0, 0xee, 0x27, 0x62, 0x56, 0x37, 0xc4, 0xac, 0x56, 0xd7, 0x27, 0xf7,
|
|
0x98, 0x30, 0x22, 0x26, 0x55, 0xfc, 0x0d, 0xf0, 0x93, 0xf9, 0x05, 0x18, 0x17, 0xfb, 0x88, 0x2f,
|
|
0xf0, 0x64, 0xa5, 0xcb, 0xf0, 0x06, 0x4e, 0x69, 0xd0, 0x3e, 0xe4, 0xc5, 0x04, 0xf1, 0xfe, 0xd4,
|
|
0x1a, 0x2a, 0x8e, 0x24, 0xf3, 0x08, 0xd0, 0xe5, 0x9e, 0xb9, 0x22, 0x9b, 0x96, 0xb0, 0x3d, 0x87,
|
|
0x6b, 0x6b, 0x5a, 0xe3, 0x8a, 0x74, 0x7a, 0x3a, 0xb9, 0xcb, 0x0d, 0x70, 0x45, 0xb6, 0xad, 0x84,
|
|
0xed, 0x19, 0xec, 0x5e, 0x7a, 0xe9, 0x2b, 0x92, 0x15, 0x62, 0xb2, 0x7a, 0x1f, 0x0a, 0x82, 0x20,
|
|
0xda, 0x96, 0xf9, 0x7e, 0x07, 0x1f, 0x76, 0xfa, 0x86, 0x62, 0x5e, 0x3b, 0x9f, 0x5b, 0x3b, 0x89,
|
|
0x49, 0xf6, 0x06, 0x07, 0xbc, 0xe8, 0x1d, 0x76, 0x07, 0x7d, 0x43, 0xbd, 0x00, 0x90, 0xb9, 0x44,
|
|
0xcb, 0xf0, 0x37, 0x15, 0xb6, 0xe2, 0xf7, 0x46, 0xef, 0x42, 0xee, 0xc9, 0x51, 0xef, 0xe1, 0xc0,
|
|
0x50, 0xcc, 0xdd, 0xf3, 0xb9, 0x55, 0x8e, 0x0d, 0xe2, 0xe9, 0x91, 0x05, 0x9b, 0x87, 0xdd, 0x41,
|
|
0xe7, 0x69, 0x07, 0xc7, 0x94, 0xb1, 0x3d, 0x7a, 0x4e, 0x54, 0x87, 0xad, 0xe3, 0x6e, 0xff, 0xf0,
|
|
0x69, 0xb7, 0xf3, 0xd8, 0xd8, 0x90, 0x6b, 0x3a, 0x86, 0xc4, 0x6f, 0xc4, 0x59, 0xda, 0xbd, 0xde,
|
|
0x51, 0xe7, 0x61, 0xd7, 0xd0, 0xb2, 0x2c, 0xd1, 0xbd, 0xa3, 0x2a, 0xe4, 0xfb, 0x03, 0x7c, 0xd8,
|
|
0x7d, 0x6a, 0xe8, 0x26, 0x3a, 0x9f, 0x5b, 0xdb, 0x31, 0x40, 0x5e, 0x65, 0x94, 0xf8, 0x8f, 0x2a,
|
|
0xec, 0x3d, 0x22, 0x3e, 0x19, 0x3a, 0x13, 0x87, 0x39, 0x34, 0x4c, 0xd6, 0xf3, 0x03, 0xd0, 0x4f,
|
|
0x89, 0x1f, 0xcf, 0xc3, 0x6a, 0xfe, 0xd6, 0x81, 0xb9, 0x32, 0x14, 0xff, 0x7f, 0x58, 0x38, 0x99,
|
|
0x1f, 0x43, 0x21, 0x51, 0x5d, 0xe9, 0x2f, 0x71, 0x07, 0xca, 0x07, 0xfc, 0x5a, 0x63, 0xe6, 0xfa,
|
|
0x7d, 0xb8, 0xf0, 0x01, 0xc4, 0x9d, 0x43, 0x46, 0x02, 0x26, 0x08, 0x35, 0x2c, 0x05, 0x1e, 0x84,
|
|
0xba, 0x23, 0x41, 0xa8, 0x61, 0x7e, 0x6c, 0xfd, 0xad, 0xc2, 0x66, 0x5f, 0x26, 0xcd, 0x8b, 0xe1,
|
|
0xa3, 0x89, 0xf6, 0xd6, 0xfd, 0xbd, 0x9b, 0xd7, 0xd7, 0xce, 0x6f, 0x5d, 0xff, 0xfe, 0xd7, 0x8a,
|
|
0x72, 0x4f, 0x45, 0xcf, 0xa0, 0x94, 0x2e, 0x1a, 0xed, 0x37, 0xe5, 0xa7, 0x65, 0x33, 0xfe, 0xb4,
|
|
0x6c, 0x76, 0xf8, 0xa7, 0xa5, 0x79, 0xf3, 0xad, 0x77, 0x24, 0xe8, 0x54, 0xf4, 0x19, 0xe4, 0x44,
|
|
0x81, 0x6f, 0x64, 0xd9, 0x4f, 0x58, 0xb2, 0x17, 0xc1, 0xdd, 0x37, 0x4c, 0x91, 0x53, 0x7b, 0xef,
|
|
0xf5, 0xbf, 0x55, 0xe5, 0xf5, 0xb2, 0xaa, 0xfe, 0xb5, 0xac, 0xaa, 0xff, 0x2c, 0xab, 0xea, 0x4f,
|
|
0xff, 0x55, 0x95, 0x61, 0x5e, 0x30, 0x7d, 0xf0, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x91, 0xdc,
|
|
0x3a, 0xb6, 0x41, 0x0b, 0x00, 0x00,
|
|
}
|