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