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