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