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