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