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 github_com_openshift_api_operator_v1 "github.com/openshift/api/operator/v1"
13
14 k8s_io_api_core_v1 "k8s.io/api/core/v1"
15
16 math "math"
17 math_bits "math/bits"
18 reflect "reflect"
19 strings "strings"
20 )
21
22
23 var _ = proto.Marshal
24 var _ = fmt.Errorf
25 var _ = math.Inf
26
27
28
29
30
31 const _ = proto.GoGoProtoPackageIsVersion3
32
33 func (m *Config) Reset() { *m = Config{} }
34 func (*Config) ProtoMessage() {}
35 func (*Config) Descriptor() ([]byte, []int) {
36 return fileDescriptor_67d62912ac03ce1e, []int{0}
37 }
38 func (m *Config) XXX_Unmarshal(b []byte) error {
39 return m.Unmarshal(b)
40 }
41 func (m *Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
42 b = b[:cap(b)]
43 n, err := m.MarshalToSizedBuffer(b)
44 if err != nil {
45 return nil, err
46 }
47 return b[:n], nil
48 }
49 func (m *Config) XXX_Merge(src proto.Message) {
50 xxx_messageInfo_Config.Merge(m, src)
51 }
52 func (m *Config) XXX_Size() int {
53 return m.Size()
54 }
55 func (m *Config) XXX_DiscardUnknown() {
56 xxx_messageInfo_Config.DiscardUnknown(m)
57 }
58
59 var xxx_messageInfo_Config proto.InternalMessageInfo
60
61 func (m *ConfigCondition) Reset() { *m = ConfigCondition{} }
62 func (*ConfigCondition) ProtoMessage() {}
63 func (*ConfigCondition) Descriptor() ([]byte, []int) {
64 return fileDescriptor_67d62912ac03ce1e, []int{1}
65 }
66 func (m *ConfigCondition) XXX_Unmarshal(b []byte) error {
67 return m.Unmarshal(b)
68 }
69 func (m *ConfigCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
70 b = b[:cap(b)]
71 n, err := m.MarshalToSizedBuffer(b)
72 if err != nil {
73 return nil, err
74 }
75 return b[:n], nil
76 }
77 func (m *ConfigCondition) XXX_Merge(src proto.Message) {
78 xxx_messageInfo_ConfigCondition.Merge(m, src)
79 }
80 func (m *ConfigCondition) XXX_Size() int {
81 return m.Size()
82 }
83 func (m *ConfigCondition) XXX_DiscardUnknown() {
84 xxx_messageInfo_ConfigCondition.DiscardUnknown(m)
85 }
86
87 var xxx_messageInfo_ConfigCondition proto.InternalMessageInfo
88
89 func (m *ConfigList) Reset() { *m = ConfigList{} }
90 func (*ConfigList) ProtoMessage() {}
91 func (*ConfigList) Descriptor() ([]byte, []int) {
92 return fileDescriptor_67d62912ac03ce1e, []int{2}
93 }
94 func (m *ConfigList) XXX_Unmarshal(b []byte) error {
95 return m.Unmarshal(b)
96 }
97 func (m *ConfigList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
98 b = b[:cap(b)]
99 n, err := m.MarshalToSizedBuffer(b)
100 if err != nil {
101 return nil, err
102 }
103 return b[:n], nil
104 }
105 func (m *ConfigList) XXX_Merge(src proto.Message) {
106 xxx_messageInfo_ConfigList.Merge(m, src)
107 }
108 func (m *ConfigList) XXX_Size() int {
109 return m.Size()
110 }
111 func (m *ConfigList) XXX_DiscardUnknown() {
112 xxx_messageInfo_ConfigList.DiscardUnknown(m)
113 }
114
115 var xxx_messageInfo_ConfigList proto.InternalMessageInfo
116
117 func (m *ConfigSpec) Reset() { *m = ConfigSpec{} }
118 func (*ConfigSpec) ProtoMessage() {}
119 func (*ConfigSpec) Descriptor() ([]byte, []int) {
120 return fileDescriptor_67d62912ac03ce1e, []int{3}
121 }
122 func (m *ConfigSpec) XXX_Unmarshal(b []byte) error {
123 return m.Unmarshal(b)
124 }
125 func (m *ConfigSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
126 b = b[:cap(b)]
127 n, err := m.MarshalToSizedBuffer(b)
128 if err != nil {
129 return nil, err
130 }
131 return b[:n], nil
132 }
133 func (m *ConfigSpec) XXX_Merge(src proto.Message) {
134 xxx_messageInfo_ConfigSpec.Merge(m, src)
135 }
136 func (m *ConfigSpec) XXX_Size() int {
137 return m.Size()
138 }
139 func (m *ConfigSpec) XXX_DiscardUnknown() {
140 xxx_messageInfo_ConfigSpec.DiscardUnknown(m)
141 }
142
143 var xxx_messageInfo_ConfigSpec proto.InternalMessageInfo
144
145 func (m *ConfigStatus) Reset() { *m = ConfigStatus{} }
146 func (*ConfigStatus) ProtoMessage() {}
147 func (*ConfigStatus) Descriptor() ([]byte, []int) {
148 return fileDescriptor_67d62912ac03ce1e, []int{4}
149 }
150 func (m *ConfigStatus) XXX_Unmarshal(b []byte) error {
151 return m.Unmarshal(b)
152 }
153 func (m *ConfigStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
154 b = b[:cap(b)]
155 n, err := m.MarshalToSizedBuffer(b)
156 if err != nil {
157 return nil, err
158 }
159 return b[:n], nil
160 }
161 func (m *ConfigStatus) XXX_Merge(src proto.Message) {
162 xxx_messageInfo_ConfigStatus.Merge(m, src)
163 }
164 func (m *ConfigStatus) XXX_Size() int {
165 return m.Size()
166 }
167 func (m *ConfigStatus) XXX_DiscardUnknown() {
168 xxx_messageInfo_ConfigStatus.DiscardUnknown(m)
169 }
170
171 var xxx_messageInfo_ConfigStatus proto.InternalMessageInfo
172
173 func init() {
174 proto.RegisterType((*Config)(nil), "github.com.openshift.api.samples.v1.Config")
175 proto.RegisterType((*ConfigCondition)(nil), "github.com.openshift.api.samples.v1.ConfigCondition")
176 proto.RegisterType((*ConfigList)(nil), "github.com.openshift.api.samples.v1.ConfigList")
177 proto.RegisterType((*ConfigSpec)(nil), "github.com.openshift.api.samples.v1.ConfigSpec")
178 proto.RegisterType((*ConfigStatus)(nil), "github.com.openshift.api.samples.v1.ConfigStatus")
179 }
180
181 func init() {
182 proto.RegisterFile("github.com/openshift/api/samples/v1/generated.proto", fileDescriptor_67d62912ac03ce1e)
183 }
184
185 var fileDescriptor_67d62912ac03ce1e = []byte{
186
187 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0xcd, 0x6e, 0xe4, 0x44,
188 0x10, 0x1e, 0x67, 0x7e, 0x92, 0xed, 0xdd, 0x64, 0x42, 0x07, 0xb1, 0x56, 0x0e, 0xf6, 0x6a, 0x22,
189 0xa1, 0x00, 0xa2, 0x4d, 0x96, 0x88, 0xe5, 0xc8, 0x7a, 0x4f, 0x91, 0x12, 0x2d, 0x74, 0x06, 0x24,
190 0x10, 0x07, 0x3a, 0x9e, 0x8a, 0xa7, 0x77, 0x62, 0xbb, 0xe5, 0xee, 0x19, 0x69, 0x6e, 0x3c, 0xc2,
191 0x1e, 0x79, 0x03, 0x5e, 0x82, 0x07, 0xc8, 0x8d, 0x3d, 0xee, 0xc9, 0x22, 0xe6, 0x2d, 0x72, 0x42,
192 0xdd, 0xb6, 0xe7, 0x7f, 0xc5, 0x8c, 0x16, 0x89, 0xdb, 0x74, 0x55, 0x7d, 0x5f, 0x55, 0xf7, 0xf7,
193 0x4d, 0xc9, 0xe8, 0xcb, 0x90, 0xab, 0xfe, 0xf0, 0x8a, 0x04, 0x49, 0xe4, 0x25, 0x02, 0x62, 0xd9,
194 0xe7, 0xd7, 0xca, 0x63, 0x82, 0x7b, 0x92, 0x45, 0xe2, 0x06, 0xa4, 0x37, 0x3a, 0xf1, 0x42, 0x88,
195 0x21, 0x65, 0x0a, 0x7a, 0x44, 0xa4, 0x89, 0x4a, 0xf0, 0xd1, 0x14, 0x44, 0x26, 0x20, 0xc2, 0x04,
196 0x27, 0x25, 0x88, 0x8c, 0x4e, 0x0e, 0x3f, 0x9f, 0x61, 0x0e, 0x93, 0x30, 0xf1, 0x0c, 0xf6, 0x6a,
197 0x78, 0x6d, 0x4e, 0xe6, 0x60, 0x7e, 0x15, 0x9c, 0x87, 0x9d, 0xc1, 0xd7, 0x92, 0xf0, 0xc4, 0xb4,
198 0x0e, 0x92, 0x14, 0x56, 0xf4, 0x3d, 0x3c, 0x9d, 0xd6, 0x44, 0x2c, 0xe8, 0xf3, 0x18, 0xd2, 0xb1,
199 0x27, 0x06, 0xa1, 0x0e, 0x48, 0x2f, 0x02, 0xc5, 0x56, 0xa1, 0xbc, 0x77, 0xa1, 0xd2, 0x61, 0xac,
200 0x78, 0x04, 0x4b, 0x80, 0xaf, 0xfe, 0x0d, 0x20, 0x83, 0x3e, 0x44, 0x6c, 0x11, 0xd7, 0xf9, 0x6d,
201 0x0b, 0xb5, 0x5e, 0x24, 0xf1, 0x35, 0x0f, 0xf1, 0x2f, 0x68, 0x47, 0x8f, 0xd3, 0x63, 0x8a, 0xd9,
202 0xd6, 0x13, 0xeb, 0xf8, 0xe1, 0xd3, 0x2f, 0x48, 0xc1, 0x4a, 0x66, 0x59, 0x89, 0x18, 0x84, 0x3a,
203 0x20, 0x89, 0xae, 0x26, 0xa3, 0x13, 0xf2, 0xf2, 0xea, 0x15, 0x04, 0xea, 0x02, 0x14, 0xf3, 0xf1,
204 0x6d, 0xe6, 0xd6, 0xf2, 0xcc, 0x45, 0xd3, 0x18, 0x9d, 0xb0, 0xe2, 0xef, 0x50, 0x43, 0x0a, 0x08,
205 0xec, 0x2d, 0xc3, 0xee, 0x91, 0x35, 0x24, 0x21, 0xc5, 0x70, 0x97, 0x02, 0x02, 0xff, 0x51, 0x49,
206 0xde, 0xd0, 0x27, 0x6a, 0xa8, 0xf0, 0x8f, 0xa8, 0x25, 0x15, 0x53, 0x43, 0x69, 0xd7, 0x0d, 0xe9,
207 0xc9, 0x26, 0xa4, 0x06, 0xe8, 0xef, 0x95, 0xb4, 0xad, 0xe2, 0x4c, 0x4b, 0xc2, 0xce, 0x9f, 0x75,
208 0xd4, 0x2e, 0x0a, 0x5f, 0x24, 0x71, 0x8f, 0x2b, 0x9e, 0xc4, 0xf8, 0x19, 0x6a, 0xa8, 0xb1, 0x00,
209 0xf3, 0x3e, 0x0f, 0xfc, 0xa3, 0x6a, 0xa0, 0xee, 0x58, 0xc0, 0x7d, 0xe6, 0x1e, 0x2c, 0x94, 0xeb,
210 0x30, 0x35, 0x00, 0x7c, 0x3e, 0x99, 0x73, 0xcb, 0x40, 0x4f, 0xe7, 0x9b, 0xde, 0x67, 0xee, 0x0a,
211 0x33, 0x91, 0x09, 0xd3, 0xfc, 0x68, 0xf8, 0x15, 0xda, 0xbb, 0x61, 0x52, 0x7d, 0x2f, 0x7a, 0x4c,
212 0x41, 0x97, 0x47, 0x50, 0xde, 0xfe, 0xd3, 0xf5, 0x04, 0xd3, 0x08, 0xff, 0xa3, 0x72, 0x82, 0xbd,
213 0xf3, 0x39, 0x26, 0xba, 0xc0, 0x8c, 0x47, 0x08, 0xeb, 0x48, 0x37, 0x65, 0xb1, 0x2c, 0x6e, 0xa5,
214 0xfb, 0x35, 0x36, 0xee, 0x77, 0x58, 0xf6, 0xc3, 0xe7, 0x4b, 0x6c, 0x74, 0x45, 0x07, 0xfc, 0x31,
215 0x6a, 0xa5, 0xc0, 0x64, 0x12, 0xdb, 0x4d, 0xf3, 0x62, 0x13, 0x99, 0xa8, 0x89, 0xd2, 0x32, 0x8b,
216 0x3f, 0x41, 0xdb, 0x11, 0x48, 0xc9, 0x42, 0xb0, 0x5b, 0xa6, 0xb0, 0x5d, 0x16, 0x6e, 0x5f, 0x14,
217 0x61, 0x5a, 0xe5, 0x3b, 0x7f, 0x58, 0x08, 0x15, 0x12, 0x9d, 0x73, 0xa9, 0xf0, 0xcf, 0x4b, 0x86,
218 0x27, 0xeb, 0xdd, 0x47, 0xa3, 0x8d, 0xdd, 0xf7, 0xcb, 0x56, 0x3b, 0x55, 0x64, 0xc6, 0xec, 0xdf,
219 0xa2, 0x26, 0x57, 0x10, 0x69, 0xc1, 0xeb, 0xc7, 0x0f, 0x9f, 0x7e, 0xb6, 0x81, 0x31, 0xfd, 0xdd,
220 0x92, 0xb7, 0x79, 0xa6, 0x19, 0x68, 0x41, 0xd4, 0x79, 0x5d, 0xaf, 0xc6, 0xd7, 0x7f, 0x00, 0x3c,
221 0x46, 0xed, 0x88, 0xc5, 0x2c, 0x84, 0x08, 0x62, 0xa5, 0x0d, 0x52, 0xd9, 0xf2, 0x65, 0x89, 0x6e,
222 0x5f, 0xcc, 0xa7, 0xef, 0x33, 0xf7, 0xf4, 0x9d, 0xab, 0x33, 0x11, 0x7a, 0x2f, 0x24, 0xa9, 0xb6,
223 0xdd, 0x02, 0x8e, 0x2e, 0xf6, 0xc1, 0xcf, 0x51, 0xbb, 0x1c, 0x9a, 0x42, 0xc8, 0xa5, 0x4a, 0xc7,
224 0xa5, 0xad, 0x1f, 0x57, 0xad, 0x2f, 0xe7, 0xd3, 0x74, 0xb1, 0x1e, 0x3f, 0x43, 0xbb, 0x2c, 0x0d,
225 0xfa, 0x5c, 0x41, 0xa0, 0x86, 0x29, 0x48, 0xbb, 0xf1, 0xa4, 0x7e, 0xfc, 0xc0, 0xff, 0x20, 0xcf,
226 0xdc, 0xdd, 0xe7, 0xb3, 0x09, 0x3a, 0x5f, 0x87, 0xcf, 0xd0, 0x81, 0x1c, 0x70, 0x21, 0xa0, 0x77,
227 0x16, 0xb1, 0x10, 0xa4, 0x4a, 0x81, 0x45, 0xd2, 0x6e, 0x1a, 0xf8, 0xe3, 0x3c, 0x73, 0x0f, 0x2e,
228 0x97, 0xd3, 0x74, 0x15, 0x06, 0x7f, 0x83, 0xf6, 0xcb, 0x70, 0x17, 0x22, 0x71, 0xc3, 0x14, 0x48,
229 0xbb, 0x65, 0x78, 0x3e, 0xcc, 0x33, 0x77, 0xff, 0x72, 0x21, 0x47, 0x97, 0xaa, 0x3b, 0xbf, 0x37,
230 0xd0, 0xa3, 0xd9, 0x65, 0xf2, 0x7f, 0x8a, 0xd2, 0x47, 0x28, 0xa8, 0xf6, 0x45, 0xe5, 0xba, 0xd3,
231 0x0d, 0x5c, 0x37, 0x59, 0x36, 0xd3, 0x2d, 0x3e, 0x09, 0x49, 0x3a, 0xc3, 0xbd, 0x4a, 0xfe, 0xfa,
232 0xfb, 0xca, 0xdf, 0x7c, 0x3f, 0xf9, 0x5b, 0xff, 0x91, 0xfc, 0xdb, 0x9b, 0xc8, 0xaf, 0x77, 0xcf,
233 0x08, 0x52, 0xc9, 0x93, 0xd8, 0xde, 0x99, 0xdf, 0x3d, 0x3f, 0x14, 0x61, 0x5a, 0xe5, 0xfd, 0xb3,
234 0xdb, 0x3b, 0xa7, 0xf6, 0xe6, 0xce, 0xa9, 0xbd, 0xbd, 0x73, 0x6a, 0xbf, 0xe6, 0x8e, 0x75, 0x9b,
235 0x3b, 0xd6, 0x9b, 0xdc, 0xb1, 0xde, 0xe6, 0x8e, 0xf5, 0x57, 0xee, 0x58, 0xaf, 0xff, 0x76, 0x6a,
236 0x3f, 0x1d, 0xad, 0xf1, 0x69, 0xf3, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa9, 0xd3, 0x0c, 0x8c,
237 0x00, 0x09, 0x00, 0x00,
238 }
239
240 func (m *Config) Marshal() (dAtA []byte, err error) {
241 size := m.Size()
242 dAtA = make([]byte, size)
243 n, err := m.MarshalToSizedBuffer(dAtA[:size])
244 if err != nil {
245 return nil, err
246 }
247 return dAtA[:n], nil
248 }
249
250 func (m *Config) MarshalTo(dAtA []byte) (int, error) {
251 size := m.Size()
252 return m.MarshalToSizedBuffer(dAtA[:size])
253 }
254
255 func (m *Config) MarshalToSizedBuffer(dAtA []byte) (int, error) {
256 i := len(dAtA)
257 _ = i
258 var l int
259 _ = l
260 {
261 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
262 if err != nil {
263 return 0, err
264 }
265 i -= size
266 i = encodeVarintGenerated(dAtA, i, uint64(size))
267 }
268 i--
269 dAtA[i] = 0x1a
270 {
271 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
272 if err != nil {
273 return 0, err
274 }
275 i -= size
276 i = encodeVarintGenerated(dAtA, i, uint64(size))
277 }
278 i--
279 dAtA[i] = 0x12
280 {
281 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
282 if err != nil {
283 return 0, err
284 }
285 i -= size
286 i = encodeVarintGenerated(dAtA, i, uint64(size))
287 }
288 i--
289 dAtA[i] = 0xa
290 return len(dAtA) - i, nil
291 }
292
293 func (m *ConfigCondition) Marshal() (dAtA []byte, err error) {
294 size := m.Size()
295 dAtA = make([]byte, size)
296 n, err := m.MarshalToSizedBuffer(dAtA[:size])
297 if err != nil {
298 return nil, err
299 }
300 return dAtA[:n], nil
301 }
302
303 func (m *ConfigCondition) MarshalTo(dAtA []byte) (int, error) {
304 size := m.Size()
305 return m.MarshalToSizedBuffer(dAtA[:size])
306 }
307
308 func (m *ConfigCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
309 i := len(dAtA)
310 _ = i
311 var l int
312 _ = l
313 i -= len(m.Message)
314 copy(dAtA[i:], m.Message)
315 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
316 i--
317 dAtA[i] = 0x32
318 i -= len(m.Reason)
319 copy(dAtA[i:], m.Reason)
320 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
321 i--
322 dAtA[i] = 0x2a
323 {
324 size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
325 if err != nil {
326 return 0, err
327 }
328 i -= size
329 i = encodeVarintGenerated(dAtA, i, uint64(size))
330 }
331 i--
332 dAtA[i] = 0x22
333 {
334 size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i])
335 if err != nil {
336 return 0, err
337 }
338 i -= size
339 i = encodeVarintGenerated(dAtA, i, uint64(size))
340 }
341 i--
342 dAtA[i] = 0x1a
343 i -= len(m.Status)
344 copy(dAtA[i:], m.Status)
345 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
346 i--
347 dAtA[i] = 0x12
348 i -= len(m.Type)
349 copy(dAtA[i:], m.Type)
350 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
351 i--
352 dAtA[i] = 0xa
353 return len(dAtA) - i, nil
354 }
355
356 func (m *ConfigList) Marshal() (dAtA []byte, err error) {
357 size := m.Size()
358 dAtA = make([]byte, size)
359 n, err := m.MarshalToSizedBuffer(dAtA[:size])
360 if err != nil {
361 return nil, err
362 }
363 return dAtA[:n], nil
364 }
365
366 func (m *ConfigList) MarshalTo(dAtA []byte) (int, error) {
367 size := m.Size()
368 return m.MarshalToSizedBuffer(dAtA[:size])
369 }
370
371 func (m *ConfigList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
372 i := len(dAtA)
373 _ = i
374 var l int
375 _ = l
376 if len(m.Items) > 0 {
377 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
378 {
379 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
380 if err != nil {
381 return 0, err
382 }
383 i -= size
384 i = encodeVarintGenerated(dAtA, i, uint64(size))
385 }
386 i--
387 dAtA[i] = 0x12
388 }
389 }
390 {
391 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
392 if err != nil {
393 return 0, err
394 }
395 i -= size
396 i = encodeVarintGenerated(dAtA, i, uint64(size))
397 }
398 i--
399 dAtA[i] = 0xa
400 return len(dAtA) - i, nil
401 }
402
403 func (m *ConfigSpec) Marshal() (dAtA []byte, err error) {
404 size := m.Size()
405 dAtA = make([]byte, size)
406 n, err := m.MarshalToSizedBuffer(dAtA[:size])
407 if err != nil {
408 return nil, err
409 }
410 return dAtA[:n], nil
411 }
412
413 func (m *ConfigSpec) MarshalTo(dAtA []byte) (int, error) {
414 size := m.Size()
415 return m.MarshalToSizedBuffer(dAtA[:size])
416 }
417
418 func (m *ConfigSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
419 i := len(dAtA)
420 _ = i
421 var l int
422 _ = l
423 if len(m.SkippedTemplates) > 0 {
424 for iNdEx := len(m.SkippedTemplates) - 1; iNdEx >= 0; iNdEx-- {
425 i -= len(m.SkippedTemplates[iNdEx])
426 copy(dAtA[i:], m.SkippedTemplates[iNdEx])
427 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SkippedTemplates[iNdEx])))
428 i--
429 dAtA[i] = 0x32
430 }
431 }
432 if len(m.SkippedImagestreams) > 0 {
433 for iNdEx := len(m.SkippedImagestreams) - 1; iNdEx >= 0; iNdEx-- {
434 i -= len(m.SkippedImagestreams[iNdEx])
435 copy(dAtA[i:], m.SkippedImagestreams[iNdEx])
436 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SkippedImagestreams[iNdEx])))
437 i--
438 dAtA[i] = 0x2a
439 }
440 }
441 if len(m.Architectures) > 0 {
442 for iNdEx := len(m.Architectures) - 1; iNdEx >= 0; iNdEx-- {
443 i -= len(m.Architectures[iNdEx])
444 copy(dAtA[i:], m.Architectures[iNdEx])
445 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Architectures[iNdEx])))
446 i--
447 dAtA[i] = 0x22
448 }
449 }
450 i -= len(m.SamplesRegistry)
451 copy(dAtA[i:], m.SamplesRegistry)
452 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SamplesRegistry)))
453 i--
454 dAtA[i] = 0x12
455 i -= len(m.ManagementState)
456 copy(dAtA[i:], m.ManagementState)
457 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ManagementState)))
458 i--
459 dAtA[i] = 0xa
460 return len(dAtA) - i, nil
461 }
462
463 func (m *ConfigStatus) Marshal() (dAtA []byte, err error) {
464 size := m.Size()
465 dAtA = make([]byte, size)
466 n, err := m.MarshalToSizedBuffer(dAtA[:size])
467 if err != nil {
468 return nil, err
469 }
470 return dAtA[:n], nil
471 }
472
473 func (m *ConfigStatus) MarshalTo(dAtA []byte) (int, error) {
474 size := m.Size()
475 return m.MarshalToSizedBuffer(dAtA[:size])
476 }
477
478 func (m *ConfigStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
479 i := len(dAtA)
480 _ = i
481 var l int
482 _ = l
483 i -= len(m.Version)
484 copy(dAtA[i:], m.Version)
485 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
486 i--
487 dAtA[i] = 0x42
488 if len(m.SkippedTemplates) > 0 {
489 for iNdEx := len(m.SkippedTemplates) - 1; iNdEx >= 0; iNdEx-- {
490 i -= len(m.SkippedTemplates[iNdEx])
491 copy(dAtA[i:], m.SkippedTemplates[iNdEx])
492 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SkippedTemplates[iNdEx])))
493 i--
494 dAtA[i] = 0x3a
495 }
496 }
497 if len(m.SkippedImagestreams) > 0 {
498 for iNdEx := len(m.SkippedImagestreams) - 1; iNdEx >= 0; iNdEx-- {
499 i -= len(m.SkippedImagestreams[iNdEx])
500 copy(dAtA[i:], m.SkippedImagestreams[iNdEx])
501 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SkippedImagestreams[iNdEx])))
502 i--
503 dAtA[i] = 0x32
504 }
505 }
506 if len(m.Architectures) > 0 {
507 for iNdEx := len(m.Architectures) - 1; iNdEx >= 0; iNdEx-- {
508 i -= len(m.Architectures[iNdEx])
509 copy(dAtA[i:], m.Architectures[iNdEx])
510 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Architectures[iNdEx])))
511 i--
512 dAtA[i] = 0x2a
513 }
514 }
515 i -= len(m.SamplesRegistry)
516 copy(dAtA[i:], m.SamplesRegistry)
517 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SamplesRegistry)))
518 i--
519 dAtA[i] = 0x1a
520 if len(m.Conditions) > 0 {
521 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
522 {
523 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
524 if err != nil {
525 return 0, err
526 }
527 i -= size
528 i = encodeVarintGenerated(dAtA, i, uint64(size))
529 }
530 i--
531 dAtA[i] = 0x12
532 }
533 }
534 i -= len(m.ManagementState)
535 copy(dAtA[i:], m.ManagementState)
536 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ManagementState)))
537 i--
538 dAtA[i] = 0xa
539 return len(dAtA) - i, nil
540 }
541
542 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
543 offset -= sovGenerated(v)
544 base := offset
545 for v >= 1<<7 {
546 dAtA[offset] = uint8(v&0x7f | 0x80)
547 v >>= 7
548 offset++
549 }
550 dAtA[offset] = uint8(v)
551 return base
552 }
553 func (m *Config) Size() (n int) {
554 if m == nil {
555 return 0
556 }
557 var l int
558 _ = l
559 l = m.ObjectMeta.Size()
560 n += 1 + l + sovGenerated(uint64(l))
561 l = m.Spec.Size()
562 n += 1 + l + sovGenerated(uint64(l))
563 l = m.Status.Size()
564 n += 1 + l + sovGenerated(uint64(l))
565 return n
566 }
567
568 func (m *ConfigCondition) Size() (n int) {
569 if m == nil {
570 return 0
571 }
572 var l int
573 _ = l
574 l = len(m.Type)
575 n += 1 + l + sovGenerated(uint64(l))
576 l = len(m.Status)
577 n += 1 + l + sovGenerated(uint64(l))
578 l = m.LastUpdateTime.Size()
579 n += 1 + l + sovGenerated(uint64(l))
580 l = m.LastTransitionTime.Size()
581 n += 1 + l + sovGenerated(uint64(l))
582 l = len(m.Reason)
583 n += 1 + l + sovGenerated(uint64(l))
584 l = len(m.Message)
585 n += 1 + l + sovGenerated(uint64(l))
586 return n
587 }
588
589 func (m *ConfigList) Size() (n int) {
590 if m == nil {
591 return 0
592 }
593 var l int
594 _ = l
595 l = m.ListMeta.Size()
596 n += 1 + l + sovGenerated(uint64(l))
597 if len(m.Items) > 0 {
598 for _, e := range m.Items {
599 l = e.Size()
600 n += 1 + l + sovGenerated(uint64(l))
601 }
602 }
603 return n
604 }
605
606 func (m *ConfigSpec) Size() (n int) {
607 if m == nil {
608 return 0
609 }
610 var l int
611 _ = l
612 l = len(m.ManagementState)
613 n += 1 + l + sovGenerated(uint64(l))
614 l = len(m.SamplesRegistry)
615 n += 1 + l + sovGenerated(uint64(l))
616 if len(m.Architectures) > 0 {
617 for _, s := range m.Architectures {
618 l = len(s)
619 n += 1 + l + sovGenerated(uint64(l))
620 }
621 }
622 if len(m.SkippedImagestreams) > 0 {
623 for _, s := range m.SkippedImagestreams {
624 l = len(s)
625 n += 1 + l + sovGenerated(uint64(l))
626 }
627 }
628 if len(m.SkippedTemplates) > 0 {
629 for _, s := range m.SkippedTemplates {
630 l = len(s)
631 n += 1 + l + sovGenerated(uint64(l))
632 }
633 }
634 return n
635 }
636
637 func (m *ConfigStatus) Size() (n int) {
638 if m == nil {
639 return 0
640 }
641 var l int
642 _ = l
643 l = len(m.ManagementState)
644 n += 1 + l + sovGenerated(uint64(l))
645 if len(m.Conditions) > 0 {
646 for _, e := range m.Conditions {
647 l = e.Size()
648 n += 1 + l + sovGenerated(uint64(l))
649 }
650 }
651 l = len(m.SamplesRegistry)
652 n += 1 + l + sovGenerated(uint64(l))
653 if len(m.Architectures) > 0 {
654 for _, s := range m.Architectures {
655 l = len(s)
656 n += 1 + l + sovGenerated(uint64(l))
657 }
658 }
659 if len(m.SkippedImagestreams) > 0 {
660 for _, s := range m.SkippedImagestreams {
661 l = len(s)
662 n += 1 + l + sovGenerated(uint64(l))
663 }
664 }
665 if len(m.SkippedTemplates) > 0 {
666 for _, s := range m.SkippedTemplates {
667 l = len(s)
668 n += 1 + l + sovGenerated(uint64(l))
669 }
670 }
671 l = len(m.Version)
672 n += 1 + l + sovGenerated(uint64(l))
673 return n
674 }
675
676 func sovGenerated(x uint64) (n int) {
677 return (math_bits.Len64(x|1) + 6) / 7
678 }
679 func sozGenerated(x uint64) (n int) {
680 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
681 }
682 func (this *Config) String() string {
683 if this == nil {
684 return "nil"
685 }
686 s := strings.Join([]string{`&Config{`,
687 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
688 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ConfigSpec", "ConfigSpec", 1), `&`, ``, 1) + `,`,
689 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ConfigStatus", "ConfigStatus", 1), `&`, ``, 1) + `,`,
690 `}`,
691 }, "")
692 return s
693 }
694 func (this *ConfigCondition) String() string {
695 if this == nil {
696 return "nil"
697 }
698 s := strings.Join([]string{`&ConfigCondition{`,
699 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
700 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
701 `LastUpdateTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
702 `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
703 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
704 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
705 `}`,
706 }, "")
707 return s
708 }
709 func (this *ConfigList) String() string {
710 if this == nil {
711 return "nil"
712 }
713 repeatedStringForItems := "[]Config{"
714 for _, f := range this.Items {
715 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Config", "Config", 1), `&`, ``, 1) + ","
716 }
717 repeatedStringForItems += "}"
718 s := strings.Join([]string{`&ConfigList{`,
719 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
720 `Items:` + repeatedStringForItems + `,`,
721 `}`,
722 }, "")
723 return s
724 }
725 func (this *ConfigSpec) String() string {
726 if this == nil {
727 return "nil"
728 }
729 s := strings.Join([]string{`&ConfigSpec{`,
730 `ManagementState:` + fmt.Sprintf("%v", this.ManagementState) + `,`,
731 `SamplesRegistry:` + fmt.Sprintf("%v", this.SamplesRegistry) + `,`,
732 `Architectures:` + fmt.Sprintf("%v", this.Architectures) + `,`,
733 `SkippedImagestreams:` + fmt.Sprintf("%v", this.SkippedImagestreams) + `,`,
734 `SkippedTemplates:` + fmt.Sprintf("%v", this.SkippedTemplates) + `,`,
735 `}`,
736 }, "")
737 return s
738 }
739 func (this *ConfigStatus) String() string {
740 if this == nil {
741 return "nil"
742 }
743 repeatedStringForConditions := "[]ConfigCondition{"
744 for _, f := range this.Conditions {
745 repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "ConfigCondition", "ConfigCondition", 1), `&`, ``, 1) + ","
746 }
747 repeatedStringForConditions += "}"
748 s := strings.Join([]string{`&ConfigStatus{`,
749 `ManagementState:` + fmt.Sprintf("%v", this.ManagementState) + `,`,
750 `Conditions:` + repeatedStringForConditions + `,`,
751 `SamplesRegistry:` + fmt.Sprintf("%v", this.SamplesRegistry) + `,`,
752 `Architectures:` + fmt.Sprintf("%v", this.Architectures) + `,`,
753 `SkippedImagestreams:` + fmt.Sprintf("%v", this.SkippedImagestreams) + `,`,
754 `SkippedTemplates:` + fmt.Sprintf("%v", this.SkippedTemplates) + `,`,
755 `Version:` + fmt.Sprintf("%v", this.Version) + `,`,
756 `}`,
757 }, "")
758 return s
759 }
760 func valueToStringGenerated(v interface{}) string {
761 rv := reflect.ValueOf(v)
762 if rv.IsNil() {
763 return "nil"
764 }
765 pv := reflect.Indirect(rv).Interface()
766 return fmt.Sprintf("*%v", pv)
767 }
768 func (m *Config) Unmarshal(dAtA []byte) error {
769 l := len(dAtA)
770 iNdEx := 0
771 for iNdEx < l {
772 preIndex := iNdEx
773 var wire uint64
774 for shift := uint(0); ; shift += 7 {
775 if shift >= 64 {
776 return ErrIntOverflowGenerated
777 }
778 if iNdEx >= l {
779 return io.ErrUnexpectedEOF
780 }
781 b := dAtA[iNdEx]
782 iNdEx++
783 wire |= uint64(b&0x7F) << shift
784 if b < 0x80 {
785 break
786 }
787 }
788 fieldNum := int32(wire >> 3)
789 wireType := int(wire & 0x7)
790 if wireType == 4 {
791 return fmt.Errorf("proto: Config: wiretype end group for non-group")
792 }
793 if fieldNum <= 0 {
794 return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
795 }
796 switch fieldNum {
797 case 1:
798 if wireType != 2 {
799 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
800 }
801 var msglen int
802 for shift := uint(0); ; shift += 7 {
803 if shift >= 64 {
804 return ErrIntOverflowGenerated
805 }
806 if iNdEx >= l {
807 return io.ErrUnexpectedEOF
808 }
809 b := dAtA[iNdEx]
810 iNdEx++
811 msglen |= int(b&0x7F) << shift
812 if b < 0x80 {
813 break
814 }
815 }
816 if msglen < 0 {
817 return ErrInvalidLengthGenerated
818 }
819 postIndex := iNdEx + msglen
820 if postIndex < 0 {
821 return ErrInvalidLengthGenerated
822 }
823 if postIndex > l {
824 return io.ErrUnexpectedEOF
825 }
826 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
827 return err
828 }
829 iNdEx = postIndex
830 case 2:
831 if wireType != 2 {
832 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
833 }
834 var msglen int
835 for shift := uint(0); ; shift += 7 {
836 if shift >= 64 {
837 return ErrIntOverflowGenerated
838 }
839 if iNdEx >= l {
840 return io.ErrUnexpectedEOF
841 }
842 b := dAtA[iNdEx]
843 iNdEx++
844 msglen |= int(b&0x7F) << shift
845 if b < 0x80 {
846 break
847 }
848 }
849 if msglen < 0 {
850 return ErrInvalidLengthGenerated
851 }
852 postIndex := iNdEx + msglen
853 if postIndex < 0 {
854 return ErrInvalidLengthGenerated
855 }
856 if postIndex > l {
857 return io.ErrUnexpectedEOF
858 }
859 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
860 return err
861 }
862 iNdEx = postIndex
863 case 3:
864 if wireType != 2 {
865 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
866 }
867 var msglen int
868 for shift := uint(0); ; shift += 7 {
869 if shift >= 64 {
870 return ErrIntOverflowGenerated
871 }
872 if iNdEx >= l {
873 return io.ErrUnexpectedEOF
874 }
875 b := dAtA[iNdEx]
876 iNdEx++
877 msglen |= int(b&0x7F) << shift
878 if b < 0x80 {
879 break
880 }
881 }
882 if msglen < 0 {
883 return ErrInvalidLengthGenerated
884 }
885 postIndex := iNdEx + msglen
886 if postIndex < 0 {
887 return ErrInvalidLengthGenerated
888 }
889 if postIndex > l {
890 return io.ErrUnexpectedEOF
891 }
892 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
893 return err
894 }
895 iNdEx = postIndex
896 default:
897 iNdEx = preIndex
898 skippy, err := skipGenerated(dAtA[iNdEx:])
899 if err != nil {
900 return err
901 }
902 if (skippy < 0) || (iNdEx+skippy) < 0 {
903 return ErrInvalidLengthGenerated
904 }
905 if (iNdEx + skippy) > l {
906 return io.ErrUnexpectedEOF
907 }
908 iNdEx += skippy
909 }
910 }
911
912 if iNdEx > l {
913 return io.ErrUnexpectedEOF
914 }
915 return nil
916 }
917 func (m *ConfigCondition) Unmarshal(dAtA []byte) error {
918 l := len(dAtA)
919 iNdEx := 0
920 for iNdEx < l {
921 preIndex := iNdEx
922 var wire uint64
923 for shift := uint(0); ; shift += 7 {
924 if shift >= 64 {
925 return ErrIntOverflowGenerated
926 }
927 if iNdEx >= l {
928 return io.ErrUnexpectedEOF
929 }
930 b := dAtA[iNdEx]
931 iNdEx++
932 wire |= uint64(b&0x7F) << shift
933 if b < 0x80 {
934 break
935 }
936 }
937 fieldNum := int32(wire >> 3)
938 wireType := int(wire & 0x7)
939 if wireType == 4 {
940 return fmt.Errorf("proto: ConfigCondition: wiretype end group for non-group")
941 }
942 if fieldNum <= 0 {
943 return fmt.Errorf("proto: ConfigCondition: illegal tag %d (wire type %d)", fieldNum, wire)
944 }
945 switch fieldNum {
946 case 1:
947 if wireType != 2 {
948 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
949 }
950 var stringLen uint64
951 for shift := uint(0); ; shift += 7 {
952 if shift >= 64 {
953 return ErrIntOverflowGenerated
954 }
955 if iNdEx >= l {
956 return io.ErrUnexpectedEOF
957 }
958 b := dAtA[iNdEx]
959 iNdEx++
960 stringLen |= uint64(b&0x7F) << shift
961 if b < 0x80 {
962 break
963 }
964 }
965 intStringLen := int(stringLen)
966 if intStringLen < 0 {
967 return ErrInvalidLengthGenerated
968 }
969 postIndex := iNdEx + intStringLen
970 if postIndex < 0 {
971 return ErrInvalidLengthGenerated
972 }
973 if postIndex > l {
974 return io.ErrUnexpectedEOF
975 }
976 m.Type = ConfigConditionType(dAtA[iNdEx:postIndex])
977 iNdEx = postIndex
978 case 2:
979 if wireType != 2 {
980 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
981 }
982 var stringLen uint64
983 for shift := uint(0); ; shift += 7 {
984 if shift >= 64 {
985 return ErrIntOverflowGenerated
986 }
987 if iNdEx >= l {
988 return io.ErrUnexpectedEOF
989 }
990 b := dAtA[iNdEx]
991 iNdEx++
992 stringLen |= uint64(b&0x7F) << shift
993 if b < 0x80 {
994 break
995 }
996 }
997 intStringLen := int(stringLen)
998 if intStringLen < 0 {
999 return ErrInvalidLengthGenerated
1000 }
1001 postIndex := iNdEx + intStringLen
1002 if postIndex < 0 {
1003 return ErrInvalidLengthGenerated
1004 }
1005 if postIndex > l {
1006 return io.ErrUnexpectedEOF
1007 }
1008 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
1009 iNdEx = postIndex
1010 case 3:
1011 if wireType != 2 {
1012 return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
1013 }
1014 var msglen int
1015 for shift := uint(0); ; shift += 7 {
1016 if shift >= 64 {
1017 return ErrIntOverflowGenerated
1018 }
1019 if iNdEx >= l {
1020 return io.ErrUnexpectedEOF
1021 }
1022 b := dAtA[iNdEx]
1023 iNdEx++
1024 msglen |= int(b&0x7F) << shift
1025 if b < 0x80 {
1026 break
1027 }
1028 }
1029 if msglen < 0 {
1030 return ErrInvalidLengthGenerated
1031 }
1032 postIndex := iNdEx + msglen
1033 if postIndex < 0 {
1034 return ErrInvalidLengthGenerated
1035 }
1036 if postIndex > l {
1037 return io.ErrUnexpectedEOF
1038 }
1039 if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1040 return err
1041 }
1042 iNdEx = postIndex
1043 case 4:
1044 if wireType != 2 {
1045 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
1046 }
1047 var msglen int
1048 for shift := uint(0); ; shift += 7 {
1049 if shift >= 64 {
1050 return ErrIntOverflowGenerated
1051 }
1052 if iNdEx >= l {
1053 return io.ErrUnexpectedEOF
1054 }
1055 b := dAtA[iNdEx]
1056 iNdEx++
1057 msglen |= int(b&0x7F) << shift
1058 if b < 0x80 {
1059 break
1060 }
1061 }
1062 if msglen < 0 {
1063 return ErrInvalidLengthGenerated
1064 }
1065 postIndex := iNdEx + msglen
1066 if postIndex < 0 {
1067 return ErrInvalidLengthGenerated
1068 }
1069 if postIndex > l {
1070 return io.ErrUnexpectedEOF
1071 }
1072 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1073 return err
1074 }
1075 iNdEx = postIndex
1076 case 5:
1077 if wireType != 2 {
1078 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
1079 }
1080 var stringLen uint64
1081 for shift := uint(0); ; shift += 7 {
1082 if shift >= 64 {
1083 return ErrIntOverflowGenerated
1084 }
1085 if iNdEx >= l {
1086 return io.ErrUnexpectedEOF
1087 }
1088 b := dAtA[iNdEx]
1089 iNdEx++
1090 stringLen |= uint64(b&0x7F) << shift
1091 if b < 0x80 {
1092 break
1093 }
1094 }
1095 intStringLen := int(stringLen)
1096 if intStringLen < 0 {
1097 return ErrInvalidLengthGenerated
1098 }
1099 postIndex := iNdEx + intStringLen
1100 if postIndex < 0 {
1101 return ErrInvalidLengthGenerated
1102 }
1103 if postIndex > l {
1104 return io.ErrUnexpectedEOF
1105 }
1106 m.Reason = string(dAtA[iNdEx:postIndex])
1107 iNdEx = postIndex
1108 case 6:
1109 if wireType != 2 {
1110 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
1111 }
1112 var stringLen uint64
1113 for shift := uint(0); ; shift += 7 {
1114 if shift >= 64 {
1115 return ErrIntOverflowGenerated
1116 }
1117 if iNdEx >= l {
1118 return io.ErrUnexpectedEOF
1119 }
1120 b := dAtA[iNdEx]
1121 iNdEx++
1122 stringLen |= uint64(b&0x7F) << shift
1123 if b < 0x80 {
1124 break
1125 }
1126 }
1127 intStringLen := int(stringLen)
1128 if intStringLen < 0 {
1129 return ErrInvalidLengthGenerated
1130 }
1131 postIndex := iNdEx + intStringLen
1132 if postIndex < 0 {
1133 return ErrInvalidLengthGenerated
1134 }
1135 if postIndex > l {
1136 return io.ErrUnexpectedEOF
1137 }
1138 m.Message = string(dAtA[iNdEx:postIndex])
1139 iNdEx = postIndex
1140 default:
1141 iNdEx = preIndex
1142 skippy, err := skipGenerated(dAtA[iNdEx:])
1143 if err != nil {
1144 return err
1145 }
1146 if (skippy < 0) || (iNdEx+skippy) < 0 {
1147 return ErrInvalidLengthGenerated
1148 }
1149 if (iNdEx + skippy) > l {
1150 return io.ErrUnexpectedEOF
1151 }
1152 iNdEx += skippy
1153 }
1154 }
1155
1156 if iNdEx > l {
1157 return io.ErrUnexpectedEOF
1158 }
1159 return nil
1160 }
1161 func (m *ConfigList) Unmarshal(dAtA []byte) error {
1162 l := len(dAtA)
1163 iNdEx := 0
1164 for iNdEx < l {
1165 preIndex := iNdEx
1166 var wire uint64
1167 for shift := uint(0); ; shift += 7 {
1168 if shift >= 64 {
1169 return ErrIntOverflowGenerated
1170 }
1171 if iNdEx >= l {
1172 return io.ErrUnexpectedEOF
1173 }
1174 b := dAtA[iNdEx]
1175 iNdEx++
1176 wire |= uint64(b&0x7F) << shift
1177 if b < 0x80 {
1178 break
1179 }
1180 }
1181 fieldNum := int32(wire >> 3)
1182 wireType := int(wire & 0x7)
1183 if wireType == 4 {
1184 return fmt.Errorf("proto: ConfigList: wiretype end group for non-group")
1185 }
1186 if fieldNum <= 0 {
1187 return fmt.Errorf("proto: ConfigList: illegal tag %d (wire type %d)", fieldNum, wire)
1188 }
1189 switch fieldNum {
1190 case 1:
1191 if wireType != 2 {
1192 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1193 }
1194 var msglen int
1195 for shift := uint(0); ; shift += 7 {
1196 if shift >= 64 {
1197 return ErrIntOverflowGenerated
1198 }
1199 if iNdEx >= l {
1200 return io.ErrUnexpectedEOF
1201 }
1202 b := dAtA[iNdEx]
1203 iNdEx++
1204 msglen |= int(b&0x7F) << shift
1205 if b < 0x80 {
1206 break
1207 }
1208 }
1209 if msglen < 0 {
1210 return ErrInvalidLengthGenerated
1211 }
1212 postIndex := iNdEx + msglen
1213 if postIndex < 0 {
1214 return ErrInvalidLengthGenerated
1215 }
1216 if postIndex > l {
1217 return io.ErrUnexpectedEOF
1218 }
1219 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1220 return err
1221 }
1222 iNdEx = postIndex
1223 case 2:
1224 if wireType != 2 {
1225 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1226 }
1227 var msglen int
1228 for shift := uint(0); ; shift += 7 {
1229 if shift >= 64 {
1230 return ErrIntOverflowGenerated
1231 }
1232 if iNdEx >= l {
1233 return io.ErrUnexpectedEOF
1234 }
1235 b := dAtA[iNdEx]
1236 iNdEx++
1237 msglen |= int(b&0x7F) << shift
1238 if b < 0x80 {
1239 break
1240 }
1241 }
1242 if msglen < 0 {
1243 return ErrInvalidLengthGenerated
1244 }
1245 postIndex := iNdEx + msglen
1246 if postIndex < 0 {
1247 return ErrInvalidLengthGenerated
1248 }
1249 if postIndex > l {
1250 return io.ErrUnexpectedEOF
1251 }
1252 m.Items = append(m.Items, Config{})
1253 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1254 return err
1255 }
1256 iNdEx = postIndex
1257 default:
1258 iNdEx = preIndex
1259 skippy, err := skipGenerated(dAtA[iNdEx:])
1260 if err != nil {
1261 return err
1262 }
1263 if (skippy < 0) || (iNdEx+skippy) < 0 {
1264 return ErrInvalidLengthGenerated
1265 }
1266 if (iNdEx + skippy) > l {
1267 return io.ErrUnexpectedEOF
1268 }
1269 iNdEx += skippy
1270 }
1271 }
1272
1273 if iNdEx > l {
1274 return io.ErrUnexpectedEOF
1275 }
1276 return nil
1277 }
1278 func (m *ConfigSpec) Unmarshal(dAtA []byte) error {
1279 l := len(dAtA)
1280 iNdEx := 0
1281 for iNdEx < l {
1282 preIndex := iNdEx
1283 var wire uint64
1284 for shift := uint(0); ; shift += 7 {
1285 if shift >= 64 {
1286 return ErrIntOverflowGenerated
1287 }
1288 if iNdEx >= l {
1289 return io.ErrUnexpectedEOF
1290 }
1291 b := dAtA[iNdEx]
1292 iNdEx++
1293 wire |= uint64(b&0x7F) << shift
1294 if b < 0x80 {
1295 break
1296 }
1297 }
1298 fieldNum := int32(wire >> 3)
1299 wireType := int(wire & 0x7)
1300 if wireType == 4 {
1301 return fmt.Errorf("proto: ConfigSpec: wiretype end group for non-group")
1302 }
1303 if fieldNum <= 0 {
1304 return fmt.Errorf("proto: ConfigSpec: illegal tag %d (wire type %d)", fieldNum, wire)
1305 }
1306 switch fieldNum {
1307 case 1:
1308 if wireType != 2 {
1309 return fmt.Errorf("proto: wrong wireType = %d for field ManagementState", wireType)
1310 }
1311 var stringLen uint64
1312 for shift := uint(0); ; shift += 7 {
1313 if shift >= 64 {
1314 return ErrIntOverflowGenerated
1315 }
1316 if iNdEx >= l {
1317 return io.ErrUnexpectedEOF
1318 }
1319 b := dAtA[iNdEx]
1320 iNdEx++
1321 stringLen |= uint64(b&0x7F) << shift
1322 if b < 0x80 {
1323 break
1324 }
1325 }
1326 intStringLen := int(stringLen)
1327 if intStringLen < 0 {
1328 return ErrInvalidLengthGenerated
1329 }
1330 postIndex := iNdEx + intStringLen
1331 if postIndex < 0 {
1332 return ErrInvalidLengthGenerated
1333 }
1334 if postIndex > l {
1335 return io.ErrUnexpectedEOF
1336 }
1337 m.ManagementState = github_com_openshift_api_operator_v1.ManagementState(dAtA[iNdEx:postIndex])
1338 iNdEx = postIndex
1339 case 2:
1340 if wireType != 2 {
1341 return fmt.Errorf("proto: wrong wireType = %d for field SamplesRegistry", wireType)
1342 }
1343 var stringLen uint64
1344 for shift := uint(0); ; shift += 7 {
1345 if shift >= 64 {
1346 return ErrIntOverflowGenerated
1347 }
1348 if iNdEx >= l {
1349 return io.ErrUnexpectedEOF
1350 }
1351 b := dAtA[iNdEx]
1352 iNdEx++
1353 stringLen |= uint64(b&0x7F) << shift
1354 if b < 0x80 {
1355 break
1356 }
1357 }
1358 intStringLen := int(stringLen)
1359 if intStringLen < 0 {
1360 return ErrInvalidLengthGenerated
1361 }
1362 postIndex := iNdEx + intStringLen
1363 if postIndex < 0 {
1364 return ErrInvalidLengthGenerated
1365 }
1366 if postIndex > l {
1367 return io.ErrUnexpectedEOF
1368 }
1369 m.SamplesRegistry = string(dAtA[iNdEx:postIndex])
1370 iNdEx = postIndex
1371 case 4:
1372 if wireType != 2 {
1373 return fmt.Errorf("proto: wrong wireType = %d for field Architectures", wireType)
1374 }
1375 var stringLen uint64
1376 for shift := uint(0); ; shift += 7 {
1377 if shift >= 64 {
1378 return ErrIntOverflowGenerated
1379 }
1380 if iNdEx >= l {
1381 return io.ErrUnexpectedEOF
1382 }
1383 b := dAtA[iNdEx]
1384 iNdEx++
1385 stringLen |= uint64(b&0x7F) << shift
1386 if b < 0x80 {
1387 break
1388 }
1389 }
1390 intStringLen := int(stringLen)
1391 if intStringLen < 0 {
1392 return ErrInvalidLengthGenerated
1393 }
1394 postIndex := iNdEx + intStringLen
1395 if postIndex < 0 {
1396 return ErrInvalidLengthGenerated
1397 }
1398 if postIndex > l {
1399 return io.ErrUnexpectedEOF
1400 }
1401 m.Architectures = append(m.Architectures, string(dAtA[iNdEx:postIndex]))
1402 iNdEx = postIndex
1403 case 5:
1404 if wireType != 2 {
1405 return fmt.Errorf("proto: wrong wireType = %d for field SkippedImagestreams", wireType)
1406 }
1407 var stringLen uint64
1408 for shift := uint(0); ; shift += 7 {
1409 if shift >= 64 {
1410 return ErrIntOverflowGenerated
1411 }
1412 if iNdEx >= l {
1413 return io.ErrUnexpectedEOF
1414 }
1415 b := dAtA[iNdEx]
1416 iNdEx++
1417 stringLen |= uint64(b&0x7F) << shift
1418 if b < 0x80 {
1419 break
1420 }
1421 }
1422 intStringLen := int(stringLen)
1423 if intStringLen < 0 {
1424 return ErrInvalidLengthGenerated
1425 }
1426 postIndex := iNdEx + intStringLen
1427 if postIndex < 0 {
1428 return ErrInvalidLengthGenerated
1429 }
1430 if postIndex > l {
1431 return io.ErrUnexpectedEOF
1432 }
1433 m.SkippedImagestreams = append(m.SkippedImagestreams, string(dAtA[iNdEx:postIndex]))
1434 iNdEx = postIndex
1435 case 6:
1436 if wireType != 2 {
1437 return fmt.Errorf("proto: wrong wireType = %d for field SkippedTemplates", wireType)
1438 }
1439 var stringLen uint64
1440 for shift := uint(0); ; shift += 7 {
1441 if shift >= 64 {
1442 return ErrIntOverflowGenerated
1443 }
1444 if iNdEx >= l {
1445 return io.ErrUnexpectedEOF
1446 }
1447 b := dAtA[iNdEx]
1448 iNdEx++
1449 stringLen |= uint64(b&0x7F) << shift
1450 if b < 0x80 {
1451 break
1452 }
1453 }
1454 intStringLen := int(stringLen)
1455 if intStringLen < 0 {
1456 return ErrInvalidLengthGenerated
1457 }
1458 postIndex := iNdEx + intStringLen
1459 if postIndex < 0 {
1460 return ErrInvalidLengthGenerated
1461 }
1462 if postIndex > l {
1463 return io.ErrUnexpectedEOF
1464 }
1465 m.SkippedTemplates = append(m.SkippedTemplates, string(dAtA[iNdEx:postIndex]))
1466 iNdEx = postIndex
1467 default:
1468 iNdEx = preIndex
1469 skippy, err := skipGenerated(dAtA[iNdEx:])
1470 if err != nil {
1471 return err
1472 }
1473 if (skippy < 0) || (iNdEx+skippy) < 0 {
1474 return ErrInvalidLengthGenerated
1475 }
1476 if (iNdEx + skippy) > l {
1477 return io.ErrUnexpectedEOF
1478 }
1479 iNdEx += skippy
1480 }
1481 }
1482
1483 if iNdEx > l {
1484 return io.ErrUnexpectedEOF
1485 }
1486 return nil
1487 }
1488 func (m *ConfigStatus) Unmarshal(dAtA []byte) error {
1489 l := len(dAtA)
1490 iNdEx := 0
1491 for iNdEx < l {
1492 preIndex := iNdEx
1493 var wire uint64
1494 for shift := uint(0); ; shift += 7 {
1495 if shift >= 64 {
1496 return ErrIntOverflowGenerated
1497 }
1498 if iNdEx >= l {
1499 return io.ErrUnexpectedEOF
1500 }
1501 b := dAtA[iNdEx]
1502 iNdEx++
1503 wire |= uint64(b&0x7F) << shift
1504 if b < 0x80 {
1505 break
1506 }
1507 }
1508 fieldNum := int32(wire >> 3)
1509 wireType := int(wire & 0x7)
1510 if wireType == 4 {
1511 return fmt.Errorf("proto: ConfigStatus: wiretype end group for non-group")
1512 }
1513 if fieldNum <= 0 {
1514 return fmt.Errorf("proto: ConfigStatus: illegal tag %d (wire type %d)", fieldNum, wire)
1515 }
1516 switch fieldNum {
1517 case 1:
1518 if wireType != 2 {
1519 return fmt.Errorf("proto: wrong wireType = %d for field ManagementState", wireType)
1520 }
1521 var stringLen uint64
1522 for shift := uint(0); ; shift += 7 {
1523 if shift >= 64 {
1524 return ErrIntOverflowGenerated
1525 }
1526 if iNdEx >= l {
1527 return io.ErrUnexpectedEOF
1528 }
1529 b := dAtA[iNdEx]
1530 iNdEx++
1531 stringLen |= uint64(b&0x7F) << shift
1532 if b < 0x80 {
1533 break
1534 }
1535 }
1536 intStringLen := int(stringLen)
1537 if intStringLen < 0 {
1538 return ErrInvalidLengthGenerated
1539 }
1540 postIndex := iNdEx + intStringLen
1541 if postIndex < 0 {
1542 return ErrInvalidLengthGenerated
1543 }
1544 if postIndex > l {
1545 return io.ErrUnexpectedEOF
1546 }
1547 m.ManagementState = github_com_openshift_api_operator_v1.ManagementState(dAtA[iNdEx:postIndex])
1548 iNdEx = postIndex
1549 case 2:
1550 if wireType != 2 {
1551 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
1552 }
1553 var msglen int
1554 for shift := uint(0); ; shift += 7 {
1555 if shift >= 64 {
1556 return ErrIntOverflowGenerated
1557 }
1558 if iNdEx >= l {
1559 return io.ErrUnexpectedEOF
1560 }
1561 b := dAtA[iNdEx]
1562 iNdEx++
1563 msglen |= int(b&0x7F) << shift
1564 if b < 0x80 {
1565 break
1566 }
1567 }
1568 if msglen < 0 {
1569 return ErrInvalidLengthGenerated
1570 }
1571 postIndex := iNdEx + msglen
1572 if postIndex < 0 {
1573 return ErrInvalidLengthGenerated
1574 }
1575 if postIndex > l {
1576 return io.ErrUnexpectedEOF
1577 }
1578 m.Conditions = append(m.Conditions, ConfigCondition{})
1579 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1580 return err
1581 }
1582 iNdEx = postIndex
1583 case 3:
1584 if wireType != 2 {
1585 return fmt.Errorf("proto: wrong wireType = %d for field SamplesRegistry", wireType)
1586 }
1587 var stringLen uint64
1588 for shift := uint(0); ; shift += 7 {
1589 if shift >= 64 {
1590 return ErrIntOverflowGenerated
1591 }
1592 if iNdEx >= l {
1593 return io.ErrUnexpectedEOF
1594 }
1595 b := dAtA[iNdEx]
1596 iNdEx++
1597 stringLen |= uint64(b&0x7F) << shift
1598 if b < 0x80 {
1599 break
1600 }
1601 }
1602 intStringLen := int(stringLen)
1603 if intStringLen < 0 {
1604 return ErrInvalidLengthGenerated
1605 }
1606 postIndex := iNdEx + intStringLen
1607 if postIndex < 0 {
1608 return ErrInvalidLengthGenerated
1609 }
1610 if postIndex > l {
1611 return io.ErrUnexpectedEOF
1612 }
1613 m.SamplesRegistry = string(dAtA[iNdEx:postIndex])
1614 iNdEx = postIndex
1615 case 5:
1616 if wireType != 2 {
1617 return fmt.Errorf("proto: wrong wireType = %d for field Architectures", wireType)
1618 }
1619 var stringLen uint64
1620 for shift := uint(0); ; shift += 7 {
1621 if shift >= 64 {
1622 return ErrIntOverflowGenerated
1623 }
1624 if iNdEx >= l {
1625 return io.ErrUnexpectedEOF
1626 }
1627 b := dAtA[iNdEx]
1628 iNdEx++
1629 stringLen |= uint64(b&0x7F) << shift
1630 if b < 0x80 {
1631 break
1632 }
1633 }
1634 intStringLen := int(stringLen)
1635 if intStringLen < 0 {
1636 return ErrInvalidLengthGenerated
1637 }
1638 postIndex := iNdEx + intStringLen
1639 if postIndex < 0 {
1640 return ErrInvalidLengthGenerated
1641 }
1642 if postIndex > l {
1643 return io.ErrUnexpectedEOF
1644 }
1645 m.Architectures = append(m.Architectures, string(dAtA[iNdEx:postIndex]))
1646 iNdEx = postIndex
1647 case 6:
1648 if wireType != 2 {
1649 return fmt.Errorf("proto: wrong wireType = %d for field SkippedImagestreams", wireType)
1650 }
1651 var stringLen uint64
1652 for shift := uint(0); ; shift += 7 {
1653 if shift >= 64 {
1654 return ErrIntOverflowGenerated
1655 }
1656 if iNdEx >= l {
1657 return io.ErrUnexpectedEOF
1658 }
1659 b := dAtA[iNdEx]
1660 iNdEx++
1661 stringLen |= uint64(b&0x7F) << shift
1662 if b < 0x80 {
1663 break
1664 }
1665 }
1666 intStringLen := int(stringLen)
1667 if intStringLen < 0 {
1668 return ErrInvalidLengthGenerated
1669 }
1670 postIndex := iNdEx + intStringLen
1671 if postIndex < 0 {
1672 return ErrInvalidLengthGenerated
1673 }
1674 if postIndex > l {
1675 return io.ErrUnexpectedEOF
1676 }
1677 m.SkippedImagestreams = append(m.SkippedImagestreams, string(dAtA[iNdEx:postIndex]))
1678 iNdEx = postIndex
1679 case 7:
1680 if wireType != 2 {
1681 return fmt.Errorf("proto: wrong wireType = %d for field SkippedTemplates", wireType)
1682 }
1683 var stringLen uint64
1684 for shift := uint(0); ; shift += 7 {
1685 if shift >= 64 {
1686 return ErrIntOverflowGenerated
1687 }
1688 if iNdEx >= l {
1689 return io.ErrUnexpectedEOF
1690 }
1691 b := dAtA[iNdEx]
1692 iNdEx++
1693 stringLen |= uint64(b&0x7F) << shift
1694 if b < 0x80 {
1695 break
1696 }
1697 }
1698 intStringLen := int(stringLen)
1699 if intStringLen < 0 {
1700 return ErrInvalidLengthGenerated
1701 }
1702 postIndex := iNdEx + intStringLen
1703 if postIndex < 0 {
1704 return ErrInvalidLengthGenerated
1705 }
1706 if postIndex > l {
1707 return io.ErrUnexpectedEOF
1708 }
1709 m.SkippedTemplates = append(m.SkippedTemplates, string(dAtA[iNdEx:postIndex]))
1710 iNdEx = postIndex
1711 case 8:
1712 if wireType != 2 {
1713 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
1714 }
1715 var stringLen uint64
1716 for shift := uint(0); ; shift += 7 {
1717 if shift >= 64 {
1718 return ErrIntOverflowGenerated
1719 }
1720 if iNdEx >= l {
1721 return io.ErrUnexpectedEOF
1722 }
1723 b := dAtA[iNdEx]
1724 iNdEx++
1725 stringLen |= uint64(b&0x7F) << shift
1726 if b < 0x80 {
1727 break
1728 }
1729 }
1730 intStringLen := int(stringLen)
1731 if intStringLen < 0 {
1732 return ErrInvalidLengthGenerated
1733 }
1734 postIndex := iNdEx + intStringLen
1735 if postIndex < 0 {
1736 return ErrInvalidLengthGenerated
1737 }
1738 if postIndex > l {
1739 return io.ErrUnexpectedEOF
1740 }
1741 m.Version = string(dAtA[iNdEx:postIndex])
1742 iNdEx = postIndex
1743 default:
1744 iNdEx = preIndex
1745 skippy, err := skipGenerated(dAtA[iNdEx:])
1746 if err != nil {
1747 return err
1748 }
1749 if (skippy < 0) || (iNdEx+skippy) < 0 {
1750 return ErrInvalidLengthGenerated
1751 }
1752 if (iNdEx + skippy) > l {
1753 return io.ErrUnexpectedEOF
1754 }
1755 iNdEx += skippy
1756 }
1757 }
1758
1759 if iNdEx > l {
1760 return io.ErrUnexpectedEOF
1761 }
1762 return nil
1763 }
1764 func skipGenerated(dAtA []byte) (n int, err error) {
1765 l := len(dAtA)
1766 iNdEx := 0
1767 depth := 0
1768 for iNdEx < l {
1769 var wire uint64
1770 for shift := uint(0); ; shift += 7 {
1771 if shift >= 64 {
1772 return 0, ErrIntOverflowGenerated
1773 }
1774 if iNdEx >= l {
1775 return 0, io.ErrUnexpectedEOF
1776 }
1777 b := dAtA[iNdEx]
1778 iNdEx++
1779 wire |= (uint64(b) & 0x7F) << shift
1780 if b < 0x80 {
1781 break
1782 }
1783 }
1784 wireType := int(wire & 0x7)
1785 switch wireType {
1786 case 0:
1787 for shift := uint(0); ; shift += 7 {
1788 if shift >= 64 {
1789 return 0, ErrIntOverflowGenerated
1790 }
1791 if iNdEx >= l {
1792 return 0, io.ErrUnexpectedEOF
1793 }
1794 iNdEx++
1795 if dAtA[iNdEx-1] < 0x80 {
1796 break
1797 }
1798 }
1799 case 1:
1800 iNdEx += 8
1801 case 2:
1802 var length int
1803 for shift := uint(0); ; shift += 7 {
1804 if shift >= 64 {
1805 return 0, ErrIntOverflowGenerated
1806 }
1807 if iNdEx >= l {
1808 return 0, io.ErrUnexpectedEOF
1809 }
1810 b := dAtA[iNdEx]
1811 iNdEx++
1812 length |= (int(b) & 0x7F) << shift
1813 if b < 0x80 {
1814 break
1815 }
1816 }
1817 if length < 0 {
1818 return 0, ErrInvalidLengthGenerated
1819 }
1820 iNdEx += length
1821 case 3:
1822 depth++
1823 case 4:
1824 if depth == 0 {
1825 return 0, ErrUnexpectedEndOfGroupGenerated
1826 }
1827 depth--
1828 case 5:
1829 iNdEx += 4
1830 default:
1831 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1832 }
1833 if iNdEx < 0 {
1834 return 0, ErrInvalidLengthGenerated
1835 }
1836 if depth == 0 {
1837 return iNdEx, nil
1838 }
1839 }
1840 return 0, io.ErrUnexpectedEOF
1841 }
1842
1843 var (
1844 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
1845 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
1846 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
1847 )
1848
View as plain text