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