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