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