nflog.pb.go

Documentation: github.com/prometheus/alertmanager/nflog/nflogpb

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: nflog.proto
     3  
     4  package nflogpb
     5  
     6  import (
     7  	fmt "fmt"
     8  
     9  	_ "github.com/gogo/protobuf/gogoproto"
    10  	proto "github.com/gogo/protobuf/proto"
    11  	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
    12  
    13  	io "io"
    14  	math "math"
    15  	math_bits "math/bits"
    16  	time "time"
    17  )
    18  
    19  // Reference imports to suppress errors if they are not otherwise used.
    20  var _ = proto.Marshal
    21  var _ = fmt.Errorf
    22  var _ = math.Inf
    23  var _ = time.Kitchen
    24  
    25  // This is a compile-time assertion to ensure that this generated file
    26  // is compatible with the proto package it is being compiled against.
    27  // A compilation error at this line likely means your copy of the
    28  // proto package needs to be updated.
    29  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    30  
    31  type Receiver struct {
    32  	// Configured name of the receiver group.
    33  	GroupName string `protobuf:"bytes,1,opt,name=group_name,json=groupName,proto3" json:"group_name,omitempty"`
    34  	// Name of the integration of the receiver.
    35  	Integration string `protobuf:"bytes,2,opt,name=integration,proto3" json:"integration,omitempty"`
    36  	// Index of the receiver with respect to the integration.
    37  	// Every integration in a group may have 0..N configurations.
    38  	Idx                  uint32   `protobuf:"varint,3,opt,name=idx,proto3" json:"idx,omitempty"`
    39  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
    40  	XXX_unrecognized     []byte   `json:"-"`
    41  	XXX_sizecache        int32    `json:"-"`
    42  }
    43  
    44  func (m *Receiver) Reset()         { *m = Receiver{} }
    45  func (m *Receiver) String() string { return proto.CompactTextString(m) }
    46  func (*Receiver) ProtoMessage()    {}
    47  func (*Receiver) Descriptor() ([]byte, []int) {
    48  	return fileDescriptor_c2d9785ad9c3e602, []int{0}
    49  }
    50  func (m *Receiver) XXX_Unmarshal(b []byte) error {
    51  	return m.Unmarshal(b)
    52  }
    53  func (m *Receiver) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    54  	if deterministic {
    55  		return xxx_messageInfo_Receiver.Marshal(b, m, deterministic)
    56  	} else {
    57  		b = b[:cap(b)]
    58  		n, err := m.MarshalToSizedBuffer(b)
    59  		if err != nil {
    60  			return nil, err
    61  		}
    62  		return b[:n], nil
    63  	}
    64  }
    65  func (m *Receiver) XXX_Merge(src proto.Message) {
    66  	xxx_messageInfo_Receiver.Merge(m, src)
    67  }
    68  func (m *Receiver) XXX_Size() int {
    69  	return m.Size()
    70  }
    71  func (m *Receiver) XXX_DiscardUnknown() {
    72  	xxx_messageInfo_Receiver.DiscardUnknown(m)
    73  }
    74  
    75  var xxx_messageInfo_Receiver proto.InternalMessageInfo
    76  
    77  // Entry holds information about a successful notification
    78  // sent to a receiver.
    79  type Entry struct {
    80  	// The key identifying the dispatching group.
    81  	GroupKey []byte `protobuf:"bytes,1,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"`
    82  	// The receiver that was notified.
    83  	Receiver *Receiver `protobuf:"bytes,2,opt,name=receiver,proto3" json:"receiver,omitempty"`
    84  	// Hash over the state of the group at notification time.
    85  	// Deprecated in favor of FiringAlerts field, but kept for compatibility.
    86  	GroupHash []byte `protobuf:"bytes,3,opt,name=group_hash,json=groupHash,proto3" json:"group_hash,omitempty"`
    87  	// Whether the notification was about a resolved alert.
    88  	// Deprecated in favor of ResolvedAlerts field, but kept for compatibility.
    89  	Resolved bool `protobuf:"varint,4,opt,name=resolved,proto3" json:"resolved,omitempty"`
    90  	// Timestamp of the succeeding notification.
    91  	Timestamp time.Time `protobuf:"bytes,5,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
    92  	// FiringAlerts list of hashes of firing alerts at the last notification time.
    93  	FiringAlerts []uint64 `protobuf:"varint,6,rep,packed,name=firing_alerts,json=firingAlerts,proto3" json:"firing_alerts,omitempty"`
    94  	// ResolvedAlerts list of hashes of resolved alerts at the last notification time.
    95  	ResolvedAlerts       []uint64 `protobuf:"varint,7,rep,packed,name=resolved_alerts,json=resolvedAlerts,proto3" json:"resolved_alerts,omitempty"`
    96  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
    97  	XXX_unrecognized     []byte   `json:"-"`
    98  	XXX_sizecache        int32    `json:"-"`
    99  }
   100  
   101  func (m *Entry) Reset()         { *m = Entry{} }
   102  func (m *Entry) String() string { return proto.CompactTextString(m) }
   103  func (*Entry) ProtoMessage()    {}
   104  func (*Entry) Descriptor() ([]byte, []int) {
   105  	return fileDescriptor_c2d9785ad9c3e602, []int{1}
   106  }
   107  func (m *Entry) XXX_Unmarshal(b []byte) error {
   108  	return m.Unmarshal(b)
   109  }
   110  func (m *Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   111  	if deterministic {
   112  		return xxx_messageInfo_Entry.Marshal(b, m, deterministic)
   113  	} else {
   114  		b = b[:cap(b)]
   115  		n, err := m.MarshalToSizedBuffer(b)
   116  		if err != nil {
   117  			return nil, err
   118  		}
   119  		return b[:n], nil
   120  	}
   121  }
   122  func (m *Entry) XXX_Merge(src proto.Message) {
   123  	xxx_messageInfo_Entry.Merge(m, src)
   124  }
   125  func (m *Entry) XXX_Size() int {
   126  	return m.Size()
   127  }
   128  func (m *Entry) XXX_DiscardUnknown() {
   129  	xxx_messageInfo_Entry.DiscardUnknown(m)
   130  }
   131  
   132  var xxx_messageInfo_Entry proto.InternalMessageInfo
   133  
   134  // MeshEntry is a wrapper message to communicate a notify log
   135  // entry through a mesh network.
   136  type MeshEntry struct {
   137  	// The original raw notify log entry.
   138  	Entry *Entry `protobuf:"bytes,1,opt,name=entry,proto3" json:"entry,omitempty"`
   139  	// A timestamp indicating when the mesh peer should evict
   140  	// the log entry from its state.
   141  	ExpiresAt            time.Time `protobuf:"bytes,2,opt,name=expires_at,json=expiresAt,proto3,stdtime" json:"expires_at"`
   142  	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
   143  	XXX_unrecognized     []byte    `json:"-"`
   144  	XXX_sizecache        int32     `json:"-"`
   145  }
   146  
   147  func (m *MeshEntry) Reset()         { *m = MeshEntry{} }
   148  func (m *MeshEntry) String() string { return proto.CompactTextString(m) }
   149  func (*MeshEntry) ProtoMessage()    {}
   150  func (*MeshEntry) Descriptor() ([]byte, []int) {
   151  	return fileDescriptor_c2d9785ad9c3e602, []int{2}
   152  }
   153  func (m *MeshEntry) XXX_Unmarshal(b []byte) error {
   154  	return m.Unmarshal(b)
   155  }
   156  func (m *MeshEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   157  	if deterministic {
   158  		return xxx_messageInfo_MeshEntry.Marshal(b, m, deterministic)
   159  	} else {
   160  		b = b[:cap(b)]
   161  		n, err := m.MarshalToSizedBuffer(b)
   162  		if err != nil {
   163  			return nil, err
   164  		}
   165  		return b[:n], nil
   166  	}
   167  }
   168  func (m *MeshEntry) XXX_Merge(src proto.Message) {
   169  	xxx_messageInfo_MeshEntry.Merge(m, src)
   170  }
   171  func (m *MeshEntry) XXX_Size() int {
   172  	return m.Size()
   173  }
   174  func (m *MeshEntry) XXX_DiscardUnknown() {
   175  	xxx_messageInfo_MeshEntry.DiscardUnknown(m)
   176  }
   177  
   178  var xxx_messageInfo_MeshEntry proto.InternalMessageInfo
   179  
   180  func init() {
   181  	proto.RegisterType((*Receiver)(nil), "nflogpb.Receiver")
   182  	proto.RegisterType((*Entry)(nil), "nflogpb.Entry")
   183  	proto.RegisterType((*MeshEntry)(nil), "nflogpb.MeshEntry")
   184  }
   185  
   186  func init() { proto.RegisterFile("nflog.proto", fileDescriptor_c2d9785ad9c3e602) }
   187  
   188  var fileDescriptor_c2d9785ad9c3e602 = []byte{
   189  	// 385 bytes of a gzipped FileDescriptorProto
   190  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x90, 0xcf, 0x6e, 0xd3, 0x40,
   191  	0x10, 0xc6, 0xbb, 0x4d, 0xd3, 0xda, 0xe3, 0xb4, 0x94, 0x15, 0x07, 0xcb, 0x08, 0xc7, 0x0a, 0x48,
   192  	0xf8, 0x82, 0x23, 0x95, 0x27, 0x68, 0x10, 0x12, 0x12, 0x82, 0xc3, 0x8a, 0x2b, 0xb2, 0x36, 0x74,
   193  	0xb2, 0x5e, 0x61, 0x7b, 0xad, 0xf5, 0x36, 0x6a, 0xde, 0x82, 0x47, 0xe0, 0x71, 0x72, 0xe4, 0x09,
   194  	0xf8, 0x93, 0x27, 0x41, 0xde, 0xb5, 0x1d, 0x8e, 0xdc, 0x66, 0x7f, 0xf3, 0xcd, 0xcc, 0xb7, 0x1f,
   195  	0x04, 0xf5, 0xa6, 0x54, 0x22, 0x6b, 0xb4, 0x32, 0x8a, 0x5e, 0xd8, 0x47, 0xb3, 0x8e, 0xe6, 0x42,
   196  	0x29, 0x51, 0xe2, 0xd2, 0xe2, 0xf5, 0xfd, 0x66, 0x69, 0x64, 0x85, 0xad, 0xe1, 0x55, 0xe3, 0x94,
   197  	0xd1, 0x13, 0xa1, 0x84, 0xb2, 0xe5, 0xb2, 0xab, 0x1c, 0x5d, 0x7c, 0x06, 0x8f, 0xe1, 0x17, 0x94,
   198  	0x5b, 0xd4, 0xf4, 0x19, 0x80, 0xd0, 0xea, 0xbe, 0xc9, 0x6b, 0x5e, 0x61, 0x48, 0x12, 0x92, 0xfa,
   199  	0xcc, 0xb7, 0xe4, 0x23, 0xaf, 0x90, 0x26, 0x10, 0xc8, 0xda, 0xa0, 0xd0, 0xdc, 0x48, 0x55, 0x87,
   200  	0xa7, 0xb6, 0xff, 0x2f, 0xa2, 0xd7, 0x30, 0x91, 0x77, 0x0f, 0xe1, 0x24, 0x21, 0xe9, 0x25, 0xeb,
   201  	0xca, 0xc5, 0xf7, 0x53, 0x98, 0xbe, 0xad, 0x8d, 0xde, 0xd1, 0xa7, 0xe0, 0x56, 0xe5, 0x5f, 0x71,
   202  	0x67, 0x77, 0xcf, 0x98, 0x67, 0xc1, 0x7b, 0xdc, 0xd1, 0x57, 0xe0, 0xe9, 0xde, 0x85, 0xdd, 0x1b,
   203  	0xdc, 0x3c, 0xce, 0xfa, 0x8f, 0x65, 0x83, 0x3d, 0x36, 0x4a, 0x8e, 0x46, 0x0b, 0xde, 0x16, 0xf6,
   204  	0xdc, 0xac, 0x37, 0xfa, 0x8e, 0xb7, 0x05, 0x8d, 0xba, 0x6d, 0xad, 0x2a, 0xb7, 0x78, 0x17, 0x9e,
   205  	0x25, 0x24, 0xf5, 0xd8, 0xf8, 0xa6, 0x2b, 0xf0, 0xc7, 0x60, 0xc2, 0xa9, 0x3d, 0x15, 0x65, 0x2e,
   206  	0xba, 0x6c, 0x88, 0x2e, 0xfb, 0x34, 0x28, 0x56, 0xde, 0xfe, 0xe7, 0xfc, 0xe4, 0xdb, 0xaf, 0x39,
   207  	0x61, 0xc7, 0x31, 0xfa, 0x1c, 0x2e, 0x37, 0x52, 0xcb, 0x5a, 0xe4, 0xbc, 0x44, 0x6d, 0xda, 0xf0,
   208  	0x3c, 0x99, 0xa4, 0x67, 0x6c, 0xe6, 0xe0, 0xad, 0x65, 0xf4, 0x25, 0x3c, 0x1a, 0x8e, 0x0e, 0xb2,
   209  	0x0b, 0x2b, 0xbb, 0x1a, 0xb0, 0x13, 0x2e, 0xb6, 0xe0, 0x7f, 0xc0, 0xb6, 0x70, 0x29, 0xbd, 0x80,
   210  	0x29, 0x76, 0x85, 0x4d, 0x28, 0xb8, 0xb9, 0x1a, 0x53, 0xb0, 0x6d, 0xe6, 0x9a, 0xf4, 0x0d, 0x00,
   211  	0x3e, 0x34, 0x52, 0x63, 0x9b, 0x73, 0xd3, 0x07, 0xf6, 0x9f, 0xbf, 0xe8, 0xe7, 0x6e, 0xcd, 0xea,
   212  	0x7a, 0xff, 0x27, 0x3e, 0xd9, 0x1f, 0x62, 0xf2, 0xe3, 0x10, 0x93, 0xdf, 0x87, 0x98, 0xac, 0xcf,
   213  	0xed, 0xe8, 0xeb, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x49, 0xcd, 0xa7, 0x1e, 0x61, 0x02, 0x00,
   214  	0x00,
   215  }
   216  
   217  func (m *Receiver) Marshal() (dAtA []byte, err error) {
   218  	size := m.Size()
   219  	dAtA = make([]byte, size)
   220  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   221  	if err != nil {
   222  		return nil, err
   223  	}
   224  	return dAtA[:n], nil
   225  }
   226  
   227  func (m *Receiver) MarshalTo(dAtA []byte) (int, error) {
   228  	size := m.Size()
   229  	return m.MarshalToSizedBuffer(dAtA[:size])
   230  }
   231  
   232  func (m *Receiver) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   233  	i := len(dAtA)
   234  	_ = i
   235  	var l int
   236  	_ = l
   237  	if m.XXX_unrecognized != nil {
   238  		i -= len(m.XXX_unrecognized)
   239  		copy(dAtA[i:], m.XXX_unrecognized)
   240  	}
   241  	if m.Idx != 0 {
   242  		i = encodeVarintNflog(dAtA, i, uint64(m.Idx))
   243  		i--
   244  		dAtA[i] = 0x18
   245  	}
   246  	if len(m.Integration) > 0 {
   247  		i -= len(m.Integration)
   248  		copy(dAtA[i:], m.Integration)
   249  		i = encodeVarintNflog(dAtA, i, uint64(len(m.Integration)))
   250  		i--
   251  		dAtA[i] = 0x12
   252  	}
   253  	if len(m.GroupName) > 0 {
   254  		i -= len(m.GroupName)
   255  		copy(dAtA[i:], m.GroupName)
   256  		i = encodeVarintNflog(dAtA, i, uint64(len(m.GroupName)))
   257  		i--
   258  		dAtA[i] = 0xa
   259  	}
   260  	return len(dAtA) - i, nil
   261  }
   262  
   263  func (m *Entry) Marshal() (dAtA []byte, err error) {
   264  	size := m.Size()
   265  	dAtA = make([]byte, size)
   266  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   267  	if err != nil {
   268  		return nil, err
   269  	}
   270  	return dAtA[:n], nil
   271  }
   272  
   273  func (m *Entry) MarshalTo(dAtA []byte) (int, error) {
   274  	size := m.Size()
   275  	return m.MarshalToSizedBuffer(dAtA[:size])
   276  }
   277  
   278  func (m *Entry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   279  	i := len(dAtA)
   280  	_ = i
   281  	var l int
   282  	_ = l
   283  	if m.XXX_unrecognized != nil {
   284  		i -= len(m.XXX_unrecognized)
   285  		copy(dAtA[i:], m.XXX_unrecognized)
   286  	}
   287  	if len(m.ResolvedAlerts) > 0 {
   288  		dAtA2 := make([]byte, len(m.ResolvedAlerts)*10)
   289  		var j1 int
   290  		for _, num := range m.ResolvedAlerts {
   291  			for num >= 1<<7 {
   292  				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
   293  				num >>= 7
   294  				j1++
   295  			}
   296  			dAtA2[j1] = uint8(num)
   297  			j1++
   298  		}
   299  		i -= j1
   300  		copy(dAtA[i:], dAtA2[:j1])
   301  		i = encodeVarintNflog(dAtA, i, uint64(j1))
   302  		i--
   303  		dAtA[i] = 0x3a
   304  	}
   305  	if len(m.FiringAlerts) > 0 {
   306  		dAtA4 := make([]byte, len(m.FiringAlerts)*10)
   307  		var j3 int
   308  		for _, num := range m.FiringAlerts {
   309  			for num >= 1<<7 {
   310  				dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80)
   311  				num >>= 7
   312  				j3++
   313  			}
   314  			dAtA4[j3] = uint8(num)
   315  			j3++
   316  		}
   317  		i -= j3
   318  		copy(dAtA[i:], dAtA4[:j3])
   319  		i = encodeVarintNflog(dAtA, i, uint64(j3))
   320  		i--
   321  		dAtA[i] = 0x32
   322  	}
   323  	n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
   324  	if err5 != nil {
   325  		return 0, err5
   326  	}
   327  	i -= n5
   328  	i = encodeVarintNflog(dAtA, i, uint64(n5))
   329  	i--
   330  	dAtA[i] = 0x2a
   331  	if m.Resolved {
   332  		i--
   333  		if m.Resolved {
   334  			dAtA[i] = 1
   335  		} else {
   336  			dAtA[i] = 0
   337  		}
   338  		i--
   339  		dAtA[i] = 0x20
   340  	}
   341  	if len(m.GroupHash) > 0 {
   342  		i -= len(m.GroupHash)
   343  		copy(dAtA[i:], m.GroupHash)
   344  		i = encodeVarintNflog(dAtA, i, uint64(len(m.GroupHash)))
   345  		i--
   346  		dAtA[i] = 0x1a
   347  	}
   348  	if m.Receiver != nil {
   349  		{
   350  			size, err := m.Receiver.MarshalToSizedBuffer(dAtA[:i])
   351  			if err != nil {
   352  				return 0, err
   353  			}
   354  			i -= size
   355  			i = encodeVarintNflog(dAtA, i, uint64(size))
   356  		}
   357  		i--
   358  		dAtA[i] = 0x12
   359  	}
   360  	if len(m.GroupKey) > 0 {
   361  		i -= len(m.GroupKey)
   362  		copy(dAtA[i:], m.GroupKey)
   363  		i = encodeVarintNflog(dAtA, i, uint64(len(m.GroupKey)))
   364  		i--
   365  		dAtA[i] = 0xa
   366  	}
   367  	return len(dAtA) - i, nil
   368  }
   369  
   370  func (m *MeshEntry) Marshal() (dAtA []byte, err error) {
   371  	size := m.Size()
   372  	dAtA = make([]byte, size)
   373  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   374  	if err != nil {
   375  		return nil, err
   376  	}
   377  	return dAtA[:n], nil
   378  }
   379  
   380  func (m *MeshEntry) MarshalTo(dAtA []byte) (int, error) {
   381  	size := m.Size()
   382  	return m.MarshalToSizedBuffer(dAtA[:size])
   383  }
   384  
   385  func (m *MeshEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   386  	i := len(dAtA)
   387  	_ = i
   388  	var l int
   389  	_ = l
   390  	if m.XXX_unrecognized != nil {
   391  		i -= len(m.XXX_unrecognized)
   392  		copy(dAtA[i:], m.XXX_unrecognized)
   393  	}
   394  	n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExpiresAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ExpiresAt):])
   395  	if err7 != nil {
   396  		return 0, err7
   397  	}
   398  	i -= n7
   399  	i = encodeVarintNflog(dAtA, i, uint64(n7))
   400  	i--
   401  	dAtA[i] = 0x12
   402  	if m.Entry != nil {
   403  		{
   404  			size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i])
   405  			if err != nil {
   406  				return 0, err
   407  			}
   408  			i -= size
   409  			i = encodeVarintNflog(dAtA, i, uint64(size))
   410  		}
   411  		i--
   412  		dAtA[i] = 0xa
   413  	}
   414  	return len(dAtA) - i, nil
   415  }
   416  
   417  func encodeVarintNflog(dAtA []byte, offset int, v uint64) int {
   418  	offset -= sovNflog(v)
   419  	base := offset
   420  	for v >= 1<<7 {
   421  		dAtA[offset] = uint8(v&0x7f | 0x80)
   422  		v >>= 7
   423  		offset++
   424  	}
   425  	dAtA[offset] = uint8(v)
   426  	return base
   427  }
   428  func (m *Receiver) Size() (n int) {
   429  	if m == nil {
   430  		return 0
   431  	}
   432  	var l int
   433  	_ = l
   434  	l = len(m.GroupName)
   435  	if l > 0 {
   436  		n += 1 + l + sovNflog(uint64(l))
   437  	}
   438  	l = len(m.Integration)
   439  	if l > 0 {
   440  		n += 1 + l + sovNflog(uint64(l))
   441  	}
   442  	if m.Idx != 0 {
   443  		n += 1 + sovNflog(uint64(m.Idx))
   444  	}
   445  	if m.XXX_unrecognized != nil {
   446  		n += len(m.XXX_unrecognized)
   447  	}
   448  	return n
   449  }
   450  
   451  func (m *Entry) Size() (n int) {
   452  	if m == nil {
   453  		return 0
   454  	}
   455  	var l int
   456  	_ = l
   457  	l = len(m.GroupKey)
   458  	if l > 0 {
   459  		n += 1 + l + sovNflog(uint64(l))
   460  	}
   461  	if m.Receiver != nil {
   462  		l = m.Receiver.Size()
   463  		n += 1 + l + sovNflog(uint64(l))
   464  	}
   465  	l = len(m.GroupHash)
   466  	if l > 0 {
   467  		n += 1 + l + sovNflog(uint64(l))
   468  	}
   469  	if m.Resolved {
   470  		n += 2
   471  	}
   472  	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
   473  	n += 1 + l + sovNflog(uint64(l))
   474  	if len(m.FiringAlerts) > 0 {
   475  		l = 0
   476  		for _, e := range m.FiringAlerts {
   477  			l += sovNflog(uint64(e))
   478  		}
   479  		n += 1 + sovNflog(uint64(l)) + l
   480  	}
   481  	if len(m.ResolvedAlerts) > 0 {
   482  		l = 0
   483  		for _, e := range m.ResolvedAlerts {
   484  			l += sovNflog(uint64(e))
   485  		}
   486  		n += 1 + sovNflog(uint64(l)) + l
   487  	}
   488  	if m.XXX_unrecognized != nil {
   489  		n += len(m.XXX_unrecognized)
   490  	}
   491  	return n
   492  }
   493  
   494  func (m *MeshEntry) Size() (n int) {
   495  	if m == nil {
   496  		return 0
   497  	}
   498  	var l int
   499  	_ = l
   500  	if m.Entry != nil {
   501  		l = m.Entry.Size()
   502  		n += 1 + l + sovNflog(uint64(l))
   503  	}
   504  	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExpiresAt)
   505  	n += 1 + l + sovNflog(uint64(l))
   506  	if m.XXX_unrecognized != nil {
   507  		n += len(m.XXX_unrecognized)
   508  	}
   509  	return n
   510  }
   511  
   512  func sovNflog(x uint64) (n int) {
   513  	return (math_bits.Len64(x|1) + 6) / 7
   514  }
   515  func sozNflog(x uint64) (n int) {
   516  	return sovNflog(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   517  }
   518  func (m *Receiver) Unmarshal(dAtA []byte) error {
   519  	l := len(dAtA)
   520  	iNdEx := 0
   521  	for iNdEx < l {
   522  		preIndex := iNdEx
   523  		var wire uint64
   524  		for shift := uint(0); ; shift += 7 {
   525  			if shift >= 64 {
   526  				return ErrIntOverflowNflog
   527  			}
   528  			if iNdEx >= l {
   529  				return io.ErrUnexpectedEOF
   530  			}
   531  			b := dAtA[iNdEx]
   532  			iNdEx++
   533  			wire |= uint64(b&0x7F) << shift
   534  			if b < 0x80 {
   535  				break
   536  			}
   537  		}
   538  		fieldNum := int32(wire >> 3)
   539  		wireType := int(wire & 0x7)
   540  		if wireType == 4 {
   541  			return fmt.Errorf("proto: Receiver: wiretype end group for non-group")
   542  		}
   543  		if fieldNum <= 0 {
   544  			return fmt.Errorf("proto: Receiver: illegal tag %d (wire type %d)", fieldNum, wire)
   545  		}
   546  		switch fieldNum {
   547  		case 1:
   548  			if wireType != 2 {
   549  				return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType)
   550  			}
   551  			var stringLen uint64
   552  			for shift := uint(0); ; shift += 7 {
   553  				if shift >= 64 {
   554  					return ErrIntOverflowNflog
   555  				}
   556  				if iNdEx >= l {
   557  					return io.ErrUnexpectedEOF
   558  				}
   559  				b := dAtA[iNdEx]
   560  				iNdEx++
   561  				stringLen |= uint64(b&0x7F) << shift
   562  				if b < 0x80 {
   563  					break
   564  				}
   565  			}
   566  			intStringLen := int(stringLen)
   567  			if intStringLen < 0 {
   568  				return ErrInvalidLengthNflog
   569  			}
   570  			postIndex := iNdEx + intStringLen
   571  			if postIndex < 0 {
   572  				return ErrInvalidLengthNflog
   573  			}
   574  			if postIndex > l {
   575  				return io.ErrUnexpectedEOF
   576  			}
   577  			m.GroupName = string(dAtA[iNdEx:postIndex])
   578  			iNdEx = postIndex
   579  		case 2:
   580  			if wireType != 2 {
   581  				return fmt.Errorf("proto: wrong wireType = %d for field Integration", wireType)
   582  			}
   583  			var stringLen uint64
   584  			for shift := uint(0); ; shift += 7 {
   585  				if shift >= 64 {
   586  					return ErrIntOverflowNflog
   587  				}
   588  				if iNdEx >= l {
   589  					return io.ErrUnexpectedEOF
   590  				}
   591  				b := dAtA[iNdEx]
   592  				iNdEx++
   593  				stringLen |= uint64(b&0x7F) << shift
   594  				if b < 0x80 {
   595  					break
   596  				}
   597  			}
   598  			intStringLen := int(stringLen)
   599  			if intStringLen < 0 {
   600  				return ErrInvalidLengthNflog
   601  			}
   602  			postIndex := iNdEx + intStringLen
   603  			if postIndex < 0 {
   604  				return ErrInvalidLengthNflog
   605  			}
   606  			if postIndex > l {
   607  				return io.ErrUnexpectedEOF
   608  			}
   609  			m.Integration = string(dAtA[iNdEx:postIndex])
   610  			iNdEx = postIndex
   611  		case 3:
   612  			if wireType != 0 {
   613  				return fmt.Errorf("proto: wrong wireType = %d for field Idx", wireType)
   614  			}
   615  			m.Idx = 0
   616  			for shift := uint(0); ; shift += 7 {
   617  				if shift >= 64 {
   618  					return ErrIntOverflowNflog
   619  				}
   620  				if iNdEx >= l {
   621  					return io.ErrUnexpectedEOF
   622  				}
   623  				b := dAtA[iNdEx]
   624  				iNdEx++
   625  				m.Idx |= uint32(b&0x7F) << shift
   626  				if b < 0x80 {
   627  					break
   628  				}
   629  			}
   630  		default:
   631  			iNdEx = preIndex
   632  			skippy, err := skipNflog(dAtA[iNdEx:])
   633  			if err != nil {
   634  				return err
   635  			}
   636  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   637  				return ErrInvalidLengthNflog
   638  			}
   639  			if (iNdEx + skippy) > l {
   640  				return io.ErrUnexpectedEOF
   641  			}
   642  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
   643  			iNdEx += skippy
   644  		}
   645  	}
   646  
   647  	if iNdEx > l {
   648  		return io.ErrUnexpectedEOF
   649  	}
   650  	return nil
   651  }
   652  func (m *Entry) Unmarshal(dAtA []byte) error {
   653  	l := len(dAtA)
   654  	iNdEx := 0
   655  	for iNdEx < l {
   656  		preIndex := iNdEx
   657  		var wire uint64
   658  		for shift := uint(0); ; shift += 7 {
   659  			if shift >= 64 {
   660  				return ErrIntOverflowNflog
   661  			}
   662  			if iNdEx >= l {
   663  				return io.ErrUnexpectedEOF
   664  			}
   665  			b := dAtA[iNdEx]
   666  			iNdEx++
   667  			wire |= uint64(b&0x7F) << shift
   668  			if b < 0x80 {
   669  				break
   670  			}
   671  		}
   672  		fieldNum := int32(wire >> 3)
   673  		wireType := int(wire & 0x7)
   674  		if wireType == 4 {
   675  			return fmt.Errorf("proto: Entry: wiretype end group for non-group")
   676  		}
   677  		if fieldNum <= 0 {
   678  			return fmt.Errorf("proto: Entry: illegal tag %d (wire type %d)", fieldNum, wire)
   679  		}
   680  		switch fieldNum {
   681  		case 1:
   682  			if wireType != 2 {
   683  				return fmt.Errorf("proto: wrong wireType = %d for field GroupKey", wireType)
   684  			}
   685  			var byteLen int
   686  			for shift := uint(0); ; shift += 7 {
   687  				if shift >= 64 {
   688  					return ErrIntOverflowNflog
   689  				}
   690  				if iNdEx >= l {
   691  					return io.ErrUnexpectedEOF
   692  				}
   693  				b := dAtA[iNdEx]
   694  				iNdEx++
   695  				byteLen |= int(b&0x7F) << shift
   696  				if b < 0x80 {
   697  					break
   698  				}
   699  			}
   700  			if byteLen < 0 {
   701  				return ErrInvalidLengthNflog
   702  			}
   703  			postIndex := iNdEx + byteLen
   704  			if postIndex < 0 {
   705  				return ErrInvalidLengthNflog
   706  			}
   707  			if postIndex > l {
   708  				return io.ErrUnexpectedEOF
   709  			}
   710  			m.GroupKey = append(m.GroupKey[:0], dAtA[iNdEx:postIndex]...)
   711  			if m.GroupKey == nil {
   712  				m.GroupKey = []byte{}
   713  			}
   714  			iNdEx = postIndex
   715  		case 2:
   716  			if wireType != 2 {
   717  				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", wireType)
   718  			}
   719  			var msglen int
   720  			for shift := uint(0); ; shift += 7 {
   721  				if shift >= 64 {
   722  					return ErrIntOverflowNflog
   723  				}
   724  				if iNdEx >= l {
   725  					return io.ErrUnexpectedEOF
   726  				}
   727  				b := dAtA[iNdEx]
   728  				iNdEx++
   729  				msglen |= int(b&0x7F) << shift
   730  				if b < 0x80 {
   731  					break
   732  				}
   733  			}
   734  			if msglen < 0 {
   735  				return ErrInvalidLengthNflog
   736  			}
   737  			postIndex := iNdEx + msglen
   738  			if postIndex < 0 {
   739  				return ErrInvalidLengthNflog
   740  			}
   741  			if postIndex > l {
   742  				return io.ErrUnexpectedEOF
   743  			}
   744  			if m.Receiver == nil {
   745  				m.Receiver = &Receiver{}
   746  			}
   747  			if err := m.Receiver.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   748  				return err
   749  			}
   750  			iNdEx = postIndex
   751  		case 3:
   752  			if wireType != 2 {
   753  				return fmt.Errorf("proto: wrong wireType = %d for field GroupHash", wireType)
   754  			}
   755  			var byteLen int
   756  			for shift := uint(0); ; shift += 7 {
   757  				if shift >= 64 {
   758  					return ErrIntOverflowNflog
   759  				}
   760  				if iNdEx >= l {
   761  					return io.ErrUnexpectedEOF
   762  				}
   763  				b := dAtA[iNdEx]
   764  				iNdEx++
   765  				byteLen |= int(b&0x7F) << shift
   766  				if b < 0x80 {
   767  					break
   768  				}
   769  			}
   770  			if byteLen < 0 {
   771  				return ErrInvalidLengthNflog
   772  			}
   773  			postIndex := iNdEx + byteLen
   774  			if postIndex < 0 {
   775  				return ErrInvalidLengthNflog
   776  			}
   777  			if postIndex > l {
   778  				return io.ErrUnexpectedEOF
   779  			}
   780  			m.GroupHash = append(m.GroupHash[:0], dAtA[iNdEx:postIndex]...)
   781  			if m.GroupHash == nil {
   782  				m.GroupHash = []byte{}
   783  			}
   784  			iNdEx = postIndex
   785  		case 4:
   786  			if wireType != 0 {
   787  				return fmt.Errorf("proto: wrong wireType = %d for field Resolved", wireType)
   788  			}
   789  			var v int
   790  			for shift := uint(0); ; shift += 7 {
   791  				if shift >= 64 {
   792  					return ErrIntOverflowNflog
   793  				}
   794  				if iNdEx >= l {
   795  					return io.ErrUnexpectedEOF
   796  				}
   797  				b := dAtA[iNdEx]
   798  				iNdEx++
   799  				v |= int(b&0x7F) << shift
   800  				if b < 0x80 {
   801  					break
   802  				}
   803  			}
   804  			m.Resolved = bool(v != 0)
   805  		case 5:
   806  			if wireType != 2 {
   807  				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
   808  			}
   809  			var msglen int
   810  			for shift := uint(0); ; shift += 7 {
   811  				if shift >= 64 {
   812  					return ErrIntOverflowNflog
   813  				}
   814  				if iNdEx >= l {
   815  					return io.ErrUnexpectedEOF
   816  				}
   817  				b := dAtA[iNdEx]
   818  				iNdEx++
   819  				msglen |= int(b&0x7F) << shift
   820  				if b < 0x80 {
   821  					break
   822  				}
   823  			}
   824  			if msglen < 0 {
   825  				return ErrInvalidLengthNflog
   826  			}
   827  			postIndex := iNdEx + msglen
   828  			if postIndex < 0 {
   829  				return ErrInvalidLengthNflog
   830  			}
   831  			if postIndex > l {
   832  				return io.ErrUnexpectedEOF
   833  			}
   834  			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
   835  				return err
   836  			}
   837  			iNdEx = postIndex
   838  		case 6:
   839  			if wireType == 0 {
   840  				var v uint64
   841  				for shift := uint(0); ; shift += 7 {
   842  					if shift >= 64 {
   843  						return ErrIntOverflowNflog
   844  					}
   845  					if iNdEx >= l {
   846  						return io.ErrUnexpectedEOF
   847  					}
   848  					b := dAtA[iNdEx]
   849  					iNdEx++
   850  					v |= uint64(b&0x7F) << shift
   851  					if b < 0x80 {
   852  						break
   853  					}
   854  				}
   855  				m.FiringAlerts = append(m.FiringAlerts, v)
   856  			} else if wireType == 2 {
   857  				var packedLen int
   858  				for shift := uint(0); ; shift += 7 {
   859  					if shift >= 64 {
   860  						return ErrIntOverflowNflog
   861  					}
   862  					if iNdEx >= l {
   863  						return io.ErrUnexpectedEOF
   864  					}
   865  					b := dAtA[iNdEx]
   866  					iNdEx++
   867  					packedLen |= int(b&0x7F) << shift
   868  					if b < 0x80 {
   869  						break
   870  					}
   871  				}
   872  				if packedLen < 0 {
   873  					return ErrInvalidLengthNflog
   874  				}
   875  				postIndex := iNdEx + packedLen
   876  				if postIndex < 0 {
   877  					return ErrInvalidLengthNflog
   878  				}
   879  				if postIndex > l {
   880  					return io.ErrUnexpectedEOF
   881  				}
   882  				var elementCount int
   883  				var count int
   884  				for _, integer := range dAtA[iNdEx:postIndex] {
   885  					if integer < 128 {
   886  						count++
   887  					}
   888  				}
   889  				elementCount = count
   890  				if elementCount != 0 && len(m.FiringAlerts) == 0 {
   891  					m.FiringAlerts = make([]uint64, 0, elementCount)
   892  				}
   893  				for iNdEx < postIndex {
   894  					var v uint64
   895  					for shift := uint(0); ; shift += 7 {
   896  						if shift >= 64 {
   897  							return ErrIntOverflowNflog
   898  						}
   899  						if iNdEx >= l {
   900  							return io.ErrUnexpectedEOF
   901  						}
   902  						b := dAtA[iNdEx]
   903  						iNdEx++
   904  						v |= uint64(b&0x7F) << shift
   905  						if b < 0x80 {
   906  							break
   907  						}
   908  					}
   909  					m.FiringAlerts = append(m.FiringAlerts, v)
   910  				}
   911  			} else {
   912  				return fmt.Errorf("proto: wrong wireType = %d for field FiringAlerts", wireType)
   913  			}
   914  		case 7:
   915  			if wireType == 0 {
   916  				var v uint64
   917  				for shift := uint(0); ; shift += 7 {
   918  					if shift >= 64 {
   919  						return ErrIntOverflowNflog
   920  					}
   921  					if iNdEx >= l {
   922  						return io.ErrUnexpectedEOF
   923  					}
   924  					b := dAtA[iNdEx]
   925  					iNdEx++
   926  					v |= uint64(b&0x7F) << shift
   927  					if b < 0x80 {
   928  						break
   929  					}
   930  				}
   931  				m.ResolvedAlerts = append(m.ResolvedAlerts, v)
   932  			} else if wireType == 2 {
   933  				var packedLen int
   934  				for shift := uint(0); ; shift += 7 {
   935  					if shift >= 64 {
   936  						return ErrIntOverflowNflog
   937  					}
   938  					if iNdEx >= l {
   939  						return io.ErrUnexpectedEOF
   940  					}
   941  					b := dAtA[iNdEx]
   942  					iNdEx++
   943  					packedLen |= int(b&0x7F) << shift
   944  					if b < 0x80 {
   945  						break
   946  					}
   947  				}
   948  				if packedLen < 0 {
   949  					return ErrInvalidLengthNflog
   950  				}
   951  				postIndex := iNdEx + packedLen
   952  				if postIndex < 0 {
   953  					return ErrInvalidLengthNflog
   954  				}
   955  				if postIndex > l {
   956  					return io.ErrUnexpectedEOF
   957  				}
   958  				var elementCount int
   959  				var count int
   960  				for _, integer := range dAtA[iNdEx:postIndex] {
   961  					if integer < 128 {
   962  						count++
   963  					}
   964  				}
   965  				elementCount = count
   966  				if elementCount != 0 && len(m.ResolvedAlerts) == 0 {
   967  					m.ResolvedAlerts = make([]uint64, 0, elementCount)
   968  				}
   969  				for iNdEx < postIndex {
   970  					var v uint64
   971  					for shift := uint(0); ; shift += 7 {
   972  						if shift >= 64 {
   973  							return ErrIntOverflowNflog
   974  						}
   975  						if iNdEx >= l {
   976  							return io.ErrUnexpectedEOF
   977  						}
   978  						b := dAtA[iNdEx]
   979  						iNdEx++
   980  						v |= uint64(b&0x7F) << shift
   981  						if b < 0x80 {
   982  							break
   983  						}
   984  					}
   985  					m.ResolvedAlerts = append(m.ResolvedAlerts, v)
   986  				}
   987  			} else {
   988  				return fmt.Errorf("proto: wrong wireType = %d for field ResolvedAlerts", wireType)
   989  			}
   990  		default:
   991  			iNdEx = preIndex
   992  			skippy, err := skipNflog(dAtA[iNdEx:])
   993  			if err != nil {
   994  				return err
   995  			}
   996  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   997  				return ErrInvalidLengthNflog
   998  			}
   999  			if (iNdEx + skippy) > l {
  1000  				return io.ErrUnexpectedEOF
  1001  			}
  1002  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1003  			iNdEx += skippy
  1004  		}
  1005  	}
  1006  
  1007  	if iNdEx > l {
  1008  		return io.ErrUnexpectedEOF
  1009  	}
  1010  	return nil
  1011  }
  1012  func (m *MeshEntry) Unmarshal(dAtA []byte) error {
  1013  	l := len(dAtA)
  1014  	iNdEx := 0
  1015  	for iNdEx < l {
  1016  		preIndex := iNdEx
  1017  		var wire uint64
  1018  		for shift := uint(0); ; shift += 7 {
  1019  			if shift >= 64 {
  1020  				return ErrIntOverflowNflog
  1021  			}
  1022  			if iNdEx >= l {
  1023  				return io.ErrUnexpectedEOF
  1024  			}
  1025  			b := dAtA[iNdEx]
  1026  			iNdEx++
  1027  			wire |= uint64(b&0x7F) << shift
  1028  			if b < 0x80 {
  1029  				break
  1030  			}
  1031  		}
  1032  		fieldNum := int32(wire >> 3)
  1033  		wireType := int(wire & 0x7)
  1034  		if wireType == 4 {
  1035  			return fmt.Errorf("proto: MeshEntry: wiretype end group for non-group")
  1036  		}
  1037  		if fieldNum <= 0 {
  1038  			return fmt.Errorf("proto: MeshEntry: illegal tag %d (wire type %d)", fieldNum, wire)
  1039  		}
  1040  		switch fieldNum {
  1041  		case 1:
  1042  			if wireType != 2 {
  1043  				return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)
  1044  			}
  1045  			var msglen int
  1046  			for shift := uint(0); ; shift += 7 {
  1047  				if shift >= 64 {
  1048  					return ErrIntOverflowNflog
  1049  				}
  1050  				if iNdEx >= l {
  1051  					return io.ErrUnexpectedEOF
  1052  				}
  1053  				b := dAtA[iNdEx]
  1054  				iNdEx++
  1055  				msglen |= int(b&0x7F) << shift
  1056  				if b < 0x80 {
  1057  					break
  1058  				}
  1059  			}
  1060  			if msglen < 0 {
  1061  				return ErrInvalidLengthNflog
  1062  			}
  1063  			postIndex := iNdEx + msglen
  1064  			if postIndex < 0 {
  1065  				return ErrInvalidLengthNflog
  1066  			}
  1067  			if postIndex > l {
  1068  				return io.ErrUnexpectedEOF
  1069  			}
  1070  			if m.Entry == nil {
  1071  				m.Entry = &Entry{}
  1072  			}
  1073  			if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1074  				return err
  1075  			}
  1076  			iNdEx = postIndex
  1077  		case 2:
  1078  			if wireType != 2 {
  1079  				return fmt.Errorf("proto: wrong wireType = %d for field ExpiresAt", wireType)
  1080  			}
  1081  			var msglen int
  1082  			for shift := uint(0); ; shift += 7 {
  1083  				if shift >= 64 {
  1084  					return ErrIntOverflowNflog
  1085  				}
  1086  				if iNdEx >= l {
  1087  					return io.ErrUnexpectedEOF
  1088  				}
  1089  				b := dAtA[iNdEx]
  1090  				iNdEx++
  1091  				msglen |= int(b&0x7F) << shift
  1092  				if b < 0x80 {
  1093  					break
  1094  				}
  1095  			}
  1096  			if msglen < 0 {
  1097  				return ErrInvalidLengthNflog
  1098  			}
  1099  			postIndex := iNdEx + msglen
  1100  			if postIndex < 0 {
  1101  				return ErrInvalidLengthNflog
  1102  			}
  1103  			if postIndex > l {
  1104  				return io.ErrUnexpectedEOF
  1105  			}
  1106  			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExpiresAt, dAtA[iNdEx:postIndex]); err != nil {
  1107  				return err
  1108  			}
  1109  			iNdEx = postIndex
  1110  		default:
  1111  			iNdEx = preIndex
  1112  			skippy, err := skipNflog(dAtA[iNdEx:])
  1113  			if err != nil {
  1114  				return err
  1115  			}
  1116  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1117  				return ErrInvalidLengthNflog
  1118  			}
  1119  			if (iNdEx + skippy) > l {
  1120  				return io.ErrUnexpectedEOF
  1121  			}
  1122  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1123  			iNdEx += skippy
  1124  		}
  1125  	}
  1126  
  1127  	if iNdEx > l {
  1128  		return io.ErrUnexpectedEOF
  1129  	}
  1130  	return nil
  1131  }
  1132  func skipNflog(dAtA []byte) (n int, err error) {
  1133  	l := len(dAtA)
  1134  	iNdEx := 0
  1135  	depth := 0
  1136  	for iNdEx < l {
  1137  		var wire uint64
  1138  		for shift := uint(0); ; shift += 7 {
  1139  			if shift >= 64 {
  1140  				return 0, ErrIntOverflowNflog
  1141  			}
  1142  			if iNdEx >= l {
  1143  				return 0, io.ErrUnexpectedEOF
  1144  			}
  1145  			b := dAtA[iNdEx]
  1146  			iNdEx++
  1147  			wire |= (uint64(b) & 0x7F) << shift
  1148  			if b < 0x80 {
  1149  				break
  1150  			}
  1151  		}
  1152  		wireType := int(wire & 0x7)
  1153  		switch wireType {
  1154  		case 0:
  1155  			for shift := uint(0); ; shift += 7 {
  1156  				if shift >= 64 {
  1157  					return 0, ErrIntOverflowNflog
  1158  				}
  1159  				if iNdEx >= l {
  1160  					return 0, io.ErrUnexpectedEOF
  1161  				}
  1162  				iNdEx++
  1163  				if dAtA[iNdEx-1] < 0x80 {
  1164  					break
  1165  				}
  1166  			}
  1167  		case 1:
  1168  			iNdEx += 8
  1169  		case 2:
  1170  			var length int
  1171  			for shift := uint(0); ; shift += 7 {
  1172  				if shift >= 64 {
  1173  					return 0, ErrIntOverflowNflog
  1174  				}
  1175  				if iNdEx >= l {
  1176  					return 0, io.ErrUnexpectedEOF
  1177  				}
  1178  				b := dAtA[iNdEx]
  1179  				iNdEx++
  1180  				length |= (int(b) & 0x7F) << shift
  1181  				if b < 0x80 {
  1182  					break
  1183  				}
  1184  			}
  1185  			if length < 0 {
  1186  				return 0, ErrInvalidLengthNflog
  1187  			}
  1188  			iNdEx += length
  1189  		case 3:
  1190  			depth++
  1191  		case 4:
  1192  			if depth == 0 {
  1193  				return 0, ErrUnexpectedEndOfGroupNflog
  1194  			}
  1195  			depth--
  1196  		case 5:
  1197  			iNdEx += 4
  1198  		default:
  1199  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  1200  		}
  1201  		if iNdEx < 0 {
  1202  			return 0, ErrInvalidLengthNflog
  1203  		}
  1204  		if depth == 0 {
  1205  			return iNdEx, nil
  1206  		}
  1207  	}
  1208  	return 0, io.ErrUnexpectedEOF
  1209  }
  1210  
  1211  var (
  1212  	ErrInvalidLengthNflog        = fmt.Errorf("proto: negative length found during unmarshaling")
  1213  	ErrIntOverflowNflog          = fmt.Errorf("proto: integer overflow")
  1214  	ErrUnexpectedEndOfGroupNflog = fmt.Errorf("proto: unexpected end of group")
  1215  )
  1216
View as plain text