Terraria v1.4.4.9
Terraria source code documentation
Loading...
Searching...
No Matches
Base64Encoding.cs
Go to the documentation of this file.
1using System.Runtime.Serialization;
2
3namespace System.Text;
4
5internal sealed class Base64Encoding : Encoding
6{
7 private const string Val2Char = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
8
9 private static ReadOnlySpan<byte> Char2val => new byte[128]
10 {
11 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
12 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
13 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
14 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
15 255, 255, 255, 62, 255, 255, 255, 63, 52, 53,
16 54, 55, 56, 57, 58, 59, 60, 61, 255, 255,
17 255, 64, 255, 255, 255, 0, 1, 2, 3, 4,
18 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
19 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
20 25, 255, 255, 255, 255, 255, 255, 26, 27, 28,
21 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
22 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
23 49, 50, 51, 255, 255, 255, 255, 255
24 };
25
26 private static ReadOnlySpan<byte> Val2byte => "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"u8;
27
28 public override int GetMaxByteCount(int charCount)
29 {
30 if (charCount < 0)
31 {
32 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charCount", System.SR.ValueMustBeNonNegative));
33 }
34 if (charCount % 4 != 0)
35 {
36 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(System.SR.Format(System.SR.XmlInvalidBase64Length, charCount.ToString())));
37 }
38 return charCount / 4 * 3;
39 }
40
41 private bool IsValidLeadBytes(int v1, int v2, int v3, int v4)
42 {
43 if ((v1 | v2) < 64)
44 {
45 return (v3 | v4) != 255;
46 }
47 return false;
48 }
49
50 private bool IsValidTailBytes(int v3, int v4)
51 {
52 if (v3 == 64)
53 {
54 return v4 == 64;
55 }
56 return true;
57 }
58
59 public unsafe override int GetByteCount(char[] chars, int index, int count)
60 {
61 if (chars == null)
62 {
63 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("chars"));
64 }
65 if (index < 0)
66 {
67 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("index", System.SR.ValueMustBeNonNegative));
68 }
69 if (index > chars.Length)
70 {
71 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("index", System.SR.Format(System.SR.OffsetExceedsBufferSize, chars.Length)));
72 }
73 if (count < 0)
74 {
75 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", System.SR.ValueMustBeNonNegative));
76 }
77 if (count > chars.Length - index)
78 {
79 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", System.SR.Format(System.SR.SizeExceedsRemainingBufferSpace, chars.Length - index)));
80 }
81 if (count == 0)
82 {
83 return 0;
84 }
85 if (count % 4 != 0)
86 {
87 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(System.SR.Format(System.SR.XmlInvalidBase64Length, count.ToString())));
88 }
89 fixed (byte* ptr4 = &Char2val[0])
90 {
91 fixed (char* ptr = &chars[index])
92 {
93 int num = 0;
94 char* ptr2 = ptr;
95 for (char* ptr3 = ptr + count; ptr2 < ptr3; ptr2 += 4)
96 {
97 char c = *ptr2;
98 char c2 = ptr2[1];
99 char c3 = ptr2[2];
100 char c4 = ptr2[3];
101 if ((c | c2 | c3 | c4) >= 128)
102 {
103 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(System.SR.Format(System.SR.XmlInvalidBase64Sequence, new string(ptr2, 0, 4), index + (int)(ptr2 - ptr))));
104 }
105 int v = ptr4[(int)c];
106 int v2 = ptr4[(int)c2];
107 int num2 = ptr4[(int)c3];
108 int num3 = ptr4[(int)c4];
109 if (!IsValidLeadBytes(v, v2, num2, num3) || !IsValidTailBytes(num2, num3))
110 {
111 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(System.SR.Format(System.SR.XmlInvalidBase64Sequence, new string(ptr2, 0, 4), index + (int)(ptr2 - ptr))));
112 }
113 int num4 = ((num3 != 64) ? 3 : ((num2 == 64) ? 1 : 2));
114 num += num4;
115 }
116 return num;
117 }
118 }
119 }
120
121 public unsafe override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
122 {
123 if (chars == null)
124 {
125 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("chars"));
126 }
127 if (charIndex < 0)
128 {
129 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charIndex", System.SR.ValueMustBeNonNegative));
130 }
131 if (charIndex > chars.Length)
132 {
133 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charIndex", System.SR.Format(System.SR.OffsetExceedsBufferSize, chars.Length)));
134 }
135 if (charCount < 0)
136 {
137 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charCount", System.SR.ValueMustBeNonNegative));
138 }
139 if (charCount > chars.Length - charIndex)
140 {
141 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charCount", System.SR.Format(System.SR.SizeExceedsRemainingBufferSpace, chars.Length - charIndex)));
142 }
143 if (bytes == null)
144 {
145 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("bytes"));
146 }
147 if (byteIndex < 0)
148 {
149 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteIndex", System.SR.ValueMustBeNonNegative));
150 }
151 if (byteIndex > bytes.Length)
152 {
153 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteIndex", System.SR.Format(System.SR.OffsetExceedsBufferSize, bytes.Length)));
154 }
155 if (charCount == 0)
156 {
157 return 0;
158 }
159 if (charCount % 4 != 0)
160 {
161 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(System.SR.Format(System.SR.XmlInvalidBase64Length, charCount.ToString())));
162 }
163 fixed (byte* ptr7 = &Char2val[0])
164 {
165 fixed (char* ptr = &chars[charIndex])
166 {
167 fixed (byte* ptr4 = &bytes[byteIndex])
168 {
169 char* ptr2 = ptr;
170 char* ptr3 = ptr + charCount;
171 byte* ptr5 = ptr4;
172 byte* ptr6 = ptr4 + bytes.Length - byteIndex;
173 for (; ptr2 < ptr3; ptr2 += 4)
174 {
175 char c = *ptr2;
176 char c2 = ptr2[1];
177 char c3 = ptr2[2];
178 char c4 = ptr2[3];
179 if ((c | c2 | c3 | c4) >= 128)
180 {
181 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(System.SR.Format(System.SR.XmlInvalidBase64Sequence, new string(ptr2, 0, 4), charIndex + (int)(ptr2 - ptr))));
182 }
183 int num = ptr7[(int)c];
184 int num2 = ptr7[(int)c2];
185 int num3 = ptr7[(int)c3];
186 int num4 = ptr7[(int)c4];
187 if (!IsValidLeadBytes(num, num2, num3, num4) || !IsValidTailBytes(num3, num4))
188 {
189 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(System.SR.Format(System.SR.XmlInvalidBase64Sequence, new string(ptr2, 0, 4), charIndex + (int)(ptr2 - ptr))));
190 }
191 int num5 = ((num4 != 64) ? 3 : ((num3 == 64) ? 1 : 2));
192 if (ptr5 + num5 > ptr6)
193 {
194 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.SR.XmlArrayTooSmall, "bytes"));
195 }
196 *ptr5 = (byte)((uint)(num << 2) | ((uint)(num2 >> 4) & 3u));
197 if (num5 > 1)
198 {
199 ptr5[1] = (byte)((uint)(num2 << 4) | ((uint)(num3 >> 2) & 0xFu));
200 if (num5 > 2)
201 {
202 ptr5[2] = (byte)((uint)(num3 << 6) | ((uint)num4 & 0x3Fu));
203 }
204 }
205 ptr5 += num5;
206 }
207 return (int)(ptr5 - ptr4);
208 }
209 }
210 }
211 }
212
213 public unsafe int GetBytes(byte[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
214 {
215 if (chars == null)
216 {
217 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("chars"));
218 }
219 if (charIndex < 0)
220 {
221 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charIndex", System.SR.ValueMustBeNonNegative));
222 }
223 if (charIndex > chars.Length)
224 {
225 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charIndex", System.SR.Format(System.SR.OffsetExceedsBufferSize, chars.Length)));
226 }
227 if (charCount < 0)
228 {
229 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charCount", System.SR.ValueMustBeNonNegative));
230 }
231 if (charCount > chars.Length - charIndex)
232 {
233 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charCount", System.SR.Format(System.SR.SizeExceedsRemainingBufferSpace, chars.Length - charIndex)));
234 }
235 if (bytes == null)
236 {
237 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("bytes"));
238 }
239 if (byteIndex < 0)
240 {
241 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteIndex", System.SR.ValueMustBeNonNegative));
242 }
243 if (byteIndex > bytes.Length)
244 {
245 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteIndex", System.SR.Format(System.SR.OffsetExceedsBufferSize, bytes.Length)));
246 }
247 if (charCount == 0)
248 {
249 return 0;
250 }
251 if (charCount % 4 != 0)
252 {
253 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(System.SR.Format(System.SR.XmlInvalidBase64Length, charCount.ToString())));
254 }
255 fixed (byte* ptr7 = &Char2val[0])
256 {
257 fixed (byte* ptr = &chars[charIndex])
258 {
259 fixed (byte* ptr4 = &bytes[byteIndex])
260 {
261 byte* ptr2 = ptr;
262 byte* ptr3 = ptr + charCount;
263 byte* ptr5 = ptr4;
264 byte* ptr6 = ptr4 + bytes.Length - byteIndex;
265 for (; ptr2 < ptr3; ptr2 += 4)
266 {
267 byte b = *ptr2;
268 byte b2 = ptr2[1];
269 byte b3 = ptr2[2];
270 byte b4 = ptr2[3];
271 if ((b | b2 | b3 | b4) >= 128)
272 {
273 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(System.SR.Format(System.SR.XmlInvalidBase64Sequence, "?", charIndex + (int)(ptr2 - ptr))));
274 }
275 int num = ptr7[(int)b];
276 int num2 = ptr7[(int)b2];
277 int num3 = ptr7[(int)b3];
278 int num4 = ptr7[(int)b4];
279 if (!IsValidLeadBytes(num, num2, num3, num4) || !IsValidTailBytes(num3, num4))
280 {
281 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(System.SR.Format(System.SR.XmlInvalidBase64Sequence, "?", charIndex + (int)(ptr2 - ptr))));
282 }
283 int num5 = ((num4 != 64) ? 3 : ((num3 == 64) ? 1 : 2));
284 if (ptr5 + num5 > ptr6)
285 {
286 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.SR.XmlArrayTooSmall, "bytes"));
287 }
288 *ptr5 = (byte)((uint)(num << 2) | ((uint)(num2 >> 4) & 3u));
289 if (num5 > 1)
290 {
291 ptr5[1] = (byte)((uint)(num2 << 4) | ((uint)(num3 >> 2) & 0xFu));
292 if (num5 > 2)
293 {
294 ptr5[2] = (byte)((uint)(num3 << 6) | ((uint)num4 & 0x3Fu));
295 }
296 }
297 ptr5 += num5;
298 }
299 return (int)(ptr5 - ptr4);
300 }
301 }
302 }
303 }
304
305 public override int GetMaxCharCount(int byteCount)
306 {
307 if (byteCount < 0 || byteCount > 1610612731)
308 {
309 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteCount", System.SR.Format(System.SR.ValueMustBeInRange, 0, 1610612731)));
310 }
311 return (byteCount + 2) / 3 * 4;
312 }
313
314 public override int GetCharCount(byte[] bytes, int index, int count)
315 {
316 return GetMaxCharCount(count);
317 }
318
319 public unsafe override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
320 {
321 if (bytes == null)
322 {
323 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("bytes"));
324 }
325 if (byteIndex < 0)
326 {
327 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteIndex", System.SR.ValueMustBeNonNegative));
328 }
329 if (byteIndex > bytes.Length)
330 {
331 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteIndex", System.SR.Format(System.SR.OffsetExceedsBufferSize, bytes.Length)));
332 }
333 if (byteCount < 0)
334 {
335 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteCount", System.SR.ValueMustBeNonNegative));
336 }
337 if (byteCount > bytes.Length - byteIndex)
338 {
339 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteCount", System.SR.Format(System.SR.SizeExceedsRemainingBufferSpace, bytes.Length - byteIndex)));
340 }
341 int charCount = GetCharCount(bytes, byteIndex, byteCount);
342 if (chars == null)
343 {
344 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("chars"));
345 }
346 if (charIndex < 0)
347 {
348 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charIndex", System.SR.ValueMustBeNonNegative));
349 }
350 if (charIndex > chars.Length)
351 {
352 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charIndex", System.SR.Format(System.SR.OffsetExceedsBufferSize, chars.Length)));
353 }
354 if (charCount < 0 || charCount > chars.Length - charIndex)
355 {
356 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.SR.XmlArrayTooSmall, "chars"));
357 }
358 if (byteCount > 0)
359 {
360 fixed (char* ptr6 = &"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".GetPinnableReference())
361 {
362 fixed (byte* ptr = &bytes[byteIndex])
363 {
364 fixed (char* ptr4 = &chars[charIndex])
365 {
366 byte* ptr2 = ptr;
367 byte* ptr3 = ptr2 + byteCount - 3;
368 char* ptr5 = ptr4;
369 while (ptr2 <= ptr3)
370 {
371 *ptr5 = ptr6[*ptr2 >> 2];
372 ptr5[1] = ptr6[((*ptr2 & 3) << 4) | (ptr2[1] >> 4)];
373 ptr5[2] = ptr6[((ptr2[1] & 0xF) << 2) | (ptr2[2] >> 6)];
374 ptr5[3] = ptr6[ptr2[2] & 0x3F];
375 ptr2 += 3;
376 ptr5 += 4;
377 }
378 if (ptr2 - ptr3 == 2)
379 {
380 *ptr5 = ptr6[*ptr2 >> 2];
381 ptr5[1] = ptr6[(*ptr2 & 3) << 4];
382 ptr5[2] = '=';
383 ptr5[3] = '=';
384 }
385 else if (ptr2 - ptr3 == 1)
386 {
387 *ptr5 = ptr6[*ptr2 >> 2];
388 ptr5[1] = ptr6[((*ptr2 & 3) << 4) | (ptr2[1] >> 4)];
389 ptr5[2] = ptr6[(ptr2[1] & 0xF) << 2];
390 ptr5[3] = '=';
391 }
392 }
393 }
394 }
395 }
396 return charCount;
397 }
398
399 public unsafe int GetChars(byte[] bytes, int byteIndex, int byteCount, byte[] chars, int charIndex)
400 {
401 if (bytes == null)
402 {
403 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("bytes"));
404 }
405 if (byteIndex < 0)
406 {
407 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteIndex", System.SR.ValueMustBeNonNegative));
408 }
409 if (byteIndex > bytes.Length)
410 {
411 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteIndex", System.SR.Format(System.SR.OffsetExceedsBufferSize, bytes.Length)));
412 }
413 if (byteCount < 0)
414 {
415 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteCount", System.SR.ValueMustBeNonNegative));
416 }
417 if (byteCount > bytes.Length - byteIndex)
418 {
419 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("byteCount", System.SR.Format(System.SR.SizeExceedsRemainingBufferSpace, bytes.Length - byteIndex)));
420 }
421 int charCount = GetCharCount(bytes, byteIndex, byteCount);
422 if (chars == null)
423 {
424 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("chars"));
425 }
426 if (charIndex < 0)
427 {
428 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charIndex", System.SR.ValueMustBeNonNegative));
429 }
430 if (charIndex > chars.Length)
431 {
432 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("charIndex", System.SR.Format(System.SR.OffsetExceedsBufferSize, chars.Length)));
433 }
434 if (charCount < 0 || charCount > chars.Length - charIndex)
435 {
436 throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.SR.XmlArrayTooSmall, "chars"));
437 }
438 if (byteCount > 0)
439 {
440 fixed (byte* ptr6 = &Val2byte[0])
441 {
442 fixed (byte* ptr = &bytes[byteIndex])
443 {
444 fixed (byte* ptr4 = &chars[charIndex])
445 {
446 byte* ptr2 = ptr;
447 byte* ptr3 = ptr2 + byteCount - 3;
448 byte* ptr5 = ptr4;
449 while (ptr2 <= ptr3)
450 {
451 *ptr5 = ptr6[*ptr2 >> 2];
452 ptr5[1] = ptr6[((*ptr2 & 3) << 4) | (ptr2[1] >> 4)];
453 ptr5[2] = ptr6[((ptr2[1] & 0xF) << 2) | (ptr2[2] >> 6)];
454 ptr5[3] = ptr6[ptr2[2] & 0x3F];
455 ptr2 += 3;
456 ptr5 += 4;
457 }
458 if (ptr2 - ptr3 == 2)
459 {
460 *ptr5 = ptr6[*ptr2 >> 2];
461 ptr5[1] = ptr6[(*ptr2 & 3) << 4];
462 ptr5[2] = 61;
463 ptr5[3] = 61;
464 }
465 else if (ptr2 - ptr3 == 1)
466 {
467 *ptr5 = ptr6[*ptr2 >> 2];
468 ptr5[1] = ptr6[((*ptr2 & 3) << 4) | (ptr2[1] >> 4)];
469 ptr5[2] = ptr6[(ptr2[1] & 0xF) << 2];
470 ptr5[3] = 61;
471 }
472 }
473 }
474 }
475 }
476 return charCount;
477 }
478}
System.SR.XmlInvalidBase64Sequence
static string XmlInvalidBase64Sequence
Definition SR.cs:334
System.SR.XmlInvalidBase64Length
static string XmlInvalidBase64Length
Definition SR.cs:332
System.SR.ValueMustBeInRange
static string ValueMustBeInRange
Definition SR.cs:326
System.SR.Format
static string Format(string resourceFormat, object p1)
Definition SR.cs:118
System.SR.ValueMustBeNonNegative
static string ValueMustBeNonNegative
Definition SR.cs:296
System.SR.SizeExceedsRemainingBufferSpace
static string SizeExceedsRemainingBufferSpace
Definition SR.cs:324
System.SR.OffsetExceedsBufferSize
static string OffsetExceedsBufferSize
Definition SR.cs:322
System.SR.XmlArrayTooSmall
static string XmlArrayTooSmall
Definition SR.cs:348
System.SR
Definition SR.cs:7
System.Text.Base64Encoding.IsValidTailBytes
bool IsValidTailBytes(int v3, int v4)
Definition Base64Encoding.cs:50
System.Text.Base64Encoding.GetMaxCharCount
override int GetMaxCharCount(int byteCount)
Definition Base64Encoding.cs:305
System.Text.Base64Encoding.GetBytes
unsafe int GetBytes(byte[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
Definition Base64Encoding.cs:213
System.Text.Base64Encoding.GetMaxByteCount
override int GetMaxByteCount(int charCount)
Definition Base64Encoding.cs:28
System.Text.Base64Encoding.Char2val
static ReadOnlySpan< byte > Char2val
Definition Base64Encoding.cs:9
System.Text.Base64Encoding.GetCharCount
override int GetCharCount(byte[] bytes, int index, int count)
Definition Base64Encoding.cs:314
System.Text.Base64Encoding.GetChars
unsafe int GetChars(byte[] bytes, int byteIndex, int byteCount, byte[] chars, int charIndex)
Definition Base64Encoding.cs:399
System.Text.Base64Encoding.GetChars
unsafe override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
Definition Base64Encoding.cs:319
System.Text.Base64Encoding.GetBytes
unsafe override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
Definition Base64Encoding.cs:121
System.Text.Base64Encoding.GetByteCount
unsafe override int GetByteCount(char[] chars, int index, int count)
Definition Base64Encoding.cs:59
System.Text.Base64Encoding.IsValidLeadBytes
bool IsValidLeadBytes(int v1, int v2, int v3, int v4)
Definition Base64Encoding.cs:41
System.Text.Base64Encoding.Val2byte
static ReadOnlySpan< byte > Val2byte
Definition Base64Encoding.cs:26