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