Source file src/github.com/prometheus/alertmanager/silence/silencepb/silence.pb.go

Documentation: github.com/prometheus/alertmanager/silence/silencepb

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: silence.proto
     3  
     4  package silencepb
     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 specifies how the given name and pattern are matched
    32  // against a label set.
    33  type Matcher_Type int32
    34  
    35  const (
    36  	Matcher_EQUAL      Matcher_Type = 0
    37  	Matcher_REGEXP     Matcher_Type = 1
    38  	Matcher_NOT_EQUAL  Matcher_Type = 2
    39  	Matcher_NOT_REGEXP Matcher_Type = 3
    40  )
    41  
    42  var Matcher_Type_name = map[int32]string{
    43  	0: "EQUAL",
    44  	1: "REGEXP",
    45  	2: "NOT_EQUAL",
    46  	3: "NOT_REGEXP",
    47  }
    48  
    49  var Matcher_Type_value = map[string]int32{
    50  	"EQUAL":      0,
    51  	"REGEXP":     1,
    52  	"NOT_EQUAL":  2,
    53  	"NOT_REGEXP": 3,
    54  }
    55  
    56  func (x Matcher_Type) String() string {
    57  	return proto.EnumName(Matcher_Type_name, int32(x))
    58  }
    59  
    60  func (Matcher_Type) EnumDescriptor() ([]byte, []int) {
    61  	return fileDescriptor_7fc56058cf68dbd8, []int{0, 0}
    62  }
    63  
    64  // Matcher specifies a rule, which can match or set of labels or not.
    65  type Matcher struct {
    66  	Type Matcher_Type `protobuf:"varint,1,opt,name=type,proto3,enum=silencepb.Matcher_Type" json:"type,omitempty"`
    67  	// The label name in a label set to against which the matcher
    68  	// checks the pattern.
    69  	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
    70  	// The pattern being checked according to the matcher's type.
    71  	Pattern              string   `protobuf:"bytes,3,opt,name=pattern,proto3" json:"pattern,omitempty"`
    72  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
    73  	XXX_unrecognized     []byte   `json:"-"`
    74  	XXX_sizecache        int32    `json:"-"`
    75  }
    76  
    77  func (m *Matcher) Reset()         { *m = Matcher{} }
    78  func (m *Matcher) String() string { return proto.CompactTextString(m) }
    79  func (*Matcher) ProtoMessage()    {}
    80  func (*Matcher) Descriptor() ([]byte, []int) {
    81  	return fileDescriptor_7fc56058cf68dbd8, []int{0}
    82  }
    83  func (m *Matcher) XXX_Unmarshal(b []byte) error {
    84  	return m.Unmarshal(b)
    85  }
    86  func (m *Matcher) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    87  	if deterministic {
    88  		return xxx_messageInfo_Matcher.Marshal(b, m, deterministic)
    89  	} else {
    90  		b = b[:cap(b)]
    91  		n, err := m.MarshalToSizedBuffer(b)
    92  		if err != nil {
    93  			return nil, err
    94  		}
    95  		return b[:n], nil
    96  	}
    97  }
    98  func (m *Matcher) XXX_Merge(src proto.Message) {
    99  	xxx_messageInfo_Matcher.Merge(m, src)
   100  }
   101  func (m *Matcher) XXX_Size() int {
   102  	return m.Size()
   103  }
   104  func (m *Matcher) XXX_DiscardUnknown() {
   105  	xxx_messageInfo_Matcher.DiscardUnknown(m)
   106  }
   107  
   108  var xxx_messageInfo_Matcher proto.InternalMessageInfo
   109  
   110  // DEPRECATED: A comment can be attached to a silence.
   111  type Comment struct {
   112  	Author               string    `protobuf:"bytes,1,opt,name=author,proto3" json:"author,omitempty"`
   113  	Comment              string    `protobuf:"bytes,2,opt,name=comment,proto3" json:"comment,omitempty"`
   114  	Timestamp            time.Time `protobuf:"bytes,3,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
   115  	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
   116  	XXX_unrecognized     []byte    `json:"-"`
   117  	XXX_sizecache        int32     `json:"-"`
   118  }
   119  
   120  func (m *Comment) Reset()         { *m = Comment{} }
   121  func (m *Comment) String() string { return proto.CompactTextString(m) }
   122  func (*Comment) ProtoMessage()    {}
   123  func (*Comment) Descriptor() ([]byte, []int) {
   124  	return fileDescriptor_7fc56058cf68dbd8, []int{1}
   125  }
   126  func (m *Comment) XXX_Unmarshal(b []byte) error {
   127  	return m.Unmarshal(b)
   128  }
   129  func (m *Comment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   130  	if deterministic {
   131  		return xxx_messageInfo_Comment.Marshal(b, m, deterministic)
   132  	} else {
   133  		b = b[:cap(b)]
   134  		n, err := m.MarshalToSizedBuffer(b)
   135  		if err != nil {
   136  			return nil, err
   137  		}
   138  		return b[:n], nil
   139  	}
   140  }
   141  func (m *Comment) XXX_Merge(src proto.Message) {
   142  	xxx_messageInfo_Comment.Merge(m, src)
   143  }
   144  func (m *Comment) XXX_Size() int {
   145  	return m.Size()
   146  }
   147  func (m *Comment) XXX_DiscardUnknown() {
   148  	xxx_messageInfo_Comment.DiscardUnknown(m)
   149  }
   150  
   151  var xxx_messageInfo_Comment proto.InternalMessageInfo
   152  
   153  // Silence specifies an object that ignores alerts based
   154  // on a set of matchers during a given time frame.
   155  type Silence struct {
   156  	// A globally unique identifier.
   157  	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   158  	// A set of matchers all of which have to be true for a silence
   159  	// to affect a given label set.
   160  	Matchers []*Matcher `protobuf:"bytes,2,rep,name=matchers,proto3" json:"matchers,omitempty"`
   161  	// The time range during which the silence is active.
   162  	StartsAt time.Time `protobuf:"bytes,3,opt,name=starts_at,json=startsAt,proto3,stdtime" json:"starts_at"`
   163  	EndsAt   time.Time `protobuf:"bytes,4,opt,name=ends_at,json=endsAt,proto3,stdtime" json:"ends_at"`
   164  	// The last notification made to the silence.
   165  	UpdatedAt time.Time `protobuf:"bytes,5,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at"`
   166  	// DEPRECATED: A set of comments made on the silence.
   167  	Comments []*Comment `protobuf:"bytes,7,rep,name=comments,proto3" json:"comments,omitempty"`
   168  	// Comment for the silence.
   169  	CreatedBy            string   `protobuf:"bytes,8,opt,name=created_by,json=createdBy,proto3" json:"created_by,omitempty"`
   170  	Comment              string   `protobuf:"bytes,9,opt,name=comment,proto3" json:"comment,omitempty"`
   171  	XXX_NoUnkeyedLiteral struct{} `json:"-"`
   172  	XXX_unrecognized     []byte   `json:"-"`
   173  	XXX_sizecache        int32    `json:"-"`
   174  }
   175  
   176  func (m *Silence) Reset()         { *m = Silence{} }
   177  func (m *Silence) String() string { return proto.CompactTextString(m) }
   178  func (*Silence) ProtoMessage()    {}
   179  func (*Silence) Descriptor() ([]byte, []int) {
   180  	return fileDescriptor_7fc56058cf68dbd8, []int{2}
   181  }
   182  func (m *Silence) XXX_Unmarshal(b []byte) error {
   183  	return m.Unmarshal(b)
   184  }
   185  func (m *Silence) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   186  	if deterministic {
   187  		return xxx_messageInfo_Silence.Marshal(b, m, deterministic)
   188  	} else {
   189  		b = b[:cap(b)]
   190  		n, err := m.MarshalToSizedBuffer(b)
   191  		if err != nil {
   192  			return nil, err
   193  		}
   194  		return b[:n], nil
   195  	}
   196  }
   197  func (m *Silence) XXX_Merge(src proto.Message) {
   198  	xxx_messageInfo_Silence.Merge(m, src)
   199  }
   200  func (m *Silence) XXX_Size() int {
   201  	return m.Size()
   202  }
   203  func (m *Silence) XXX_DiscardUnknown() {
   204  	xxx_messageInfo_Silence.DiscardUnknown(m)
   205  }
   206  
   207  var xxx_messageInfo_Silence proto.InternalMessageInfo
   208  
   209  // MeshSilence wraps a regular silence with an expiration timestamp
   210  // after which the silence may be garbage collected.
   211  type MeshSilence struct {
   212  	Silence              *Silence  `protobuf:"bytes,1,opt,name=silence,proto3" json:"silence,omitempty"`
   213  	ExpiresAt            time.Time `protobuf:"bytes,2,opt,name=expires_at,json=expiresAt,proto3,stdtime" json:"expires_at"`
   214  	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
   215  	XXX_unrecognized     []byte    `json:"-"`
   216  	XXX_sizecache        int32     `json:"-"`
   217  }
   218  
   219  func (m *MeshSilence) Reset()         { *m = MeshSilence{} }
   220  func (m *MeshSilence) String() string { return proto.CompactTextString(m) }
   221  func (*MeshSilence) ProtoMessage()    {}
   222  func (*MeshSilence) Descriptor() ([]byte, []int) {
   223  	return fileDescriptor_7fc56058cf68dbd8, []int{3}
   224  }
   225  func (m *MeshSilence) XXX_Unmarshal(b []byte) error {
   226  	return m.Unmarshal(b)
   227  }
   228  func (m *MeshSilence) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   229  	if deterministic {
   230  		return xxx_messageInfo_MeshSilence.Marshal(b, m, deterministic)
   231  	} else {
   232  		b = b[:cap(b)]
   233  		n, err := m.MarshalToSizedBuffer(b)
   234  		if err != nil {
   235  			return nil, err
   236  		}
   237  		return b[:n], nil
   238  	}
   239  }
   240  func (m *MeshSilence) XXX_Merge(src proto.Message) {
   241  	xxx_messageInfo_MeshSilence.Merge(m, src)
   242  }
   243  func (m *MeshSilence) XXX_Size() int {
   244  	return m.Size()
   245  }
   246  func (m *MeshSilence) XXX_DiscardUnknown() {
   247  	xxx_messageInfo_MeshSilence.DiscardUnknown(m)
   248  }
   249  
   250  var xxx_messageInfo_MeshSilence proto.InternalMessageInfo
   251  
   252  func init() {
   253  	proto.RegisterEnum("silencepb.Matcher_Type", Matcher_Type_name, Matcher_Type_value)
   254  	proto.RegisterType((*Matcher)(nil), "silencepb.Matcher")
   255  	proto.RegisterType((*Comment)(nil), "silencepb.Comment")
   256  	proto.RegisterType((*Silence)(nil), "silencepb.Silence")
   257  	proto.RegisterType((*MeshSilence)(nil), "silencepb.MeshSilence")
   258  }
   259  
   260  func init() { proto.RegisterFile("silence.proto", fileDescriptor_7fc56058cf68dbd8) }
   261  
   262  var fileDescriptor_7fc56058cf68dbd8 = []byte{
   263  	// 461 bytes of a gzipped FileDescriptorProto
   264  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x91, 0xcd, 0x8e, 0xd2, 0x50,
   265  	0x14, 0xc7, 0xb9, 0x85, 0xa1, 0xdc, 0x43, 0x86, 0x90, 0x13, 0xa3, 0x0d, 0x89, 0x40, 0xba, 0x22,
   266  	0xd1, 0x94, 0x04, 0xb7, 0xba, 0x28, 0x13, 0xe2, 0xc6, 0xf1, 0xa3, 0x62, 0xe2, 0x6e, 0x52, 0xe8,
   267  	0x11, 0x9a, 0x4c, 0x3f, 0xd2, 0x1e, 0x12, 0x59, 0xe9, 0x23, 0xf8, 0x0c, 0x3e, 0x0d, 0x4b, 0x9f,
   268  	0xc0, 0x0f, 0xde, 0xc2, 0x9d, 0xe9, 0xed, 0x2d, 0xce, 0x84, 0x55, 0x77, 0xf7, 0xdc, 0xf3, 0xff,
   269  	0x9f, 0x8f, 0xdf, 0x81, 0xcb, 0x3c, 0xbc, 0xa5, 0x78, 0x4d, 0x4e, 0x9a, 0x25, 0x9c, 0xa0, 0xd4,
   270  	0x61, 0xba, 0x1a, 0x8c, 0x36, 0x49, 0xb2, 0xb9, 0xa5, 0xa9, 0x4a, 0xac, 0x76, 0x9f, 0xa6, 0x1c,
   271  	0x46, 0x94, 0xb3, 0x1f, 0xa5, 0xa5, 0x76, 0xf0, 0x60, 0x93, 0x6c, 0x12, 0xf5, 0x9c, 0x16, 0xaf,
   272  	0xf2, 0xd7, 0xfe, 0x2e, 0xc0, 0xbc, 0xf6, 0x79, 0xbd, 0xa5, 0x0c, 0x9f, 0x40, 0x8b, 0xf7, 0x29,
   273  	0x59, 0x62, 0x2c, 0x26, 0xbd, 0xd9, 0x23, 0xe7, 0x54, 0xdc, 0xd1, 0x0a, 0x67, 0xb9, 0x4f, 0xc9,
   274  	0x53, 0x22, 0x44, 0x68, 0xc5, 0x7e, 0x44, 0x96, 0x31, 0x16, 0x13, 0xe9, 0xa9, 0x37, 0x5a, 0x60,
   275  	0xa6, 0x3e, 0x33, 0x65, 0xb1, 0xd5, 0x54, 0xdf, 0x55, 0x68, 0x3f, 0x87, 0x56, 0xe1, 0x45, 0x09,
   276  	0x17, 0x8b, 0x77, 0x1f, 0xdc, 0x57, 0xfd, 0x06, 0x02, 0xb4, 0xbd, 0xc5, 0xcb, 0xc5, 0xc7, 0xb7,
   277  	0x7d, 0x81, 0x97, 0x20, 0x5f, 0xbf, 0x59, 0xde, 0x94, 0x29, 0x03, 0x7b, 0x00, 0x45, 0xa8, 0xd3,
   278  	0x4d, 0xfb, 0x0b, 0x98, 0x57, 0x49, 0x14, 0x51, 0xcc, 0xf8, 0x10, 0xda, 0xfe, 0x8e, 0xb7, 0x49,
   279  	0xa6, 0xa6, 0x94, 0x9e, 0x8e, 0x8a, 0xd6, 0xeb, 0x52, 0xa2, 0x27, 0xaa, 0x42, 0x9c, 0x83, 0x3c,
   280  	0xa1, 0x50, 0x63, 0x75, 0x67, 0x03, 0xa7, 0x84, 0xe5, 0x54, 0xb0, 0x9c, 0x65, 0xa5, 0x98, 0x77,
   281  	0x0e, 0x3f, 0x47, 0x8d, 0x6f, 0xbf, 0x46, 0xc2, 0xfb, 0x6f, 0xb3, 0xff, 0x1a, 0x60, 0xbe, 0x2f,
   282  	0x69, 0x60, 0x0f, 0x8c, 0x30, 0xd0, 0xdd, 0x8d, 0x30, 0x40, 0x07, 0x3a, 0x51, 0x89, 0x27, 0xb7,
   283  	0x8c, 0x71, 0x73, 0xd2, 0x9d, 0xe1, 0x39, 0x39, 0xef, 0xa4, 0x41, 0x17, 0x64, 0xce, 0x7e, 0xc6,
   284  	0xf9, 0x8d, 0xcf, 0xb5, 0xe6, 0xe9, 0x94, 0x36, 0x97, 0xf1, 0x05, 0x98, 0x14, 0x07, 0xaa, 0x40,
   285  	0xab, 0x46, 0x81, 0x76, 0x61, 0x72, 0x19, 0xaf, 0x00, 0x76, 0x69, 0xe0, 0x33, 0x05, 0x45, 0x85,
   286  	0x8b, 0x3a, 0x48, 0xb4, 0xcf, 0xe5, 0x62, 0x6d, 0x4d, 0x38, 0xb7, 0xcc, 0xb3, 0xb5, 0xf5, 0xb9,
   287  	0xbc, 0x93, 0x06, 0x1f, 0x03, 0xac, 0x33, 0x52, 0x4d, 0x57, 0x7b, 0xab, 0xa3, 0xf0, 0x49, 0xfd,
   288  	0x33, 0xdf, 0xdf, 0xbd, 0x9f, 0xbc, 0x77, 0x3f, 0xfb, 0xab, 0x80, 0xee, 0x35, 0xe5, 0xdb, 0x8a,
   289  	0xff, 0x53, 0x30, 0x75, 0x1f, 0x75, 0x84, 0xfb, 0x7d, 0xb5, 0xc8, 0xab, 0x24, 0xc5, 0xae, 0xf4,
   290  	0x39, 0x0d, 0x33, 0x52, 0xb4, 0x8c, 0x3a, 0xbb, 0x6a, 0x9f, 0xcb, 0xf3, 0xfe, 0xe1, 0xcf, 0xb0,
   291  	0x71, 0x38, 0x0e, 0xc5, 0x8f, 0xe3, 0x50, 0xfc, 0x3e, 0x0e, 0xc5, 0xaa, 0xad, 0xac, 0xcf, 0xfe,
   292  	0x05, 0x00, 0x00, 0xff, 0xff, 0xad, 0x09, 0x3a, 0xe9, 0x90, 0x03, 0x00, 0x00,
   293  }
   294  
   295  func (m *Matcher) Marshal() (dAtA []byte, err error) {
   296  	size := m.Size()
   297  	dAtA = make([]byte, size)
   298  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   299  	if err != nil {
   300  		return nil, err
   301  	}
   302  	return dAtA[:n], nil
   303  }
   304  
   305  func (m *Matcher) MarshalTo(dAtA []byte) (int, error) {
   306  	size := m.Size()
   307  	return m.MarshalToSizedBuffer(dAtA[:size])
   308  }
   309  
   310  func (m *Matcher) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   311  	i := len(dAtA)
   312  	_ = i
   313  	var l int
   314  	_ = l
   315  	if m.XXX_unrecognized != nil {
   316  		i -= len(m.XXX_unrecognized)
   317  		copy(dAtA[i:], m.XXX_unrecognized)
   318  	}
   319  	if len(m.Pattern) > 0 {
   320  		i -= len(m.Pattern)
   321  		copy(dAtA[i:], m.Pattern)
   322  		i = encodeVarintSilence(dAtA, i, uint64(len(m.Pattern)))
   323  		i--
   324  		dAtA[i] = 0x1a
   325  	}
   326  	if len(m.Name) > 0 {
   327  		i -= len(m.Name)
   328  		copy(dAtA[i:], m.Name)
   329  		i = encodeVarintSilence(dAtA, i, uint64(len(m.Name)))
   330  		i--
   331  		dAtA[i] = 0x12
   332  	}
   333  	if m.Type != 0 {
   334  		i = encodeVarintSilence(dAtA, i, uint64(m.Type))
   335  		i--
   336  		dAtA[i] = 0x8
   337  	}
   338  	return len(dAtA) - i, nil
   339  }
   340  
   341  func (m *Comment) Marshal() (dAtA []byte, err error) {
   342  	size := m.Size()
   343  	dAtA = make([]byte, size)
   344  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   345  	if err != nil {
   346  		return nil, err
   347  	}
   348  	return dAtA[:n], nil
   349  }
   350  
   351  func (m *Comment) MarshalTo(dAtA []byte) (int, error) {
   352  	size := m.Size()
   353  	return m.MarshalToSizedBuffer(dAtA[:size])
   354  }
   355  
   356  func (m *Comment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   357  	i := len(dAtA)
   358  	_ = i
   359  	var l int
   360  	_ = l
   361  	if m.XXX_unrecognized != nil {
   362  		i -= len(m.XXX_unrecognized)
   363  		copy(dAtA[i:], m.XXX_unrecognized)
   364  	}
   365  	n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
   366  	if err1 != nil {
   367  		return 0, err1
   368  	}
   369  	i -= n1
   370  	i = encodeVarintSilence(dAtA, i, uint64(n1))
   371  	i--
   372  	dAtA[i] = 0x1a
   373  	if len(m.Comment) > 0 {
   374  		i -= len(m.Comment)
   375  		copy(dAtA[i:], m.Comment)
   376  		i = encodeVarintSilence(dAtA, i, uint64(len(m.Comment)))
   377  		i--
   378  		dAtA[i] = 0x12
   379  	}
   380  	if len(m.Author) > 0 {
   381  		i -= len(m.Author)
   382  		copy(dAtA[i:], m.Author)
   383  		i = encodeVarintSilence(dAtA, i, uint64(len(m.Author)))
   384  		i--
   385  		dAtA[i] = 0xa
   386  	}
   387  	return len(dAtA) - i, nil
   388  }
   389  
   390  func (m *Silence) Marshal() (dAtA []byte, err error) {
   391  	size := m.Size()
   392  	dAtA = make([]byte, size)
   393  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   394  	if err != nil {
   395  		return nil, err
   396  	}
   397  	return dAtA[:n], nil
   398  }
   399  
   400  func (m *Silence) MarshalTo(dAtA []byte) (int, error) {
   401  	size := m.Size()
   402  	return m.MarshalToSizedBuffer(dAtA[:size])
   403  }
   404  
   405  func (m *Silence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   406  	i := len(dAtA)
   407  	_ = i
   408  	var l int
   409  	_ = l
   410  	if m.XXX_unrecognized != nil {
   411  		i -= len(m.XXX_unrecognized)
   412  		copy(dAtA[i:], m.XXX_unrecognized)
   413  	}
   414  	if len(m.Comment) > 0 {
   415  		i -= len(m.Comment)
   416  		copy(dAtA[i:], m.Comment)
   417  		i = encodeVarintSilence(dAtA, i, uint64(len(m.Comment)))
   418  		i--
   419  		dAtA[i] = 0x4a
   420  	}
   421  	if len(m.CreatedBy) > 0 {
   422  		i -= len(m.CreatedBy)
   423  		copy(dAtA[i:], m.CreatedBy)
   424  		i = encodeVarintSilence(dAtA, i, uint64(len(m.CreatedBy)))
   425  		i--
   426  		dAtA[i] = 0x42
   427  	}
   428  	if len(m.Comments) > 0 {
   429  		for iNdEx := len(m.Comments) - 1; iNdEx >= 0; iNdEx-- {
   430  			{
   431  				size, err := m.Comments[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   432  				if err != nil {
   433  					return 0, err
   434  				}
   435  				i -= size
   436  				i = encodeVarintSilence(dAtA, i, uint64(size))
   437  			}
   438  			i--
   439  			dAtA[i] = 0x3a
   440  		}
   441  	}
   442  	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt):])
   443  	if err2 != nil {
   444  		return 0, err2
   445  	}
   446  	i -= n2
   447  	i = encodeVarintSilence(dAtA, i, uint64(n2))
   448  	i--
   449  	dAtA[i] = 0x2a
   450  	n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndsAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndsAt):])
   451  	if err3 != nil {
   452  		return 0, err3
   453  	}
   454  	i -= n3
   455  	i = encodeVarintSilence(dAtA, i, uint64(n3))
   456  	i--
   457  	dAtA[i] = 0x22
   458  	n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartsAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartsAt):])
   459  	if err4 != nil {
   460  		return 0, err4
   461  	}
   462  	i -= n4
   463  	i = encodeVarintSilence(dAtA, i, uint64(n4))
   464  	i--
   465  	dAtA[i] = 0x1a
   466  	if len(m.Matchers) > 0 {
   467  		for iNdEx := len(m.Matchers) - 1; iNdEx >= 0; iNdEx-- {
   468  			{
   469  				size, err := m.Matchers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   470  				if err != nil {
   471  					return 0, err
   472  				}
   473  				i -= size
   474  				i = encodeVarintSilence(dAtA, i, uint64(size))
   475  			}
   476  			i--
   477  			dAtA[i] = 0x12
   478  		}
   479  	}
   480  	if len(m.Id) > 0 {
   481  		i -= len(m.Id)
   482  		copy(dAtA[i:], m.Id)
   483  		i = encodeVarintSilence(dAtA, i, uint64(len(m.Id)))
   484  		i--
   485  		dAtA[i] = 0xa
   486  	}
   487  	return len(dAtA) - i, nil
   488  }
   489  
   490  func (m *MeshSilence) Marshal() (dAtA []byte, err error) {
   491  	size := m.Size()
   492  	dAtA = make([]byte, size)
   493  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   494  	if err != nil {
   495  		return nil, err
   496  	}
   497  	return dAtA[:n], nil
   498  }
   499  
   500  func (m *MeshSilence) MarshalTo(dAtA []byte) (int, error) {
   501  	size := m.Size()
   502  	return m.MarshalToSizedBuffer(dAtA[:size])
   503  }
   504  
   505  func (m *MeshSilence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   506  	i := len(dAtA)
   507  	_ = i
   508  	var l int
   509  	_ = l
   510  	if m.XXX_unrecognized != nil {
   511  		i -= len(m.XXX_unrecognized)
   512  		copy(dAtA[i:], m.XXX_unrecognized)
   513  	}
   514  	n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ExpiresAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ExpiresAt):])
   515  	if err5 != nil {
   516  		return 0, err5
   517  	}
   518  	i -= n5
   519  	i = encodeVarintSilence(dAtA, i, uint64(n5))
   520  	i--
   521  	dAtA[i] = 0x12
   522  	if m.Silence != nil {
   523  		{
   524  			size, err := m.Silence.MarshalToSizedBuffer(dAtA[:i])
   525  			if err != nil {
   526  				return 0, err
   527  			}
   528  			i -= size
   529  			i = encodeVarintSilence(dAtA, i, uint64(size))
   530  		}
   531  		i--
   532  		dAtA[i] = 0xa
   533  	}
   534  	return len(dAtA) - i, nil
   535  }
   536  
   537  func encodeVarintSilence(dAtA []byte, offset int, v uint64) int {
   538  	offset -= sovSilence(v)
   539  	base := offset
   540  	for v >= 1<<7 {
   541  		dAtA[offset] = uint8(v&0x7f | 0x80)
   542  		v >>= 7
   543  		offset++
   544  	}
   545  	dAtA[offset] = uint8(v)
   546  	return base
   547  }
   548  func (m *Matcher) Size() (n int) {
   549  	if m == nil {
   550  		return 0
   551  	}
   552  	var l int
   553  	_ = l
   554  	if m.Type != 0 {
   555  		n += 1 + sovSilence(uint64(m.Type))
   556  	}
   557  	l = len(m.Name)
   558  	if l > 0 {
   559  		n += 1 + l + sovSilence(uint64(l))
   560  	}
   561  	l = len(m.Pattern)
   562  	if l > 0 {
   563  		n += 1 + l + sovSilence(uint64(l))
   564  	}
   565  	if m.XXX_unrecognized != nil {
   566  		n += len(m.XXX_unrecognized)
   567  	}
   568  	return n
   569  }
   570  
   571  func (m *Comment) Size() (n int) {
   572  	if m == nil {
   573  		return 0
   574  	}
   575  	var l int
   576  	_ = l
   577  	l = len(m.Author)
   578  	if l > 0 {
   579  		n += 1 + l + sovSilence(uint64(l))
   580  	}
   581  	l = len(m.Comment)
   582  	if l > 0 {
   583  		n += 1 + l + sovSilence(uint64(l))
   584  	}
   585  	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
   586  	n += 1 + l + sovSilence(uint64(l))
   587  	if m.XXX_unrecognized != nil {
   588  		n += len(m.XXX_unrecognized)
   589  	}
   590  	return n
   591  }
   592  
   593  func (m *Silence) Size() (n int) {
   594  	if m == nil {
   595  		return 0
   596  	}
   597  	var l int
   598  	_ = l
   599  	l = len(m.Id)
   600  	if l > 0 {
   601  		n += 1 + l + sovSilence(uint64(l))
   602  	}
   603  	if len(m.Matchers) > 0 {
   604  		for _, e := range m.Matchers {
   605  			l = e.Size()
   606  			n += 1 + l + sovSilence(uint64(l))
   607  		}
   608  	}
   609  	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartsAt)
   610  	n += 1 + l + sovSilence(uint64(l))
   611  	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndsAt)
   612  	n += 1 + l + sovSilence(uint64(l))
   613  	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)
   614  	n += 1 + l + sovSilence(uint64(l))
   615  	if len(m.Comments) > 0 {
   616  		for _, e := range m.Comments {
   617  			l = e.Size()
   618  			n += 1 + l + sovSilence(uint64(l))
   619  		}
   620  	}
   621  	l = len(m.CreatedBy)
   622  	if l > 0 {
   623  		n += 1 + l + sovSilence(uint64(l))
   624  	}
   625  	l = len(m.Comment)
   626  	if l > 0 {
   627  		n += 1 + l + sovSilence(uint64(l))
   628  	}
   629  	if m.XXX_unrecognized != nil {
   630  		n += len(m.XXX_unrecognized)
   631  	}
   632  	return n
   633  }
   634  
   635  func (m *MeshSilence) Size() (n int) {
   636  	if m == nil {
   637  		return 0
   638  	}
   639  	var l int
   640  	_ = l
   641  	if m.Silence != nil {
   642  		l = m.Silence.Size()
   643  		n += 1 + l + sovSilence(uint64(l))
   644  	}
   645  	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ExpiresAt)
   646  	n += 1 + l + sovSilence(uint64(l))
   647  	if m.XXX_unrecognized != nil {
   648  		n += len(m.XXX_unrecognized)
   649  	}
   650  	return n
   651  }
   652  
   653  func sovSilence(x uint64) (n int) {
   654  	return (math_bits.Len64(x|1) + 6) / 7
   655  }
   656  func sozSilence(x uint64) (n int) {
   657  	return sovSilence(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   658  }
   659  func (m *Matcher) Unmarshal(dAtA []byte) error {
   660  	l := len(dAtA)
   661  	iNdEx := 0
   662  	for iNdEx < l {
   663  		preIndex := iNdEx
   664  		var wire uint64
   665  		for shift := uint(0); ; shift += 7 {
   666  			if shift >= 64 {
   667  				return ErrIntOverflowSilence
   668  			}
   669  			if iNdEx >= l {
   670  				return io.ErrUnexpectedEOF
   671  			}
   672  			b := dAtA[iNdEx]
   673  			iNdEx++
   674  			wire |= uint64(b&0x7F) << shift
   675  			if b < 0x80 {
   676  				break
   677  			}
   678  		}
   679  		fieldNum := int32(wire >> 3)
   680  		wireType := int(wire & 0x7)
   681  		if wireType == 4 {
   682  			return fmt.Errorf("proto: Matcher: wiretype end group for non-group")
   683  		}
   684  		if fieldNum <= 0 {
   685  			return fmt.Errorf("proto: Matcher: illegal tag %d (wire type %d)", fieldNum, wire)
   686  		}
   687  		switch fieldNum {
   688  		case 1:
   689  			if wireType != 0 {
   690  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
   691  			}
   692  			m.Type = 0
   693  			for shift := uint(0); ; shift += 7 {
   694  				if shift >= 64 {
   695  					return ErrIntOverflowSilence
   696  				}
   697  				if iNdEx >= l {
   698  					return io.ErrUnexpectedEOF
   699  				}
   700  				b := dAtA[iNdEx]
   701  				iNdEx++
   702  				m.Type |= Matcher_Type(b&0x7F) << shift
   703  				if b < 0x80 {
   704  					break
   705  				}
   706  			}
   707  		case 2:
   708  			if wireType != 2 {
   709  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
   710  			}
   711  			var stringLen uint64
   712  			for shift := uint(0); ; shift += 7 {
   713  				if shift >= 64 {
   714  					return ErrIntOverflowSilence
   715  				}
   716  				if iNdEx >= l {
   717  					return io.ErrUnexpectedEOF
   718  				}
   719  				b := dAtA[iNdEx]
   720  				iNdEx++
   721  				stringLen |= uint64(b&0x7F) << shift
   722  				if b < 0x80 {
   723  					break
   724  				}
   725  			}
   726  			intStringLen := int(stringLen)
   727  			if intStringLen < 0 {
   728  				return ErrInvalidLengthSilence
   729  			}
   730  			postIndex := iNdEx + intStringLen
   731  			if postIndex < 0 {
   732  				return ErrInvalidLengthSilence
   733  			}
   734  			if postIndex > l {
   735  				return io.ErrUnexpectedEOF
   736  			}
   737  			m.Name = string(dAtA[iNdEx:postIndex])
   738  			iNdEx = postIndex
   739  		case 3:
   740  			if wireType != 2 {
   741  				return fmt.Errorf("proto: wrong wireType = %d for field Pattern", wireType)
   742  			}
   743  			var stringLen uint64
   744  			for shift := uint(0); ; shift += 7 {
   745  				if shift >= 64 {
   746  					return ErrIntOverflowSilence
   747  				}
   748  				if iNdEx >= l {
   749  					return io.ErrUnexpectedEOF
   750  				}
   751  				b := dAtA[iNdEx]
   752  				iNdEx++
   753  				stringLen |= uint64(b&0x7F) << shift
   754  				if b < 0x80 {
   755  					break
   756  				}
   757  			}
   758  			intStringLen := int(stringLen)
   759  			if intStringLen < 0 {
   760  				return ErrInvalidLengthSilence
   761  			}
   762  			postIndex := iNdEx + intStringLen
   763  			if postIndex < 0 {
   764  				return ErrInvalidLengthSilence
   765  			}
   766  			if postIndex > l {
   767  				return io.ErrUnexpectedEOF
   768  			}
   769  			m.Pattern = string(dAtA[iNdEx:postIndex])
   770  			iNdEx = postIndex
   771  		default:
   772  			iNdEx = preIndex
   773  			skippy, err := skipSilence(dAtA[iNdEx:])
   774  			if err != nil {
   775  				return err
   776  			}
   777  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   778  				return ErrInvalidLengthSilence
   779  			}
   780  			if (iNdEx + skippy) > l {
   781  				return io.ErrUnexpectedEOF
   782  			}
   783  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
   784  			iNdEx += skippy
   785  		}
   786  	}
   787  
   788  	if iNdEx > l {
   789  		return io.ErrUnexpectedEOF
   790  	}
   791  	return nil
   792  }
   793  func (m *Comment) Unmarshal(dAtA []byte) error {
   794  	l := len(dAtA)
   795  	iNdEx := 0
   796  	for iNdEx < l {
   797  		preIndex := iNdEx
   798  		var wire uint64
   799  		for shift := uint(0); ; shift += 7 {
   800  			if shift >= 64 {
   801  				return ErrIntOverflowSilence
   802  			}
   803  			if iNdEx >= l {
   804  				return io.ErrUnexpectedEOF
   805  			}
   806  			b := dAtA[iNdEx]
   807  			iNdEx++
   808  			wire |= uint64(b&0x7F) << shift
   809  			if b < 0x80 {
   810  				break
   811  			}
   812  		}
   813  		fieldNum := int32(wire >> 3)
   814  		wireType := int(wire & 0x7)
   815  		if wireType == 4 {
   816  			return fmt.Errorf("proto: Comment: wiretype end group for non-group")
   817  		}
   818  		if fieldNum <= 0 {
   819  			return fmt.Errorf("proto: Comment: illegal tag %d (wire type %d)", fieldNum, wire)
   820  		}
   821  		switch fieldNum {
   822  		case 1:
   823  			if wireType != 2 {
   824  				return fmt.Errorf("proto: wrong wireType = %d for field Author", wireType)
   825  			}
   826  			var stringLen uint64
   827  			for shift := uint(0); ; shift += 7 {
   828  				if shift >= 64 {
   829  					return ErrIntOverflowSilence
   830  				}
   831  				if iNdEx >= l {
   832  					return io.ErrUnexpectedEOF
   833  				}
   834  				b := dAtA[iNdEx]
   835  				iNdEx++
   836  				stringLen |= uint64(b&0x7F) << shift
   837  				if b < 0x80 {
   838  					break
   839  				}
   840  			}
   841  			intStringLen := int(stringLen)
   842  			if intStringLen < 0 {
   843  				return ErrInvalidLengthSilence
   844  			}
   845  			postIndex := iNdEx + intStringLen
   846  			if postIndex < 0 {
   847  				return ErrInvalidLengthSilence
   848  			}
   849  			if postIndex > l {
   850  				return io.ErrUnexpectedEOF
   851  			}
   852  			m.Author = string(dAtA[iNdEx:postIndex])
   853  			iNdEx = postIndex
   854  		case 2:
   855  			if wireType != 2 {
   856  				return fmt.Errorf("proto: wrong wireType = %d for field Comment", wireType)
   857  			}
   858  			var stringLen uint64
   859  			for shift := uint(0); ; shift += 7 {
   860  				if shift >= 64 {
   861  					return ErrIntOverflowSilence
   862  				}
   863  				if iNdEx >= l {
   864  					return io.ErrUnexpectedEOF
   865  				}
   866  				b := dAtA[iNdEx]
   867  				iNdEx++
   868  				stringLen |= uint64(b&0x7F) << shift
   869  				if b < 0x80 {
   870  					break
   871  				}
   872  			}
   873  			intStringLen := int(stringLen)
   874  			if intStringLen < 0 {
   875  				return ErrInvalidLengthSilence
   876  			}
   877  			postIndex := iNdEx + intStringLen
   878  			if postIndex < 0 {
   879  				return ErrInvalidLengthSilence
   880  			}
   881  			if postIndex > l {
   882  				return io.ErrUnexpectedEOF
   883  			}
   884  			m.Comment = string(dAtA[iNdEx:postIndex])
   885  			iNdEx = postIndex
   886  		case 3:
   887  			if wireType != 2 {
   888  				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
   889  			}
   890  			var msglen int
   891  			for shift := uint(0); ; shift += 7 {
   892  				if shift >= 64 {
   893  					return ErrIntOverflowSilence
   894  				}
   895  				if iNdEx >= l {
   896  					return io.ErrUnexpectedEOF
   897  				}
   898  				b := dAtA[iNdEx]
   899  				iNdEx++
   900  				msglen |= int(b&0x7F) << shift
   901  				if b < 0x80 {
   902  					break
   903  				}
   904  			}
   905  			if msglen < 0 {
   906  				return ErrInvalidLengthSilence
   907  			}
   908  			postIndex := iNdEx + msglen
   909  			if postIndex < 0 {
   910  				return ErrInvalidLengthSilence
   911  			}
   912  			if postIndex > l {
   913  				return io.ErrUnexpectedEOF
   914  			}
   915  			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
   916  				return err
   917  			}
   918  			iNdEx = postIndex
   919  		default:
   920  			iNdEx = preIndex
   921  			skippy, err := skipSilence(dAtA[iNdEx:])
   922  			if err != nil {
   923  				return err
   924  			}
   925  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   926  				return ErrInvalidLengthSilence
   927  			}
   928  			if (iNdEx + skippy) > l {
   929  				return io.ErrUnexpectedEOF
   930  			}
   931  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
   932  			iNdEx += skippy
   933  		}
   934  	}
   935  
   936  	if iNdEx > l {
   937  		return io.ErrUnexpectedEOF
   938  	}
   939  	return nil
   940  }
   941  func (m *Silence) Unmarshal(dAtA []byte) error {
   942  	l := len(dAtA)
   943  	iNdEx := 0
   944  	for iNdEx < l {
   945  		preIndex := iNdEx
   946  		var wire uint64
   947  		for shift := uint(0); ; shift += 7 {
   948  			if shift >= 64 {
   949  				return ErrIntOverflowSilence
   950  			}
   951  			if iNdEx >= l {
   952  				return io.ErrUnexpectedEOF
   953  			}
   954  			b := dAtA[iNdEx]
   955  			iNdEx++
   956  			wire |= uint64(b&0x7F) << shift
   957  			if b < 0x80 {
   958  				break
   959  			}
   960  		}
   961  		fieldNum := int32(wire >> 3)
   962  		wireType := int(wire & 0x7)
   963  		if wireType == 4 {
   964  			return fmt.Errorf("proto: Silence: wiretype end group for non-group")
   965  		}
   966  		if fieldNum <= 0 {
   967  			return fmt.Errorf("proto: Silence: illegal tag %d (wire type %d)", fieldNum, wire)
   968  		}
   969  		switch fieldNum {
   970  		case 1:
   971  			if wireType != 2 {
   972  				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
   973  			}
   974  			var stringLen uint64
   975  			for shift := uint(0); ; shift += 7 {
   976  				if shift >= 64 {
   977  					return ErrIntOverflowSilence
   978  				}
   979  				if iNdEx >= l {
   980  					return io.ErrUnexpectedEOF
   981  				}
   982  				b := dAtA[iNdEx]
   983  				iNdEx++
   984  				stringLen |= uint64(b&0x7F) << shift
   985  				if b < 0x80 {
   986  					break
   987  				}
   988  			}
   989  			intStringLen := int(stringLen)
   990  			if intStringLen < 0 {
   991  				return ErrInvalidLengthSilence
   992  			}
   993  			postIndex := iNdEx + intStringLen
   994  			if postIndex < 0 {
   995  				return ErrInvalidLengthSilence
   996  			}
   997  			if postIndex > l {
   998  				return io.ErrUnexpectedEOF
   999  			}
  1000  			m.Id = string(dAtA[iNdEx:postIndex])
  1001  			iNdEx = postIndex
  1002  		case 2:
  1003  			if wireType != 2 {
  1004  				return fmt.Errorf("proto: wrong wireType = %d for field Matchers", wireType)
  1005  			}
  1006  			var msglen int
  1007  			for shift := uint(0); ; shift += 7 {
  1008  				if shift >= 64 {
  1009  					return ErrIntOverflowSilence
  1010  				}
  1011  				if iNdEx >= l {
  1012  					return io.ErrUnexpectedEOF
  1013  				}
  1014  				b := dAtA[iNdEx]
  1015  				iNdEx++
  1016  				msglen |= int(b&0x7F) << shift
  1017  				if b < 0x80 {
  1018  					break
  1019  				}
  1020  			}
  1021  			if msglen < 0 {
  1022  				return ErrInvalidLengthSilence
  1023  			}
  1024  			postIndex := iNdEx + msglen
  1025  			if postIndex < 0 {
  1026  				return ErrInvalidLengthSilence
  1027  			}
  1028  			if postIndex > l {
  1029  				return io.ErrUnexpectedEOF
  1030  			}
  1031  			m.Matchers = append(m.Matchers, &Matcher{})
  1032  			if err := m.Matchers[len(m.Matchers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1033  				return err
  1034  			}
  1035  			iNdEx = postIndex
  1036  		case 3:
  1037  			if wireType != 2 {
  1038  				return fmt.Errorf("proto: wrong wireType = %d for field StartsAt", wireType)
  1039  			}
  1040  			var msglen int
  1041  			for shift := uint(0); ; shift += 7 {
  1042  				if shift >= 64 {
  1043  					return ErrIntOverflowSilence
  1044  				}
  1045  				if iNdEx >= l {
  1046  					return io.ErrUnexpectedEOF
  1047  				}
  1048  				b := dAtA[iNdEx]
  1049  				iNdEx++
  1050  				msglen |= int(b&0x7F) << shift
  1051  				if b < 0x80 {
  1052  					break
  1053  				}
  1054  			}
  1055  			if msglen < 0 {
  1056  				return ErrInvalidLengthSilence
  1057  			}
  1058  			postIndex := iNdEx + msglen
  1059  			if postIndex < 0 {
  1060  				return ErrInvalidLengthSilence
  1061  			}
  1062  			if postIndex > l {
  1063  				return io.ErrUnexpectedEOF
  1064  			}
  1065  			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartsAt, dAtA[iNdEx:postIndex]); err != nil {
  1066  				return err
  1067  			}
  1068  			iNdEx = postIndex
  1069  		case 4:
  1070  			if wireType != 2 {
  1071  				return fmt.Errorf("proto: wrong wireType = %d for field EndsAt", wireType)
  1072  			}
  1073  			var msglen int
  1074  			for shift := uint(0); ; shift += 7 {
  1075  				if shift >= 64 {
  1076  					return ErrIntOverflowSilence
  1077  				}
  1078  				if iNdEx >= l {
  1079  					return io.ErrUnexpectedEOF
  1080  				}
  1081  				b := dAtA[iNdEx]
  1082  				iNdEx++
  1083  				msglen |= int(b&0x7F) << shift
  1084  				if b < 0x80 {
  1085  					break
  1086  				}
  1087  			}
  1088  			if msglen < 0 {
  1089  				return ErrInvalidLengthSilence
  1090  			}
  1091  			postIndex := iNdEx + msglen
  1092  			if postIndex < 0 {
  1093  				return ErrInvalidLengthSilence
  1094  			}
  1095  			if postIndex > l {
  1096  				return io.ErrUnexpectedEOF
  1097  			}
  1098  			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndsAt, dAtA[iNdEx:postIndex]); err != nil {
  1099  				return err
  1100  			}
  1101  			iNdEx = postIndex
  1102  		case 5:
  1103  			if wireType != 2 {
  1104  				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
  1105  			}
  1106  			var msglen int
  1107  			for shift := uint(0); ; shift += 7 {
  1108  				if shift >= 64 {
  1109  					return ErrIntOverflowSilence
  1110  				}
  1111  				if iNdEx >= l {
  1112  					return io.ErrUnexpectedEOF
  1113  				}
  1114  				b := dAtA[iNdEx]
  1115  				iNdEx++
  1116  				msglen |= int(b&0x7F) << shift
  1117  				if b < 0x80 {
  1118  					break
  1119  				}
  1120  			}
  1121  			if msglen < 0 {
  1122  				return ErrInvalidLengthSilence
  1123  			}
  1124  			postIndex := iNdEx + msglen
  1125  			if postIndex < 0 {
  1126  				return ErrInvalidLengthSilence
  1127  			}
  1128  			if postIndex > l {
  1129  				return io.ErrUnexpectedEOF
  1130  			}
  1131  			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil {
  1132  				return err
  1133  			}
  1134  			iNdEx = postIndex
  1135  		case 7:
  1136  			if wireType != 2 {
  1137  				return fmt.Errorf("proto: wrong wireType = %d for field Comments", wireType)
  1138  			}
  1139  			var msglen int
  1140  			for shift := uint(0); ; shift += 7 {
  1141  				if shift >= 64 {
  1142  					return ErrIntOverflowSilence
  1143  				}
  1144  				if iNdEx >= l {
  1145  					return io.ErrUnexpectedEOF
  1146  				}
  1147  				b := dAtA[iNdEx]
  1148  				iNdEx++
  1149  				msglen |= int(b&0x7F) << shift
  1150  				if b < 0x80 {
  1151  					break
  1152  				}
  1153  			}
  1154  			if msglen < 0 {
  1155  				return ErrInvalidLengthSilence
  1156  			}
  1157  			postIndex := iNdEx + msglen
  1158  			if postIndex < 0 {
  1159  				return ErrInvalidLengthSilence
  1160  			}
  1161  			if postIndex > l {
  1162  				return io.ErrUnexpectedEOF
  1163  			}
  1164  			m.Comments = append(m.Comments, &Comment{})
  1165  			if err := m.Comments[len(m.Comments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1166  				return err
  1167  			}
  1168  			iNdEx = postIndex
  1169  		case 8:
  1170  			if wireType != 2 {
  1171  				return fmt.Errorf("proto: wrong wireType = %d for field CreatedBy", wireType)
  1172  			}
  1173  			var stringLen uint64
  1174  			for shift := uint(0); ; shift += 7 {
  1175  				if shift >= 64 {
  1176  					return ErrIntOverflowSilence
  1177  				}
  1178  				if iNdEx >= l {
  1179  					return io.ErrUnexpectedEOF
  1180  				}
  1181  				b := dAtA[iNdEx]
  1182  				iNdEx++
  1183  				stringLen |= uint64(b&0x7F) << shift
  1184  				if b < 0x80 {
  1185  					break
  1186  				}
  1187  			}
  1188  			intStringLen := int(stringLen)
  1189  			if intStringLen < 0 {
  1190  				return ErrInvalidLengthSilence
  1191  			}
  1192  			postIndex := iNdEx + intStringLen
  1193  			if postIndex < 0 {
  1194  				return ErrInvalidLengthSilence
  1195  			}
  1196  			if postIndex > l {
  1197  				return io.ErrUnexpectedEOF
  1198  			}
  1199  			m.CreatedBy = string(dAtA[iNdEx:postIndex])
  1200  			iNdEx = postIndex
  1201  		case 9:
  1202  			if wireType != 2 {
  1203  				return fmt.Errorf("proto: wrong wireType = %d for field Comment", wireType)
  1204  			}
  1205  			var stringLen uint64
  1206  			for shift := uint(0); ; shift += 7 {
  1207  				if shift >= 64 {
  1208  					return ErrIntOverflowSilence
  1209  				}
  1210  				if iNdEx >= l {
  1211  					return io.ErrUnexpectedEOF
  1212  				}
  1213  				b := dAtA[iNdEx]
  1214  				iNdEx++
  1215  				stringLen |= uint64(b&0x7F) << shift
  1216  				if b < 0x80 {
  1217  					break
  1218  				}
  1219  			}
  1220  			intStringLen := int(stringLen)
  1221  			if intStringLen < 0 {
  1222  				return ErrInvalidLengthSilence
  1223  			}
  1224  			postIndex := iNdEx + intStringLen
  1225  			if postIndex < 0 {
  1226  				return ErrInvalidLengthSilence
  1227  			}
  1228  			if postIndex > l {
  1229  				return io.ErrUnexpectedEOF
  1230  			}
  1231  			m.Comment = string(dAtA[iNdEx:postIndex])
  1232  			iNdEx = postIndex
  1233  		default:
  1234  			iNdEx = preIndex
  1235  			skippy, err := skipSilence(dAtA[iNdEx:])
  1236  			if err != nil {
  1237  				return err
  1238  			}
  1239  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1240  				return ErrInvalidLengthSilence
  1241  			}
  1242  			if (iNdEx + skippy) > l {
  1243  				return io.ErrUnexpectedEOF
  1244  			}
  1245  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1246  			iNdEx += skippy
  1247  		}
  1248  	}
  1249  
  1250  	if iNdEx > l {
  1251  		return io.ErrUnexpectedEOF
  1252  	}
  1253  	return nil
  1254  }
  1255  func (m *MeshSilence) Unmarshal(dAtA []byte) error {
  1256  	l := len(dAtA)
  1257  	iNdEx := 0
  1258  	for iNdEx < l {
  1259  		preIndex := iNdEx
  1260  		var wire uint64
  1261  		for shift := uint(0); ; shift += 7 {
  1262  			if shift >= 64 {
  1263  				return ErrIntOverflowSilence
  1264  			}
  1265  			if iNdEx >= l {
  1266  				return io.ErrUnexpectedEOF
  1267  			}
  1268  			b := dAtA[iNdEx]
  1269  			iNdEx++
  1270  			wire |= uint64(b&0x7F) << shift
  1271  			if b < 0x80 {
  1272  				break
  1273  			}
  1274  		}
  1275  		fieldNum := int32(wire >> 3)
  1276  		wireType := int(wire & 0x7)
  1277  		if wireType == 4 {
  1278  			return fmt.Errorf("proto: MeshSilence: wiretype end group for non-group")
  1279  		}
  1280  		if fieldNum <= 0 {
  1281  			return fmt.Errorf("proto: MeshSilence: illegal tag %d (wire type %d)", fieldNum, wire)
  1282  		}
  1283  		switch fieldNum {
  1284  		case 1:
  1285  			if wireType != 2 {
  1286  				return fmt.Errorf("proto: wrong wireType = %d for field Silence", wireType)
  1287  			}
  1288  			var msglen int
  1289  			for shift := uint(0); ; shift += 7 {
  1290  				if shift >= 64 {
  1291  					return ErrIntOverflowSilence
  1292  				}
  1293  				if iNdEx >= l {
  1294  					return io.ErrUnexpectedEOF
  1295  				}
  1296  				b := dAtA[iNdEx]
  1297  				iNdEx++
  1298  				msglen |= int(b&0x7F) << shift
  1299  				if b < 0x80 {
  1300  					break
  1301  				}
  1302  			}
  1303  			if msglen < 0 {
  1304  				return ErrInvalidLengthSilence
  1305  			}
  1306  			postIndex := iNdEx + msglen
  1307  			if postIndex < 0 {
  1308  				return ErrInvalidLengthSilence
  1309  			}
  1310  			if postIndex > l {
  1311  				return io.ErrUnexpectedEOF
  1312  			}
  1313  			if m.Silence == nil {
  1314  				m.Silence = &Silence{}
  1315  			}
  1316  			if err := m.Silence.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1317  				return err
  1318  			}
  1319  			iNdEx = postIndex
  1320  		case 2:
  1321  			if wireType != 2 {
  1322  				return fmt.Errorf("proto: wrong wireType = %d for field ExpiresAt", wireType)
  1323  			}
  1324  			var msglen int
  1325  			for shift := uint(0); ; shift += 7 {
  1326  				if shift >= 64 {
  1327  					return ErrIntOverflowSilence
  1328  				}
  1329  				if iNdEx >= l {
  1330  					return io.ErrUnexpectedEOF
  1331  				}
  1332  				b := dAtA[iNdEx]
  1333  				iNdEx++
  1334  				msglen |= int(b&0x7F) << shift
  1335  				if b < 0x80 {
  1336  					break
  1337  				}
  1338  			}
  1339  			if msglen < 0 {
  1340  				return ErrInvalidLengthSilence
  1341  			}
  1342  			postIndex := iNdEx + msglen
  1343  			if postIndex < 0 {
  1344  				return ErrInvalidLengthSilence
  1345  			}
  1346  			if postIndex > l {
  1347  				return io.ErrUnexpectedEOF
  1348  			}
  1349  			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ExpiresAt, dAtA[iNdEx:postIndex]); err != nil {
  1350  				return err
  1351  			}
  1352  			iNdEx = postIndex
  1353  		default:
  1354  			iNdEx = preIndex
  1355  			skippy, err := skipSilence(dAtA[iNdEx:])
  1356  			if err != nil {
  1357  				return err
  1358  			}
  1359  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1360  				return ErrInvalidLengthSilence
  1361  			}
  1362  			if (iNdEx + skippy) > l {
  1363  				return io.ErrUnexpectedEOF
  1364  			}
  1365  			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  1366  			iNdEx += skippy
  1367  		}
  1368  	}
  1369  
  1370  	if iNdEx > l {
  1371  		return io.ErrUnexpectedEOF
  1372  	}
  1373  	return nil
  1374  }
  1375  func skipSilence(dAtA []byte) (n int, err error) {
  1376  	l := len(dAtA)
  1377  	iNdEx := 0
  1378  	depth := 0
  1379  	for iNdEx < l {
  1380  		var wire uint64
  1381  		for shift := uint(0); ; shift += 7 {
  1382  			if shift >= 64 {
  1383  				return 0, ErrIntOverflowSilence
  1384  			}
  1385  			if iNdEx >= l {
  1386  				return 0, io.ErrUnexpectedEOF
  1387  			}
  1388  			b := dAtA[iNdEx]
  1389  			iNdEx++
  1390  			wire |= (uint64(b) & 0x7F) << shift
  1391  			if b < 0x80 {
  1392  				break
  1393  			}
  1394  		}
  1395  		wireType := int(wire & 0x7)
  1396  		switch wireType {
  1397  		case 0:
  1398  			for shift := uint(0); ; shift += 7 {
  1399  				if shift >= 64 {
  1400  					return 0, ErrIntOverflowSilence
  1401  				}
  1402  				if iNdEx >= l {
  1403  					return 0, io.ErrUnexpectedEOF
  1404  				}
  1405  				iNdEx++
  1406  				if dAtA[iNdEx-1] < 0x80 {
  1407  					break
  1408  				}
  1409  			}
  1410  		case 1:
  1411  			iNdEx += 8
  1412  		case 2:
  1413  			var length int
  1414  			for shift := uint(0); ; shift += 7 {
  1415  				if shift >= 64 {
  1416  					return 0, ErrIntOverflowSilence
  1417  				}
  1418  				if iNdEx >= l {
  1419  					return 0, io.ErrUnexpectedEOF
  1420  				}
  1421  				b := dAtA[iNdEx]
  1422  				iNdEx++
  1423  				length |= (int(b) & 0x7F) << shift
  1424  				if b < 0x80 {
  1425  					break
  1426  				}
  1427  			}
  1428  			if length < 0 {
  1429  				return 0, ErrInvalidLengthSilence
  1430  			}
  1431  			iNdEx += length
  1432  		case 3:
  1433  			depth++
  1434  		case 4:
  1435  			if depth == 0 {
  1436  				return 0, ErrUnexpectedEndOfGroupSilence
  1437  			}
  1438  			depth--
  1439  		case 5:
  1440  			iNdEx += 4
  1441  		default:
  1442  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  1443  		}
  1444  		if iNdEx < 0 {
  1445  			return 0, ErrInvalidLengthSilence
  1446  		}
  1447  		if depth == 0 {
  1448  			return iNdEx, nil
  1449  		}
  1450  	}
  1451  	return 0, io.ErrUnexpectedEOF
  1452  }
  1453  
  1454  var (
  1455  	ErrInvalidLengthSilence        = fmt.Errorf("proto: negative length found during unmarshaling")
  1456  	ErrIntOverflowSilence          = fmt.Errorf("proto: integer overflow")
  1457  	ErrUnexpectedEndOfGroupSilence = fmt.Errorf("proto: unexpected end of group")
  1458  )
  1459  

View as plain text