pkg/protocol/sls_logs.pb.go (1,822 lines of code) (raw):
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: sls_logs.proto
package protocol
import (
encoding_binary "encoding/binary"
fmt "fmt"
_ "github.com/gogo/protobuf/gogoproto"
github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
math_bits "math/bits"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type Log struct {
Time uint32 `protobuf:"varint,1,req,name=Time" json:"Time"`
Contents []*Log_Content `protobuf:"bytes,2,rep,name=Contents" json:"Contents,omitempty"`
Values []string `protobuf:"bytes,3,rep,name=values" json:"values,omitempty"`
TimeNs *uint32 `protobuf:"fixed32,4,opt,name=Time_ns,json=TimeNs" json:"Time_ns,omitempty"`
}
func (m *Log) Reset() { *m = Log{} }
func (m *Log) String() string { return proto.CompactTextString(m) }
func (*Log) ProtoMessage() {}
func (*Log) Descriptor() ([]byte, []int) {
return fileDescriptor_8af9b9327e825b67, []int{0}
}
func (m *Log) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Log) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Log.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Log) XXX_Merge(src proto.Message) {
xxx_messageInfo_Log.Merge(m, src)
}
func (m *Log) XXX_Size() int {
return m.Size()
}
func (m *Log) XXX_DiscardUnknown() {
xxx_messageInfo_Log.DiscardUnknown(m)
}
var xxx_messageInfo_Log proto.InternalMessageInfo
func (m *Log) GetTime() uint32 {
if m != nil {
return m.Time
}
return 0
}
func (m *Log) GetContents() []*Log_Content {
if m != nil {
return m.Contents
}
return nil
}
func (m *Log) GetValues() []string {
if m != nil {
return m.Values
}
return nil
}
func (m *Log) GetTimeNs() uint32 {
if m != nil && m.TimeNs != nil {
return *m.TimeNs
}
return 0
}
type Log_Content struct {
Key string `protobuf:"bytes,1,req,name=Key" json:"Key"`
Value string `protobuf:"bytes,2,req,name=Value" json:"Value"`
}
func (m *Log_Content) Reset() { *m = Log_Content{} }
func (m *Log_Content) String() string { return proto.CompactTextString(m) }
func (*Log_Content) ProtoMessage() {}
func (*Log_Content) Descriptor() ([]byte, []int) {
return fileDescriptor_8af9b9327e825b67, []int{0, 0}
}
func (m *Log_Content) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Log_Content) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Log_Content.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Log_Content) XXX_Merge(src proto.Message) {
xxx_messageInfo_Log_Content.Merge(m, src)
}
func (m *Log_Content) XXX_Size() int {
return m.Size()
}
func (m *Log_Content) XXX_DiscardUnknown() {
xxx_messageInfo_Log_Content.DiscardUnknown(m)
}
var xxx_messageInfo_Log_Content proto.InternalMessageInfo
func (m *Log_Content) GetKey() string {
if m != nil {
return m.Key
}
return ""
}
func (m *Log_Content) GetValue() string {
if m != nil {
return m.Value
}
return ""
}
type LogTag struct {
Key string `protobuf:"bytes,1,req,name=Key" json:"Key"`
Value string `protobuf:"bytes,2,req,name=Value" json:"Value"`
}
func (m *LogTag) Reset() { *m = LogTag{} }
func (m *LogTag) String() string { return proto.CompactTextString(m) }
func (*LogTag) ProtoMessage() {}
func (*LogTag) Descriptor() ([]byte, []int) {
return fileDescriptor_8af9b9327e825b67, []int{1}
}
func (m *LogTag) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *LogTag) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_LogTag.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *LogTag) XXX_Merge(src proto.Message) {
xxx_messageInfo_LogTag.Merge(m, src)
}
func (m *LogTag) XXX_Size() int {
return m.Size()
}
func (m *LogTag) XXX_DiscardUnknown() {
xxx_messageInfo_LogTag.DiscardUnknown(m)
}
var xxx_messageInfo_LogTag proto.InternalMessageInfo
func (m *LogTag) GetKey() string {
if m != nil {
return m.Key
}
return ""
}
func (m *LogTag) GetValue() string {
if m != nil {
return m.Value
}
return ""
}
type LogGroup struct {
Logs []*Log `protobuf:"bytes,1,rep,name=Logs" json:"Logs,omitempty"`
Category string `protobuf:"bytes,2,opt,name=Category" json:"Category"`
Topic string `protobuf:"bytes,3,opt,name=Topic" json:"Topic"`
Source string `protobuf:"bytes,4,opt,name=Source" json:"Source"`
MachineUUID string `protobuf:"bytes,5,opt,name=MachineUUID" json:"MachineUUID"`
LogTags []*LogTag `protobuf:"bytes,6,rep,name=LogTags" json:"LogTags,omitempty"`
}
func (m *LogGroup) Reset() { *m = LogGroup{} }
func (m *LogGroup) String() string { return proto.CompactTextString(m) }
func (*LogGroup) ProtoMessage() {}
func (*LogGroup) Descriptor() ([]byte, []int) {
return fileDescriptor_8af9b9327e825b67, []int{2}
}
func (m *LogGroup) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *LogGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_LogGroup.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *LogGroup) XXX_Merge(src proto.Message) {
xxx_messageInfo_LogGroup.Merge(m, src)
}
func (m *LogGroup) XXX_Size() int {
return m.Size()
}
func (m *LogGroup) XXX_DiscardUnknown() {
xxx_messageInfo_LogGroup.DiscardUnknown(m)
}
var xxx_messageInfo_LogGroup proto.InternalMessageInfo
func (m *LogGroup) GetLogs() []*Log {
if m != nil {
return m.Logs
}
return nil
}
func (m *LogGroup) GetCategory() string {
if m != nil {
return m.Category
}
return ""
}
func (m *LogGroup) GetTopic() string {
if m != nil {
return m.Topic
}
return ""
}
func (m *LogGroup) GetSource() string {
if m != nil {
return m.Source
}
return ""
}
func (m *LogGroup) GetMachineUUID() string {
if m != nil {
return m.MachineUUID
}
return ""
}
func (m *LogGroup) GetLogTags() []*LogTag {
if m != nil {
return m.LogTags
}
return nil
}
type SlsLogPackage struct {
Data []byte `protobuf:"bytes,1,req,name=data" json:"data"`
UncompressSize int32 `protobuf:"varint,2,opt,name=uncompress_size,json=uncompressSize" json:"uncompress_size"`
}
func (m *SlsLogPackage) Reset() { *m = SlsLogPackage{} }
func (m *SlsLogPackage) String() string { return proto.CompactTextString(m) }
func (*SlsLogPackage) ProtoMessage() {}
func (*SlsLogPackage) Descriptor() ([]byte, []int) {
return fileDescriptor_8af9b9327e825b67, []int{3}
}
func (m *SlsLogPackage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *SlsLogPackage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_SlsLogPackage.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *SlsLogPackage) XXX_Merge(src proto.Message) {
xxx_messageInfo_SlsLogPackage.Merge(m, src)
}
func (m *SlsLogPackage) XXX_Size() int {
return m.Size()
}
func (m *SlsLogPackage) XXX_DiscardUnknown() {
xxx_messageInfo_SlsLogPackage.DiscardUnknown(m)
}
var xxx_messageInfo_SlsLogPackage proto.InternalMessageInfo
func (m *SlsLogPackage) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
func (m *SlsLogPackage) GetUncompressSize() int32 {
if m != nil {
return m.UncompressSize
}
return 0
}
type SlsLogPackageList struct {
Packages []*SlsLogPackage `protobuf:"bytes,1,rep,name=packages" json:"packages,omitempty"`
}
func (m *SlsLogPackageList) Reset() { *m = SlsLogPackageList{} }
func (m *SlsLogPackageList) String() string { return proto.CompactTextString(m) }
func (*SlsLogPackageList) ProtoMessage() {}
func (*SlsLogPackageList) Descriptor() ([]byte, []int) {
return fileDescriptor_8af9b9327e825b67, []int{4}
}
func (m *SlsLogPackageList) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *SlsLogPackageList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_SlsLogPackageList.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *SlsLogPackageList) XXX_Merge(src proto.Message) {
xxx_messageInfo_SlsLogPackageList.Merge(m, src)
}
func (m *SlsLogPackageList) XXX_Size() int {
return m.Size()
}
func (m *SlsLogPackageList) XXX_DiscardUnknown() {
xxx_messageInfo_SlsLogPackageList.DiscardUnknown(m)
}
var xxx_messageInfo_SlsLogPackageList proto.InternalMessageInfo
func (m *SlsLogPackageList) GetPackages() []*SlsLogPackage {
if m != nil {
return m.Packages
}
return nil
}
type LogGroupList struct {
LogGroupList []*LogGroup `protobuf:"bytes,1,rep,name=logGroupList" json:"logGroupList,omitempty"`
}
func (m *LogGroupList) Reset() { *m = LogGroupList{} }
func (m *LogGroupList) String() string { return proto.CompactTextString(m) }
func (*LogGroupList) ProtoMessage() {}
func (*LogGroupList) Descriptor() ([]byte, []int) {
return fileDescriptor_8af9b9327e825b67, []int{5}
}
func (m *LogGroupList) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *LogGroupList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_LogGroupList.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *LogGroupList) XXX_Merge(src proto.Message) {
xxx_messageInfo_LogGroupList.Merge(m, src)
}
func (m *LogGroupList) XXX_Size() int {
return m.Size()
}
func (m *LogGroupList) XXX_DiscardUnknown() {
xxx_messageInfo_LogGroupList.DiscardUnknown(m)
}
var xxx_messageInfo_LogGroupList proto.InternalMessageInfo
func (m *LogGroupList) GetLogGroupList() []*LogGroup {
if m != nil {
return m.LogGroupList
}
return nil
}
func init() {
proto.RegisterType((*Log)(nil), "sls_logs.Log")
proto.RegisterType((*Log_Content)(nil), "sls_logs.Log.Content")
proto.RegisterType((*LogTag)(nil), "sls_logs.LogTag")
proto.RegisterType((*LogGroup)(nil), "sls_logs.LogGroup")
proto.RegisterType((*SlsLogPackage)(nil), "sls_logs.SlsLogPackage")
proto.RegisterType((*SlsLogPackageList)(nil), "sls_logs.SlsLogPackageList")
proto.RegisterType((*LogGroupList)(nil), "sls_logs.LogGroupList")
}
func init() { proto.RegisterFile("sls_logs.proto", fileDescriptor_8af9b9327e825b67) }
var fileDescriptor_8af9b9327e825b67 = []byte{
// 486 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x53, 0xcb, 0x6e, 0xd3, 0x4c,
0x14, 0xce, 0xc4, 0xb9, 0xf5, 0x34, 0xe9, 0xff, 0x33, 0x12, 0x65, 0x14, 0x81, 0x31, 0x59, 0xa0,
0x08, 0xa9, 0x89, 0x00, 0x89, 0x15, 0x6c, 0x52, 0xc4, 0x45, 0x18, 0x84, 0x9c, 0x14, 0x21, 0x36,
0xd1, 0xc4, 0x0c, 0xd3, 0x51, 0x9d, 0x1c, 0xcb, 0x63, 0x23, 0xb5, 0x4f, 0xc1, 0x63, 0x65, 0xd9,
0x25, 0x1b, 0x10, 0x4a, 0x5e, 0x04, 0x79, 0x7c, 0xa9, 0xbd, 0x65, 0xe7, 0xef, 0xe2, 0xef, 0xdc,
0x34, 0x70, 0xa4, 0x03, 0xbd, 0x0c, 0x50, 0xea, 0x49, 0x18, 0x61, 0x8c, 0xb4, 0x57, 0xe0, 0xe1,
0x89, 0x54, 0xf1, 0x79, 0xb2, 0x9a, 0xf8, 0xb8, 0x9e, 0x4a, 0x94, 0x38, 0x35, 0x86, 0x55, 0xf2,
0xcd, 0x20, 0x03, 0xcc, 0x57, 0xf6, 0xe3, 0x68, 0x4b, 0xc0, 0x72, 0x51, 0x52, 0x06, 0xad, 0x85,
0x5a, 0x0b, 0x46, 0x9c, 0xe6, 0x78, 0x30, 0x6b, 0x6d, 0x7f, 0xdf, 0x6f, 0x78, 0x86, 0xa1, 0x8f,
0xa1, 0x77, 0x8a, 0x9b, 0x58, 0x6c, 0x62, 0xcd, 0x9a, 0x8e, 0x35, 0x3e, 0x7c, 0x72, 0x7b, 0x52,
0x56, 0x77, 0x51, 0x4e, 0x72, 0xd5, 0x2b, 0x6d, 0xf4, 0x18, 0x3a, 0xdf, 0x79, 0x90, 0x08, 0xcd,
0x2c, 0xc7, 0x1a, 0x1f, 0x78, 0x39, 0xa2, 0xf7, 0xa0, 0x9b, 0x46, 0x2e, 0x37, 0x9a, 0xb5, 0x1c,
0x32, 0xee, 0x9a, 0x3a, 0xc4, 0xeb, 0xa4, 0xe4, 0x07, 0x3d, 0x7c, 0x01, 0xdd, 0x3c, 0x82, 0x1e,
0x83, 0xf5, 0x4e, 0x5c, 0x9a, 0x6e, 0x0e, 0xf2, 0x6e, 0x52, 0x82, 0x0e, 0xa1, 0xfd, 0x29, 0xcd,
0x62, 0xcd, 0x8a, 0x92, 0x51, 0xa3, 0xe7, 0xd0, 0x71, 0x51, 0x2e, 0xb8, 0xfc, 0xa7, 0xbf, 0x7f,
0x11, 0xe8, 0xb9, 0x28, 0x5f, 0x47, 0x98, 0x84, 0xf4, 0x01, 0xb4, 0x5c, 0x94, 0x9a, 0x11, 0x33,
0xef, 0xa0, 0x36, 0xaf, 0x67, 0x24, 0xea, 0x40, 0xef, 0x94, 0xc7, 0x42, 0x62, 0x74, 0xc9, 0x9a,
0x0e, 0x29, 0xe3, 0x4a, 0x36, 0xad, 0xb6, 0xc0, 0x50, 0xf9, 0xcc, 0xaa, 0xc8, 0x19, 0x45, 0xef,
0x42, 0x67, 0x8e, 0x49, 0xe4, 0x0b, 0xb3, 0x88, 0x42, 0xcc, 0x39, 0xfa, 0x10, 0x0e, 0xdf, 0x73,
0xff, 0x5c, 0x6d, 0xc4, 0xd9, 0xd9, 0xdb, 0x97, 0xac, 0x5d, 0xb1, 0x54, 0x05, 0xfa, 0x08, 0xba,
0xd9, 0xc4, 0x9a, 0x75, 0x4c, 0xa7, 0xff, 0xd7, 0x3a, 0x5d, 0x70, 0xe9, 0x15, 0x86, 0xd1, 0x67,
0x18, 0xcc, 0x03, 0xed, 0xa2, 0xfc, 0xc8, 0xfd, 0x0b, 0x2e, 0x45, 0x7a, 0xf1, 0xaf, 0x3c, 0xe6,
0x66, 0x4b, 0xfd, 0xe2, 0xe2, 0x29, 0x43, 0x4f, 0xe0, 0xbf, 0x64, 0xe3, 0xe3, 0x3a, 0x8c, 0x84,
0xd6, 0x4b, 0xad, 0xae, 0x84, 0x99, 0xb0, 0x9d, 0x9b, 0x8e, 0x6e, 0xc4, 0xb9, 0xba, 0x12, 0xa3,
0x37, 0x70, 0xab, 0x96, 0xec, 0x2a, 0x1d, 0xd3, 0xa7, 0xd0, 0x0b, 0x33, 0x58, 0x6c, 0xf1, 0xce,
0x4d, 0x6f, 0x35, 0xbb, 0x57, 0x1a, 0x47, 0xaf, 0xa0, 0x5f, 0x9c, 0xc0, 0x84, 0x3c, 0x83, 0x7e,
0x50, 0xc1, 0x79, 0x10, 0xad, 0x0d, 0x69, 0x54, 0xaf, 0xe6, 0x9b, 0xcd, 0xb6, 0x3b, 0x9b, 0x5c,
0xef, 0x6c, 0xf2, 0x67, 0x67, 0x93, 0x1f, 0x7b, 0xbb, 0x71, 0xbd, 0xb7, 0x1b, 0x3f, 0xf7, 0x76,
0xe3, 0xcb, 0xb8, 0xf2, 0x3a, 0x78, 0xa0, 0x56, 0x7c, 0xc5, 0xa7, 0x2a, 0x40, 0x19, 0x73, 0x15,
0x4c, 0xc3, 0x0b, 0x99, 0xbd, 0x16, 0x1f, 0x83, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc9, 0xad,
0x4e, 0xb8, 0x62, 0x03, 0x00, 0x00,
}
func (m *Log) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Log) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Log) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.TimeNs != nil {
i -= 4
encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.TimeNs))
i--
dAtA[i] = 0x25
}
if len(m.Values) > 0 {
for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
i -= len(m.Values[iNdEx])
copy(dAtA[i:], m.Values[iNdEx])
i = encodeVarintSlsLogs(dAtA, i, uint64(len(m.Values[iNdEx])))
i--
dAtA[i] = 0x1a
}
}
if len(m.Contents) > 0 {
for iNdEx := len(m.Contents) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Contents[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintSlsLogs(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
}
i = encodeVarintSlsLogs(dAtA, i, uint64(m.Time))
i--
dAtA[i] = 0x8
return len(dAtA) - i, nil
}
func (m *Log_Content) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Log_Content) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Log_Content) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
i -= len(m.Value)
copy(dAtA[i:], m.Value)
i = encodeVarintSlsLogs(dAtA, i, uint64(len(m.Value)))
i--
dAtA[i] = 0x12
i -= len(m.Key)
copy(dAtA[i:], m.Key)
i = encodeVarintSlsLogs(dAtA, i, uint64(len(m.Key)))
i--
dAtA[i] = 0xa
return len(dAtA) - i, nil
}
func (m *LogTag) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *LogTag) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *LogTag) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
i -= len(m.Value)
copy(dAtA[i:], m.Value)
i = encodeVarintSlsLogs(dAtA, i, uint64(len(m.Value)))
i--
dAtA[i] = 0x12
i -= len(m.Key)
copy(dAtA[i:], m.Key)
i = encodeVarintSlsLogs(dAtA, i, uint64(len(m.Key)))
i--
dAtA[i] = 0xa
return len(dAtA) - i, nil
}
func (m *LogGroup) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *LogGroup) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *LogGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.LogTags) > 0 {
for iNdEx := len(m.LogTags) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.LogTags[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintSlsLogs(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x32
}
}
i -= len(m.MachineUUID)
copy(dAtA[i:], m.MachineUUID)
i = encodeVarintSlsLogs(dAtA, i, uint64(len(m.MachineUUID)))
i--
dAtA[i] = 0x2a
i -= len(m.Source)
copy(dAtA[i:], m.Source)
i = encodeVarintSlsLogs(dAtA, i, uint64(len(m.Source)))
i--
dAtA[i] = 0x22
i -= len(m.Topic)
copy(dAtA[i:], m.Topic)
i = encodeVarintSlsLogs(dAtA, i, uint64(len(m.Topic)))
i--
dAtA[i] = 0x1a
i -= len(m.Category)
copy(dAtA[i:], m.Category)
i = encodeVarintSlsLogs(dAtA, i, uint64(len(m.Category)))
i--
dAtA[i] = 0x12
if len(m.Logs) > 0 {
for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintSlsLogs(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func (m *SlsLogPackage) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *SlsLogPackage) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SlsLogPackage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
i = encodeVarintSlsLogs(dAtA, i, uint64(m.UncompressSize))
i--
dAtA[i] = 0x10
if m.Data != nil {
i -= len(m.Data)
copy(dAtA[i:], m.Data)
i = encodeVarintSlsLogs(dAtA, i, uint64(len(m.Data)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *SlsLogPackageList) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *SlsLogPackageList) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SlsLogPackageList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Packages) > 0 {
for iNdEx := len(m.Packages) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Packages[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintSlsLogs(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func (m *LogGroupList) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *LogGroupList) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *LogGroupList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.LogGroupList) > 0 {
for iNdEx := len(m.LogGroupList) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.LogGroupList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintSlsLogs(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func encodeVarintSlsLogs(dAtA []byte, offset int, v uint64) int {
offset -= sovSlsLogs(v)
base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func (m *Log) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
n += 1 + sovSlsLogs(uint64(m.Time))
if len(m.Contents) > 0 {
for _, e := range m.Contents {
l = e.Size()
n += 1 + l + sovSlsLogs(uint64(l))
}
}
if len(m.Values) > 0 {
for _, s := range m.Values {
l = len(s)
n += 1 + l + sovSlsLogs(uint64(l))
}
}
if m.TimeNs != nil {
n += 5
}
return n
}
func (m *Log_Content) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Key)
n += 1 + l + sovSlsLogs(uint64(l))
l = len(m.Value)
n += 1 + l + sovSlsLogs(uint64(l))
return n
}
func (m *LogTag) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Key)
n += 1 + l + sovSlsLogs(uint64(l))
l = len(m.Value)
n += 1 + l + sovSlsLogs(uint64(l))
return n
}
func (m *LogGroup) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.Logs) > 0 {
for _, e := range m.Logs {
l = e.Size()
n += 1 + l + sovSlsLogs(uint64(l))
}
}
l = len(m.Category)
n += 1 + l + sovSlsLogs(uint64(l))
l = len(m.Topic)
n += 1 + l + sovSlsLogs(uint64(l))
l = len(m.Source)
n += 1 + l + sovSlsLogs(uint64(l))
l = len(m.MachineUUID)
n += 1 + l + sovSlsLogs(uint64(l))
if len(m.LogTags) > 0 {
for _, e := range m.LogTags {
l = e.Size()
n += 1 + l + sovSlsLogs(uint64(l))
}
}
return n
}
func (m *SlsLogPackage) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Data != nil {
l = len(m.Data)
n += 1 + l + sovSlsLogs(uint64(l))
}
n += 1 + sovSlsLogs(uint64(m.UncompressSize))
return n
}
func (m *SlsLogPackageList) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.Packages) > 0 {
for _, e := range m.Packages {
l = e.Size()
n += 1 + l + sovSlsLogs(uint64(l))
}
}
return n
}
func (m *LogGroupList) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.LogGroupList) > 0 {
for _, e := range m.LogGroupList {
l = e.Size()
n += 1 + l + sovSlsLogs(uint64(l))
}
}
return n
}
func sovSlsLogs(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozSlsLogs(x uint64) (n int) {
return sovSlsLogs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Log) Unmarshal(dAtA []byte) error {
var hasFields [1]uint64
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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: Log: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Log: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
}
m.Time = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Time |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
}
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Contents", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Contents = append(m.Contents, &Log_Content{})
if err := m.Contents[len(m.Contents)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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 ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Values = append(m.Values, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 4:
if wireType != 5 {
return fmt.Errorf("proto: wrong wireType = %d for field TimeNs", wireType)
}
var v uint32
if (iNdEx + 4) > l {
return io.ErrUnexpectedEOF
}
v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
iNdEx += 4
m.TimeNs = &v
default:
iNdEx = preIndex
skippy, err := skipSlsLogs(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthSlsLogs
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Time")
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Log_Content) Unmarshal(dAtA []byte) error {
var hasFields [1]uint64
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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: Content: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Content: 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 stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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 ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Key = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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 ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Value = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
hasFields[0] |= uint64(0x00000002)
default:
iNdEx = preIndex
skippy, err := skipSlsLogs(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthSlsLogs
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Key")
}
if hasFields[0]&uint64(0x00000002) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Value")
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *LogTag) Unmarshal(dAtA []byte) error {
var hasFields [1]uint64
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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: LogTag: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: LogTag: 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 stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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 ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Key = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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 ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Value = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
hasFields[0] |= uint64(0x00000002)
default:
iNdEx = preIndex
skippy, err := skipSlsLogs(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthSlsLogs
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Key")
}
if hasFields[0]&uint64(0x00000002) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Value")
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *LogGroup) 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 ErrIntOverflowSlsLogs
}
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: LogGroup: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: LogGroup: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Logs = append(m.Logs, &Log{})
if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Category", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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 ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Category = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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 ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Topic = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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 ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Source = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field MachineUUID", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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 ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.MachineUUID = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field LogTags", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.LogTags = append(m.LogTags, &LogTag{})
if err := m.LogTags[len(m.LogTags)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSlsLogs(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthSlsLogs
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *SlsLogPackage) Unmarshal(dAtA []byte) error {
var hasFields [1]uint64
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
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: SlsLogPackage: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: SlsLogPackage: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
if m.Data == nil {
m.Data = []byte{}
}
iNdEx = postIndex
hasFields[0] |= uint64(0x00000001)
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field UncompressSize", wireType)
}
m.UncompressSize = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.UncompressSize |= int32(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipSlsLogs(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthSlsLogs
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if hasFields[0]&uint64(0x00000001) == 0 {
return github_com_gogo_protobuf_proto.NewRequiredNotSetError("data")
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *SlsLogPackageList) 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 ErrIntOverflowSlsLogs
}
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: SlsLogPackageList: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: SlsLogPackageList: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Packages", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Packages = append(m.Packages, &SlsLogPackage{})
if err := m.Packages[len(m.Packages)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSlsLogs(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthSlsLogs
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *LogGroupList) 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 ErrIntOverflowSlsLogs
}
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: LogGroupList: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: LogGroupList: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field LogGroupList", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSlsLogs
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthSlsLogs
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthSlsLogs
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.LogGroupList = append(m.LogGroupList, &LogGroup{})
if err := m.LogGroupList[len(m.LogGroupList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSlsLogs(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthSlsLogs
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipSlsLogs(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowSlsLogs
}
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, ErrIntOverflowSlsLogs
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
case 1:
iNdEx += 8
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowSlsLogs
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if length < 0 {
return 0, ErrInvalidLengthSlsLogs
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupSlsLogs
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthSlsLogs
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthSlsLogs = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowSlsLogs = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupSlsLogs = fmt.Errorf("proto: unexpected end of group")
)