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