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