< Summary

Information
Class: System.Buffers.Text.Base64Url
Assembly: System.Private.CoreLib
File(s): File 1: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Url/Base64UrlDecoder.cs
File 2: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Url/Base64UrlEncoder.cs
File 3: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Url/Base64UrlValidator.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 298
Coverable lines: 298
Total lines: 1080
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 72
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
File 1: GetMaxDecodedLength(...)0%220%
File 1: DecodeFromUtf8(...)100%110%
File 1: DecodeFromUtf8InPlace(...)0%220%
File 1: DecodeFromUtf8(...)0%440%
File 1: TryDecodeFromUtf8(...)0%440%
File 1: DecodeFromUtf8(...)0%880%
File 1: DecodeFromChars(...)100%110%
File 1: DecodeFromChars(...)0%440%
File 1: TryDecodeFromChars(...)0%220%
File 1: DecodeFromChars(...)0%660%
File 1: GetMaxDecodedLength(...)100%110%
File 1: IsInvalidLength(...)100%110%
File 1: IsValidPadding(...)0%220%
File 1: SrcLength(...)0%220%
File 1: TryDecode128Core(...)0%220%
File 1: TryDecode256Core(...)0%220%
File 1: TryLoadVector512(...)100%110%
File 1: TryLoadAvxVector256(...)100%110%
File 1: TryLoadVector128(...)100%110%
File 1: TryLoadArmVector128x4(...)100%110%
File 1: DecodeFourElements(...)100%110%
File 1: DecodeRemaining(...)100%110%
File 1: IndexOfAnyExceptWhiteSpace(...)100%110%
File 1: DecodeWithWhiteSpaceBlockwiseWrapper(...)100%110%
File 1: GetMaxDecodedLength(...)100%110%
File 1: IsInvalidLength(...)100%110%
File 1: IsValidPadding(...)100%110%
File 1: SrcLength(...)100%110%
File 1: TryDecode128Core(...)100%110%
File 1: TryDecode256Core(...)100%110%
File 1: TryLoadVector512(...)100%110%
File 1: TryLoadAvxVector256(...)100%110%
File 1: TryLoadVector128(...)100%110%
File 1: TryLoadArmVector128x4(...)100%110%
File 1: DecodeFourElements(...)100%110%
File 1: DecodeRemaining(...)100%110%
File 1: IndexOfAnyExceptWhiteSpace(...)100%110%
File 1: DecodeWithWhiteSpaceBlockwiseWrapper(...)100%110%
File 2: EncodeToUtf8(...)100%110%
File 2: GetEncodedLength(...)0%220%
File 2: EncodeToUtf8(...)0%220%
File 2: EncodeToUtf8(...)100%110%
File 2: EncodeToChars(...)100%110%
File 2: EncodeToChars(...)0%220%
File 2: EncodeToChars(...)100%110%
File 2: EncodeToString(...)0%220%
File 2: TryEncodeToChars(...)100%110%
File 2: TryEncodeToUtf8(...)100%110%
File 2: TryEncodeToUtf8InPlace(...)100%110%
File 2: GetMaxSrcLength(...)0%440%
File 2: GetInPlaceDestinationLength(...)0%220%
File 2: GetMaxEncodedLength(...)100%110%
File 2: EncodeOneOptionallyPadTwo(...)100%110%
File 2: EncodeTwoOptionallyPadOne(...)100%110%
File 2: StoreVector512ToDestination(...)100%110%
File 2: StoreVector256ToDestination(...)100%110%
File 2: StoreVector128ToDestination(...)100%110%
File 2: StoreArmVector128x4ToDestination(...)100%110%
File 2: EncodeThreeAndWrite(...)100%110%
File 2: GetMaxSrcLength(...)100%110%
File 2: GetInPlaceDestinationLength(...)100%110%
File 2: GetMaxEncodedLength(...)100%110%
File 2: EncodeOneOptionallyPadTwo(...)100%110%
File 2: EncodeTwoOptionallyPadOne(...)100%110%
File 2: StoreVector512ToDestination(...)100%110%
File 2: StoreVector256ToDestination(...)100%110%
File 2: StoreVector128ToDestination(...)100%110%
File 2: StoreArmVector128x4ToDestination(...)100%110%
File 2: EncodeThreeAndWrite(...)100%110%
File 3: IsValid(...)100%110%
File 3: IsValid(...)100%110%
File 3: IsValid(...)100%110%
File 3: IsValid(...)100%110%
File 3: .cctor()100%110%
File 3: IndexOfAnyExcept(...)100%110%
File 3: IsWhiteSpace(...)100%110%
File 3: IsEncodingPad(...)0%220%
File 3: ValidateAndDecodeLength(...)100%110%
File 3: .cctor()100%110%
File 3: IndexOfAnyExcept(...)100%110%
File 3: IsWhiteSpace(...)100%110%
File 3: IsEncodingPad(...)0%220%
File 3: ValidateAndDecodeLength(...)0%14140%

File(s)

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Url/Base64UrlDecoder.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Diagnostics;
 5using System.Diagnostics.CodeAnalysis;
 6using System.Runtime.CompilerServices;
 7using System.Runtime.InteropServices;
 8#if NET
 9using System.Runtime.Intrinsics;
 10using System.Runtime.Intrinsics.Arm;
 11using System.Runtime.Intrinsics.X86;
 12#endif
 13using static System.Buffers.Text.Base64Helper;
 14
 15namespace System.Buffers.Text
 16{
 17    // AVX2 and Vector128 version based on https://github.com/gfoidl/Base64/blob/5383320e28cac6c7ac6f86502fb05d23a048a21
 18#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105974
 19    public static partial class Base64Url
 20#pragma warning restore 1591
 21    {
 22        private const int MaxStackallocThreshold = 256;
 23
 24        /// <summary>
 25        /// Returns the maximum length (in bytes) of the result if you were to decode Base64Url-encoded text from a span
 26        /// </summary>
 27        /// <exception cref="ArgumentOutOfRangeException">The specified <paramref name="base64Length"/> is less than 0.
 28        /// </exception>
 29        public static int GetMaxDecodedLength(int base64Length)
 30        {
 31#if NET
 032            ArgumentOutOfRangeException.ThrowIfNegative(base64Length);
 33
 034            (uint whole, uint remainder) = uint.DivRem((uint)base64Length, 4);
 35
 036            return (int)(whole * 3 + (remainder > 0 ? remainder - 1 : 0));
 37#else
 38            if (base64Length < 0)
 39            {
 40                throw new ArgumentOutOfRangeException(nameof(base64Length));
 41            }
 42
 43            int remainder = (int)((uint)base64Length % 4);
 44
 45            return (base64Length >> 2) * 3 + (remainder > 0 ? remainder - 1 : 0);
 46#endif
 47        }
 48
 49        /// <summary>
 50        /// Decodes the span of UTF-8 encoded text represented as Base64Url into binary data.
 51        /// </summary>
 52        /// <param name="source">The input span which contains UTF-8 encoded text in Base64Url that needs to be decoded.
 53        /// <param name="destination">The output span which contains the result of the operation, i.e. the decoded binar
 54        /// <param name="bytesConsumed">When this method returns, contains the number of input bytes consumed during the
 55        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the output sp
 56        /// <param name="isFinalBlock"><see langword="true"/> when the input span contains the entirety of data to decod
 57        /// such as when calling in a loop. Calls with <see langword="false"/> should be followed up with another call w
 58        /// <returns>One of the enumeration values that indicates the success or failure of the operation.</returns>
 59        /// <remarks>
 60        /// As padding is optional for Base64Url the <paramref name="source"/> length not required to be a multiple of 4
 61        /// If the <paramref name="source"/> length is not a multiple of 4 and <paramref name="isFinalBlock"/> is <see l
 62        /// - Remainder of 3 bytes - decoded into 2 bytes data, decoding succeeds.
 63        /// - Remainder of 2 bytes - decoded into 1 byte data. decoding succeeds.
 64        /// - Remainder of 1 byte - will cause OperationStatus.InvalidData result.
 65        /// </remarks>
 66        public static OperationStatus DecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesCon
 067            DecodeFrom(default(Base64UrlDecoderByte), source, destination, out bytesConsumed, out bytesWritten, isFinalB
 68
 69        /// <summary>
 70        /// Decodes the span of UTF-8 encoded text in Base64Url into binary data, in-place.
 71        /// The decoded binary output is smaller than the text data contained in the input (the operation deflates the d
 72        /// </summary>
 73        /// <param name="buffer">The input span which contains the Base64Url text data that needs to be decoded.</param>
 74        /// <returns>The number of bytes written into <paramref name="buffer"/>. This can be used to slice the output fo
 75        /// <exception cref="FormatException"><paramref name="buffer"/> contains an invalid Base64Url character,
 76        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 77        /// <remarks>
 78        /// As padding is optional for Base64Url the <paramref name="buffer"/> length not required to be a multiple of 4
 79        /// If the <paramref name="buffer"/> length is not a multiple of 4 the remainders decoded accordingly:
 80        /// - Remainder of 3 bytes - decoded into 2 bytes data, decoding succeeds.
 81        /// - Remainder of 2 bytes - decoded into 1 byte data. decoding succeeds.
 82        /// - Remainder of 1 byte - is invalid input, causes FormatException.
 83        /// </remarks>
 84        public static int DecodeFromUtf8InPlace(Span<byte> buffer)
 85        {
 086            OperationStatus status = DecodeFromUtf8InPlace<Base64UrlDecoderByte>(default, buffer, out int bytesWritten, 
 87
 88            // Base64.DecodeFromUtf8InPlace returns OperationStatus, therefore doesn't throw.
 89            // For Base64Url, this is not an OperationStatus API and thus throws.
 090            if (status == OperationStatus.InvalidData)
 91            {
 092                throw new FormatException(SR.Format_BadBase64Char);
 93            }
 94
 095            Debug.Assert(status is OperationStatus.Done);
 096            return bytesWritten;
 97        }
 98
 99        /// <summary>
 100        /// Decodes the span of UTF-8 encoded text represented as Base64Url into binary data.
 101        /// </summary>
 102        /// <param name="source">The input span which contains UTF-8 encoded text in Base64Url that needs to be decoded.
 103        /// <param name="destination">The output span which contains the result of the operation, i.e. the decoded binar
 104        /// <returns>The number of bytes written into <paramref name="destination"/>. This can be used to slice the outp
 105        /// <exception cref="ArgumentException">The buffer in <paramref name="destination"/> is too small to hold the de
 106        /// <exception cref="FormatException"><paramref name="source"/> contains an invalid Base64Url character,
 107        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 108        /// <remarks>
 109        /// As padding is optional for Base64Url the <paramref name="source"/> length not required to be a multiple of 4
 110        /// If the <paramref name="source"/> length is not a multiple of 4 the remainders decoded accordingly:
 111        /// - Remainder of 3 bytes - decoded into 2 bytes data, decoding succeeds.
 112        /// - Remainder of 2 bytes - decoded into 1 byte data. decoding succeeds.
 113        /// - Remainder of 1 byte - is invalid input, causes FormatException.
 114        /// </remarks>
 115        public static int DecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination)
 116        {
 0117            OperationStatus status = DecodeFromUtf8(source, destination, out _, out int bytesWritten);
 118
 0119            if (status == OperationStatus.Done)
 120            {
 0121                return bytesWritten;
 122            }
 123
 0124            if (status == OperationStatus.DestinationTooSmall)
 125            {
 0126                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
 127            }
 128
 0129            Debug.Assert(status is OperationStatus.InvalidData);
 0130            throw new FormatException(SR.Format_BadBase64Char);
 131        }
 132
 133        /// <summary>
 134        /// Decodes the span of UTF-8 encoded text represented as Base64Url into binary data.
 135        /// </summary>
 136        /// <param name="source">The input span which contains UTF-8 encoded text in Base64Url that needs to be decoded.
 137        /// <param name="destination">The output span which contains the result of the operation, i.e. the decoded binar
 138        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the output sp
 139        /// <returns><see langword="true"/> if bytes decoded successfully, otherwise <see langword="false"/>.</returns>
 140        /// <exception cref="FormatException"><paramref name="source"/> contains an invalid Base64Url character,
 141        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 142        public static bool TryDecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten)
 143        {
 0144            OperationStatus status = DecodeFromUtf8(source, destination, out _, out bytesWritten);
 145
 0146            if (status == OperationStatus.InvalidData)
 147            {
 0148                throw new FormatException(SR.Format_BadBase64Char);
 149            }
 150
 0151            Debug.Assert(status is OperationStatus.Done or OperationStatus.DestinationTooSmall);
 0152            return status == OperationStatus.Done;
 153        }
 154
 155        /// <summary>
 156        /// Decodes the span of UTF-8 encoded text represented as Base64Url into binary data.
 157        /// </summary>
 158        /// <param name="source">The input span which contains UTF-8 encoded text in Base64Url that needs to be decoded.
 159        /// <returns>A byte array which contains the result of the decoding operation.</returns>
 160        /// <exception cref="FormatException"><paramref name="source"/> contains an invalid Base64Url character,
 161        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 162        public static unsafe byte[] DecodeFromUtf8(ReadOnlySpan<byte> source)
 163        {
 0164            int upperBound = GetMaxDecodedLength(source.Length);
 0165            byte[]? rented = null;
 166
 0167            Span<byte> destination = (uint)upperBound <= MaxStackallocThreshold
 0168                ? stackalloc byte[MaxStackallocThreshold]
 0169                : (rented = ArrayPool<byte>.Shared.Rent(upperBound));
 170
 0171            OperationStatus status = DecodeFromUtf8(source, destination, out _, out int bytesWritten);
 0172            Debug.Assert(status is OperationStatus.Done or OperationStatus.InvalidData);
 0173            byte[] ret = destination.Slice(0, bytesWritten).ToArray();
 174
 0175            if (rented is not null)
 176            {
 0177                ArrayPool<byte>.Shared.Return(rented);
 178            }
 179
 0180            return status == OperationStatus.Done ? ret : throw new FormatException(SR.Format_BadBase64Char);
 181        }
 182
 183        /// <summary>
 184        /// Decodes the span of unicode ASCII chars represented as Base64Url into binary data.
 185        /// </summary>
 186        /// <param name="source">The input span which contains unicode ASCII chars in Base64Url that needs to be decoded
 187        /// <param name="destination">The output span which contains the result of the operation, i.e. the decoded binar
 188        /// <param name="charsConsumed">When this method returns, contains the number of input chars consumed during the
 189        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the output sp
 190        /// <param name="isFinalBlock"><see langword="true"/> when the input span contains the entirety of data to decod
 191        /// such as when calling in a loop. Calls with <see langword="false"/> should be followed up with another call w
 192        /// <returns>One of the enumeration values that indicates the success or failure of the operation.</returns>
 193        /// <remarks>
 194        /// As padding is optional for Base64Url the <paramref name="source"/> length not required to be a multiple of 4
 195        /// If the <paramref name="source"/> length is not a multiple of 4 and <paramref name="isFinalBlock"/> is <see l
 196        /// - Remainder of 3 chars - decoded into 2 bytes data, decoding succeeds.
 197        /// - Remainder of 2 chars - decoded into 1 byte data. decoding succeeds.
 198        /// - Remainder of 1 char - will cause OperationStatus.InvalidData result.
 199        /// </remarks>
 200        public static OperationStatus DecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination,
 201            out int charsConsumed, out int bytesWritten, bool isFinalBlock = true) =>
 0202            DecodeFrom(default(Base64UrlDecoderChar), MemoryMarshal.Cast<char, ushort>(source), destination,
 0203                out charsConsumed, out bytesWritten, isFinalBlock, ignoreWhiteSpace: true);
 204
 205        /// <summary>
 206        /// Decodes the span of unicode ASCII chars represented as Base64Url into binary data.
 207        /// </summary>
 208        /// <param name="source">The input span which contains ASCII chars in Base64Url that needs to be decoded.</param
 209        /// <param name="destination">The output span which contains the result of the operation, i.e. the decoded binar
 210        /// <returns>The number of bytes written into the output span. This can be used to slice the output for subseque
 211        /// <exception cref="ArgumentException">The buffer in <paramref name="destination"/> is too small to hold the de
 212        /// <exception cref="FormatException"><paramref name="source"/> contains a invalid Base64Url character,
 213        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 214        public static int DecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination)
 215        {
 0216            OperationStatus status = DecodeFromChars(source, destination, out _, out int bytesWritten);
 217
 0218            if (status == OperationStatus.Done)
 219            {
 0220                return bytesWritten;
 221            }
 222
 0223            if (status == OperationStatus.DestinationTooSmall)
 224            {
 0225                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
 226            }
 227
 0228            Debug.Assert(status == OperationStatus.InvalidData);
 0229            throw new FormatException(SR.Format_BadBase64Char);
 230        }
 231
 232        /// <summary>
 233        /// Decodes the span of unicode ASCII chars represented as Base64Url into binary data.
 234        /// </summary>
 235        /// <param name="source">The input span which contains ASCII chars in Base64Url that needs to be decoded.</param
 236        /// <param name="destination">The output span which contains the result of the operation, i.e. the decoded binar
 237        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the output sp
 238        /// <returns><see langword="true"/> if bytes decoded successfully, otherwise <see langword="false"/>.</returns>
 239        /// <exception cref="FormatException"><paramref name="source"/> contains an invalid Base64Url character,
 240        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 241        public static bool TryDecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination, out int bytesWritten)
 242        {
 0243            OperationStatus status = DecodeFromChars(source, destination, out _, out bytesWritten);
 244
 0245            if (status == OperationStatus.InvalidData)
 246            {
 0247                throw new FormatException(SR.Format_BadBase64Char);
 248            }
 249
 0250            return status == OperationStatus.Done;
 251        }
 252
 253        /// <summary>
 254        /// Decodes the span of unicode ASCII chars represented as Base64Url into binary data.
 255        /// </summary>
 256        /// <param name="source">The input span which contains ASCII chars in Base64Url that needs to be decoded.</param
 257        /// <returns>A byte array which contains the result of the decoding operation.</returns>
 258        /// <exception cref="FormatException"><paramref name="source"/> contains a invalid Base64Url character,
 259        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 260        public static unsafe byte[] DecodeFromChars(ReadOnlySpan<char> source)
 261        {
 0262            int upperBound = GetMaxDecodedLength(source.Length);
 0263            byte[]? rented = null;
 264
 0265            Span<byte> destination = (uint)upperBound <= MaxStackallocThreshold
 0266                ? stackalloc byte[MaxStackallocThreshold]
 0267                : (rented = ArrayPool<byte>.Shared.Rent(upperBound));
 268
 0269            OperationStatus status = DecodeFromChars(source, destination, out _, out int bytesWritten);
 0270            byte[] ret = destination.Slice(0, bytesWritten).ToArray();
 271
 0272            if (rented is not null)
 273            {
 0274                ArrayPool<byte>.Shared.Return(rented);
 275            }
 276
 0277            return status == OperationStatus.Done ? ret : throw new FormatException(SR.Format_BadBase64Char);
 278        }
 279
 280        private readonly struct Base64UrlDecoderByte : IBase64Decoder<byte>
 281        {
 282            public ReadOnlySpan<sbyte> DecodingMap =>
 0283                [
 0284                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 0285                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 0286                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,         //62 is placed at index 45 (
 0287                    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,         //52-61 are placed at index 
 0288                    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
 0289                    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,         //0-25 are placed at index 6
 0290                    -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
 0291                    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,         //26-51 are placed at index 
 0292                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,         // Bytes over 122 ('z') are 
 0293                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,         // Hence, padding the map wi
 0294                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 0295                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 0296                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 0297                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 0298                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 0299                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 0300                ];
 301
 302            public ReadOnlySpan<uint> VbmiLookup0 =>
 0303                [
 0304                    0x80808080, 0x80808080, 0x80808080, 0x80808080,
 0305                    0x80808080, 0x80808080, 0x80808080, 0x80808080,
 0306                    0x80808080, 0x80808080, 0x80808080, 0x80803e80,
 0307                    0x37363534, 0x3b3a3938, 0x80803d3c, 0x80808080
 0308                ];
 309
 310            public ReadOnlySpan<uint> VbmiLookup1 =>
 0311                [
 0312                    0x02010080, 0x06050403, 0x0a090807, 0x0e0d0c0b,
 0313                    0x1211100f, 0x16151413, 0x80191817, 0x3f808080,
 0314                    0x1c1b1a80, 0x201f1e1d, 0x24232221, 0x28272625,
 0315                    0x2c2b2a29, 0x302f2e2d, 0x80333231, 0x80808080
 0316                ];
 317
 318            public ReadOnlySpan<sbyte> Avx2LutHigh =>
 0319                [
 0320                    0x00, 0x00, 0x2d, 0x39,
 0321                    0x4f, 0x5a, 0x6f, 0x7a,
 0322                    0x00, 0x00, 0x00, 0x00,
 0323                    0x00, 0x00, 0x00, 0x00,
 0324                    0x00, 0x00, 0x2d, 0x39,
 0325                    0x4f, 0x5a, 0x6f, 0x7a,
 0326                    0x00, 0x00, 0x00, 0x00,
 0327                    0x00, 0x00, 0x00, 0x00
 0328                ];
 329
 330            public ReadOnlySpan<sbyte> Avx2LutLow =>
 0331                [
 0332                    0x01, 0x01, 0x2d, 0x30,
 0333                    0x41, 0x50, 0x61, 0x70,
 0334                    0x01, 0x01, 0x01, 0x01,
 0335                    0x01, 0x01, 0x01, 0x01,
 0336                    0x01, 0x01, 0x2d, 0x30,
 0337                    0x41, 0x50, 0x61, 0x70,
 0338                    0x01, 0x01, 0x01, 0x01,
 0339                    0x01, 0x01, 0x01, 0x01
 0340                ];
 341
 342            public ReadOnlySpan<sbyte> Avx2LutShift =>
 0343                [
 0344                    0,   0,  17,   4,
 0345                  -65, -65, -71, -71,
 0346                    0,   0,   0,   0,
 0347                    0,   0,   0,   0,
 0348                    0,   0,  17,   4,
 0349                  -65, -65, -71, -71,
 0350                    0,   0,   0,   0,
 0351                    0,   0,   0,   0
 0352                ];
 353
 0354            public byte MaskSlashOrUnderscore => (byte)'_'; // underscore
 355
 0356            public ReadOnlySpan<int> Vector128LutHigh => [0x392d0000, 0x7a6f5a4f, 0x00000000, 0x00000000];
 357
 0358            public ReadOnlySpan<int> Vector128LutLow => [0x302d0101, 0x70615041, 0x01010101, 0x01010101];
 359
 0360            public ReadOnlySpan<uint> Vector128LutShift => [0x04110000, 0xb9b9bfbf, 0x00000000, 0x00000000];
 361
 0362            public ReadOnlySpan<uint> AdvSimdLutOne3 => [0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFF3EFF];
 363
 0364            public uint AdvSimdLutTwo3Uint1 => 0x1B1AFF3F;
 365
 0366            public int GetMaxDecodedLength(int sourceLength) => Base64Url.GetMaxDecodedLength(sourceLength);
 367
 0368            public bool IsInvalidLength(int bufferLength) => (bufferLength & 3) == 1; // One byte cannot be decoded comp
 369
 0370            public bool IsValidPadding(uint padChar) => padChar is EncodingPad or UrlEncodingPad;
 371
 0372            public int SrcLength(bool isFinalBlock, int sourceLength) => isFinalBlock ? sourceLength : sourceLength & ~0
 373
 374#if NET
 375            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 376            [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
 377            [CompExactlyDependsOn(typeof(Ssse3))]
 378            public bool TryDecode128Core(
 379                Vector128<byte> str,
 380                Vector128<byte> hiNibbles,
 381                Vector128<byte> maskSlashOrUnderscore,
 382                Vector128<byte> mask8F,
 383                Vector128<byte> lutLow,
 384                Vector128<byte> lutHigh,
 385                Vector128<sbyte> lutShift,
 386                Vector128<byte> shiftForUnderscore,
 387                out Vector128<byte> result)
 388            {
 0389                Vector128<byte> lowerBound = SimdShuffle(lutLow, hiNibbles, mask8F);
 0390                Vector128<byte> upperBound = SimdShuffle(lutHigh, hiNibbles, mask8F);
 391
 0392                Vector128<byte> below = Vector128.LessThan(str, lowerBound);
 0393                Vector128<byte> above = Vector128.GreaterThan(str, upperBound);
 0394                Vector128<byte> eq5F = Vector128.Equals(str, maskSlashOrUnderscore);
 395
 396                // Take care as arguments are flipped in order!
 0397                Vector128<byte> outside = Vector128.AndNot(below | above, eq5F);
 398
 0399                if (outside != Vector128<byte>.Zero)
 400                {
 0401                    result = default;
 0402                    return false;
 403                }
 404
 0405                Vector128<byte> shift = SimdShuffle(lutShift.AsByte(), hiNibbles, mask8F);
 0406                str += shift;
 407
 0408                result = str + (eq5F & shiftForUnderscore);
 0409                return true;
 410            }
 411
 412            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 413            [CompExactlyDependsOn(typeof(Avx2))]
 414            public bool TryDecode256Core(
 415                Vector256<sbyte> str,
 416                Vector256<sbyte> hiNibbles,
 417                Vector256<sbyte> maskSlashOrUnderscore,
 418                Vector256<sbyte> lutLow,
 419                Vector256<sbyte> lutHigh,
 420                Vector256<sbyte> lutShift,
 421                Vector256<sbyte> shiftForUnderscore,
 422                out Vector256<sbyte> result)
 423            {
 0424                Vector256<sbyte> lowerBound = Avx2.Shuffle(lutLow, hiNibbles);
 0425                Vector256<sbyte> upperBound = Avx2.Shuffle(lutHigh, hiNibbles);
 426
 0427                Vector256<sbyte> below = Vector256.LessThan(str, lowerBound);
 0428                Vector256<sbyte> above = Vector256.GreaterThan(str, upperBound);
 0429                Vector256<sbyte> eq5F = Vector256.Equals(str, maskSlashOrUnderscore);
 430
 431                // Take care as arguments are flipped in order!
 0432                Vector256<sbyte> outside = Vector256.AndNot(below | above, eq5F);
 433
 0434                if (outside != Vector256<sbyte>.Zero)
 435                {
 0436                    result = default;
 0437                    return false;
 438                }
 439
 0440                Vector256<sbyte> shift = Avx2.Shuffle(lutShift, hiNibbles);
 0441                str += shift;
 442
 0443                result = str + (eq5F & shiftForUnderscore);
 0444                return true;
 445            }
 446
 447            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 448            public unsafe bool TryLoadVector512(byte* src, byte* srcStart, int sourceLength, out Vector512<sbyte> str) =
 0449                default(Base64DecoderByte).TryLoadVector512(src, srcStart, sourceLength, out str);
 450
 451            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 452            [CompExactlyDependsOn(typeof(Avx2))]
 453            public unsafe bool TryLoadAvxVector256(byte* src, byte* srcStart, int sourceLength, out Vector256<sbyte> str
 0454                default(Base64DecoderByte).TryLoadAvxVector256(src, srcStart, sourceLength, out str);
 455
 456            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 457            public unsafe bool TryLoadVector128(byte* src, byte* srcStart, int sourceLength, out Vector128<byte> str) =>
 0458                default(Base64DecoderByte).TryLoadVector128(src, srcStart, sourceLength, out str);
 459
 460            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 461            [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
 462            public unsafe bool TryLoadArmVector128x4(byte* src, byte* srcStart, int sourceLength,
 463                out Vector128<byte> str1, out Vector128<byte> str2, out Vector128<byte> str3, out Vector128<byte> str4) 
 0464                default(Base64DecoderByte).TryLoadArmVector128x4(src, srcStart, sourceLength, out str1, out str2, out st
 465#endif // NET
 466
 467            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 468            public unsafe int DecodeFourElements(byte* source, ref sbyte decodingMap) =>
 0469                default(Base64DecoderByte).DecodeFourElements(source, ref decodingMap);
 470
 471            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 472            public unsafe int DecodeRemaining(byte* srcEnd, ref sbyte decodingMap, long remaining, out uint t2, out uint
 0473                default(Base64DecoderByte).DecodeRemaining(srcEnd, ref decodingMap, remaining, out t2, out t3);
 474
 475            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 0476            public int IndexOfAnyExceptWhiteSpace(ReadOnlySpan<byte> span) => default(Base64DecoderByte).IndexOfAnyExcep
 477
 478            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 479            public OperationStatus DecodeWithWhiteSpaceBlockwiseWrapper<TBase64Decoder>(TBase64Decoder decoder, ReadOnly
 480                ref int bytesConsumed, ref int bytesWritten, bool isFinalBlock = true) where TBase64Decoder : IBase64Dec
 0481                DecodeWithWhiteSpaceBlockwise(decoder, utf8, bytes, ref bytesConsumed, ref bytesWritten, isFinalBlock);
 482        }
 483
 484        private readonly struct Base64UrlDecoderChar : IBase64Decoder<ushort>
 485        {
 0486            public ReadOnlySpan<sbyte> DecodingMap => default(Base64UrlDecoderByte).DecodingMap;
 487
 0488            public ReadOnlySpan<uint> VbmiLookup0 => default(Base64UrlDecoderByte).VbmiLookup0;
 489
 0490            public ReadOnlySpan<uint> VbmiLookup1 => default(Base64UrlDecoderByte).VbmiLookup1;
 491
 0492            public ReadOnlySpan<sbyte> Avx2LutHigh => default(Base64UrlDecoderByte).Avx2LutHigh;
 493
 0494            public ReadOnlySpan<sbyte> Avx2LutLow => default(Base64UrlDecoderByte).Avx2LutLow;
 495
 0496            public ReadOnlySpan<sbyte> Avx2LutShift => default(Base64UrlDecoderByte).Avx2LutShift;
 497
 0498            public byte MaskSlashOrUnderscore => default(Base64UrlDecoderByte).MaskSlashOrUnderscore;
 499
 0500            public ReadOnlySpan<int> Vector128LutHigh => default(Base64UrlDecoderByte).Vector128LutHigh;
 501
 0502            public ReadOnlySpan<int> Vector128LutLow => default(Base64UrlDecoderByte).Vector128LutLow;
 503
 0504            public ReadOnlySpan<uint> Vector128LutShift => default(Base64UrlDecoderByte).Vector128LutShift;
 505
 0506            public ReadOnlySpan<uint> AdvSimdLutOne3 => default(Base64UrlDecoderByte).AdvSimdLutOne3;
 507
 0508            public uint AdvSimdLutTwo3Uint1 => default(Base64UrlDecoderByte).AdvSimdLutTwo3Uint1;
 509
 0510            public int GetMaxDecodedLength(int sourceLength) => default(Base64UrlDecoderByte).GetMaxDecodedLength(source
 511
 0512            public bool IsInvalidLength(int bufferLength) => default(Base64UrlDecoderByte).IsInvalidLength(bufferLength)
 513
 0514            public bool IsValidPadding(uint padChar) => default(Base64UrlDecoderByte).IsValidPadding(padChar);
 515
 0516            public int SrcLength(bool isFinalBlock, int sourceLength) => default(Base64UrlDecoderByte).SrcLength(isFinal
 517
 518#if NET
 519            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 520            [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
 521            [CompExactlyDependsOn(typeof(Ssse3))]
 522            public bool TryDecode128Core(Vector128<byte> str, Vector128<byte> hiNibbles, Vector128<byte> maskSlashOrUnde
 523                Vector128<byte> lutLow, Vector128<byte> lutHigh, Vector128<sbyte> lutShift, Vector128<byte> shiftForUnde
 0524                default(Base64UrlDecoderByte).TryDecode128Core(str, hiNibbles, maskSlashOrUnderscore, mask8F, lutLow, lu
 525
 526            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 527            [CompExactlyDependsOn(typeof(Avx2))]
 528            public bool TryDecode256Core(Vector256<sbyte> str, Vector256<sbyte> hiNibbles, Vector256<sbyte> maskSlashOrU
 529                Vector256<sbyte> lutHigh, Vector256<sbyte> lutShift, Vector256<sbyte> shiftForUnderscore, out Vector256<
 0530                default(Base64UrlDecoderByte).TryDecode256Core(str, hiNibbles, maskSlashOrUnderscore, lutLow, lutHigh, l
 531
 532            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 533            public unsafe bool TryLoadVector512(ushort* src, ushort* srcStart, int sourceLength, out Vector512<sbyte> st
 0534                default(Base64DecoderChar).TryLoadVector512(src, srcStart, sourceLength, out str);
 535
 536            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 537            [CompExactlyDependsOn(typeof(Avx2))]
 538            public unsafe bool TryLoadAvxVector256(ushort* src, ushort* srcStart, int sourceLength, out Vector256<sbyte>
 0539                default(Base64DecoderChar).TryLoadAvxVector256(src, srcStart, sourceLength, out str);
 540
 541            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 542            public unsafe bool TryLoadVector128(ushort* src, ushort* srcStart, int sourceLength, out Vector128<byte> str
 0543                default(Base64DecoderChar).TryLoadVector128(src, srcStart, sourceLength, out str);
 544
 545            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 546            [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
 547            public unsafe bool TryLoadArmVector128x4(ushort* src, ushort* srcStart, int sourceLength,
 548                out Vector128<byte> str1, out Vector128<byte> str2, out Vector128<byte> str3, out Vector128<byte> str4) 
 0549                default(Base64DecoderChar).TryLoadArmVector128x4(src, srcStart, sourceLength, out str1, out str2, out st
 550#endif // NET
 551
 552            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 553            public unsafe int DecodeFourElements(ushort* source, ref sbyte decodingMap) =>
 0554                default(Base64DecoderChar).DecodeFourElements(source, ref decodingMap);
 555
 556            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 557            public unsafe int DecodeRemaining(ushort* srcEnd, ref sbyte decodingMap, long remaining, out uint t2, out ui
 0558                default(Base64DecoderChar).DecodeRemaining(srcEnd, ref decodingMap, remaining, out t2, out t3);
 559
 560            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 0561            public int IndexOfAnyExceptWhiteSpace(ReadOnlySpan<ushort> span) => default(Base64DecoderChar).IndexOfAnyExc
 562
 563            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 564            public OperationStatus DecodeWithWhiteSpaceBlockwiseWrapper<TBase64Decoder>(TBase64Decoder decoder, ReadOnly
 565                ref int bytesConsumed, ref int bytesWritten, bool isFinalBlock = true) where TBase64Decoder : IBase64Dec
 0566                DecodeWithWhiteSpaceBlockwise(decoder, source, bytes, ref bytesConsumed, ref bytesWritten, isFinalBlock)
 567        }
 568    }
 569}
 570

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Url/Base64UrlEncoder.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Diagnostics;
 5using System.Diagnostics.CodeAnalysis;
 6using System.Runtime.CompilerServices;
 7using System.Runtime.InteropServices;
 8#if NET
 9using System.Runtime.Intrinsics;
 10using System.Runtime.Intrinsics.Arm;
 11using System.Runtime.Intrinsics.X86;
 12#endif
 13using static System.Buffers.Text.Base64Helper;
 14
 15namespace System.Buffers.Text
 16{
 17    public static partial class Base64Url
 18    {
 19        /// <summary>
 20        /// Encodes the span of binary data into UTF-8 encoded text represented as Base64Url.
 21        /// </summary>
 22        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 23        /// <param name="destination">The output span which contains the result of the operation, i.e. the UTF-8 encoded
 24        /// <param name="bytesConsumed">When this method returns, contains the number of input bytes consumed during the
 25        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the output sp
 26        /// <param name="isFinalBlock"><see langword="true"/> when the input span contains the entirety of data to encod
 27        /// such as when calling in a loop, subsequent calls with <see langword="false"/> should end with <see langword=
 28        /// <returns>One of the enumeration values that indicates the success or failure of the operation.</returns>
 29        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 30        public static OperationStatus EncodeToUtf8(ReadOnlySpan<byte> source,
 31            Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true) =>
 032            EncodeTo(default(Base64UrlEncoderByte), source, destination, out bytesConsumed, out bytesWritten, isFinalBlo
 33
 34        /// <summary>
 35        /// Returns the number of characters required to encode
 36        /// <paramref name="bytesLength"/> bytes to Base64Url.
 37        /// </summary>
 38        /// <remarks>
 39        /// Because the Base64Url characters are all in the 7-bit ASCII range,
 40        /// the number of characters is equal both to the number of
 41        /// <see cref="char"/> values written by methods like
 42        /// <see cref="EncodeToChars(ReadOnlySpan{byte}, Span{char})"/>
 43        /// and the number of <see cref="byte"/> values written by UTF-8 methods like
 44        /// <see cref="EncodeToUtf8(ReadOnlySpan{byte}, Span{byte})"/>.
 45        /// </remarks>
 46        /// <exception cref="ArgumentOutOfRangeException">
 47        /// <paramref name="bytesLength"/> is less than 0 or greater than 1610612733.
 48        /// </exception>
 49        public static int GetEncodedLength(int bytesLength)
 50        {
 51#if NET
 052            ArgumentOutOfRangeException.ThrowIfGreaterThan<uint>((uint)bytesLength, MaximumEncodeLength);
 53
 054            (uint whole, uint remainder) = uint.DivRem((uint)bytesLength, 3);
 55
 056            return (int)(whole * 4 + (remainder > 0 ? remainder + 1 : 0)); // if remainder is 1 or 2, the encoded length
 57#else
 58            if ((uint)bytesLength > MaximumEncodeLength)
 59            {
 60                throw new ArgumentOutOfRangeException(nameof(bytesLength));
 61            }
 62
 63            int remainder = (int)((uint)bytesLength % 3);
 64
 65            return (bytesLength / 3) * 4 + (remainder > 0 ? remainder + 1 : 0);
 66#endif
 67        }
 68
 69        /// <summary>
 70        /// Encodes the span of binary data into UTF-8 encoded text represented as Base64Url.
 71        /// </summary>
 72        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 73        /// <param name="destination">The output span which contains the result of the operation, i.e. the UTF-8 encoded
 74        /// <returns>The number of bytes written into the destination span. This can be used to slice the output for sub
 75        /// <exception cref="ArgumentException">The buffer in <paramref name="destination"/> is too small to hold the en
 76        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 77        public static int EncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination)
 78        {
 079            OperationStatus status = EncodeToUtf8(source, destination, out _, out int bytesWritten);
 80
 081            if (status == OperationStatus.Done)
 82            {
 083                return bytesWritten;
 84            }
 85
 086            Debug.Assert(status == OperationStatus.DestinationTooSmall);
 087            throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
 88        }
 89
 90        /// <summary>
 91        /// Encodes the span of binary data into UTF-8 encoded text represented as Base64Url.
 92        /// </summary>
 93        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 94        /// <returns>The output byte array which contains the result of the operation, i.e. the UTF-8 encoded text in Ba
 95        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 96        public static byte[] EncodeToUtf8(ReadOnlySpan<byte> source)
 97        {
 098            byte[] destination = new byte[GetEncodedLength(source.Length)];
 099            EncodeToUtf8(source, destination, out _, out int bytesWritten);
 0100            Debug.Assert(destination.Length == bytesWritten);
 101
 0102            return destination;
 103        }
 104
 105        /// <summary>
 106        /// Encodes the span of binary data into unicode ASCII chars represented as Base64Url.
 107        /// </summary>
 108        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 109        /// <param name="destination">The output span which contains the result of the operation, i.e. the ASCII chars i
 110        /// <param name="bytesConsumed">When this method returns, contains the number of input bytes consumed during the
 111        /// <param name="charsWritten">When this method returns, contains the number of chars written into the output sp
 112        /// <param name="isFinalBlock"><see langword="true"/> when the input span contains the entirety of data to encod
 113        /// such as when calling in a loop, subsequent calls with <see langword="false"/> should end with <see langword=
 114        /// <returns>One of the enumeration values that indicates the success or failure of the operation.</returns>
 115        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 116        public static OperationStatus EncodeToChars(ReadOnlySpan<byte> source, Span<char> destination,
 117            out int bytesConsumed, out int charsWritten, bool isFinalBlock = true) =>
 0118            EncodeTo(default(Base64UrlEncoderChar), source, MemoryMarshal.Cast<char, ushort>(destination), out bytesCons
 119
 120        /// <summary>
 121        /// Encodes the span of binary data into unicode ASCII chars represented as Base64Url.
 122        /// </summary>
 123        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 124        /// <param name="destination">The output span which contains the result of the operation, i.e. the ASCII chars i
 125        /// <returns>The number of chars written into the destination span. This can be used to slice the output for sub
 126        /// <exception cref="ArgumentException">The buffer in <paramref name="destination"/> is too small to hold the en
 127        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 128        public static int EncodeToChars(ReadOnlySpan<byte> source, Span<char> destination)
 129        {
 0130            OperationStatus status = EncodeToChars(source, destination, out _, out int charsWritten);
 131
 0132            if (status == OperationStatus.Done)
 133            {
 0134                return charsWritten;
 135            }
 136
 0137            Debug.Assert(status == OperationStatus.DestinationTooSmall);
 0138            throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
 139        }
 140
 141        /// <summary>
 142        /// Encodes the span of binary data into unicode ASCII chars represented as Base64Url.
 143        /// </summary>
 144        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 145        /// <returns>A char array which contains the result of the operation, i.e. the ASCII chars in Base64Url.</return
 146        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 147        public static char[] EncodeToChars(ReadOnlySpan<byte> source)
 148        {
 0149            char[] destination = new char[GetEncodedLength(source.Length)];
 0150            EncodeToChars(source, destination, out _, out int charsWritten);
 0151            Debug.Assert(destination.Length == charsWritten);
 152
 0153            return destination;
 154        }
 155
 156        /// <summary>
 157        /// Encodes the span of binary data into unicode string represented as Base64Url ASCII chars.
 158        /// </summary>
 159        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 160        /// <returns>A string which contains the result of the operation, i.e. the ASCII string in Base64Url.</returns>
 161        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 162        public static unsafe string EncodeToString(ReadOnlySpan<byte> source)
 163        {
 164#if NET
 0165            int encodedLength = GetEncodedLength(source.Length);
 166
 0167            return string.Create(encodedLength, (IntPtr)(&source), static (buffer, spanPtr) =>
 0168            {
 0169                ReadOnlySpan<byte> source = *(ReadOnlySpan<byte>*)spanPtr;
 0170                EncodeToChars(source, buffer, out _, out int charsWritten);
 0171                Debug.Assert(buffer.Length == charsWritten, $"The source length: {source.Length}, bytes written: {charsW
 0172            });
 173#else
 174            char[] destination = new char[GetEncodedLength(source.Length)];
 175            EncodeToChars(source, destination, out _, out int charsWritten);
 176            Debug.Assert(destination.Length == charsWritten);
 177
 178            return new string(destination);
 179#endif
 180        }
 181
 182        /// <summary>
 183        /// Encodes the span of binary data into unicode ASCII chars represented as Base64Url.
 184        /// </summary>
 185        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 186        /// <param name="destination">The output span which contains the result of the operation, i.e. the ASCII chars i
 187        /// <param name="charsWritten">When this method returns, contains the number of chars written into the output sp
 188        /// <returns><see langword="true"/> if chars encoded successfully, otherwise <see langword="false"/>.</returns>
 189        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 190        public static bool TryEncodeToChars(ReadOnlySpan<byte> source, Span<char> destination, out int charsWritten)
 191        {
 0192            OperationStatus status = EncodeToChars(source, destination, out _, out charsWritten);
 193
 0194            return status == OperationStatus.Done;
 195        }
 196
 197        /// <summary>
 198        /// Encodes the span of binary data into UTF-8 encoded text represented as Base64Url.
 199        /// </summary>
 200        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 201        /// <param name="destination">The output span which contains the result of the operation, i.e. the UTF-8 encoded
 202        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the output sp
 203        /// <returns><see langword="true"/> if bytes encoded successfully, otherwise <see langword="false"/>.</returns>
 204        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 205        public static bool TryEncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten)
 206        {
 0207            OperationStatus status = EncodeToUtf8(source, destination, out _, out bytesWritten);
 208
 0209            return status == OperationStatus.Done;
 210        }
 211
 212        /// <summary>
 213        /// Encodes the span of binary data (in-place) into UTF-8 encoded text represented as Base64Url.
 214        /// The encoded text output is larger than the binary data contained in the input (the operation inflates the da
 215        /// </summary>
 216        /// <param name="buffer">The input span which contains binary data that needs to be encoded.
 217        /// It needs to be large enough to fit the result of the operation.</param>
 218        /// <param name="dataLength">The amount of binary data contained within the buffer that needs to be encoded
 219        /// (and needs to be smaller than the buffer length).</param>
 220        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the buffer. T
 221        /// <returns><see langword="true"/> if bytes encoded successfully, otherwise <see langword="false"/>.</returns>
 222        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 223        public static bool TryEncodeToUtf8InPlace(Span<byte> buffer, int dataLength, out int bytesWritten)
 224        {
 0225            OperationStatus status = EncodeToUtf8InPlace(default(Base64UrlEncoderByte), buffer, dataLength, out bytesWri
 226
 0227            return status == OperationStatus.Done;
 228        }
 229
 230        private readonly struct Base64UrlEncoderByte : Base64Helper.IBase64Encoder<byte>
 231        {
 0232            public ReadOnlySpan<byte> EncodingMap => "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"u
 233
 0234            public sbyte Avx2LutChar62 => -17;  // char '-' diff
 235
 0236            public sbyte Avx2LutChar63 => 32;   // char '_' diff
 237
 0238            public ReadOnlySpan<byte> AdvSimdLut4 => "wxyz0123456789-_"u8;
 239
 0240            public uint Ssse3AdvSimdLutE3 => 0x000020EF;
 241
 0242            public int IncrementPadTwo => 2;
 243
 0244            public int IncrementPadOne => 3;
 245
 246            public int GetMaxSrcLength(int srcLength, int destLength) =>
 0247                srcLength <= MaximumEncodeLength && destLength >= GetEncodedLength(srcLength) ?
 0248                srcLength : GetMaxDecodedLength(destLength);
 249
 250            public uint GetInPlaceDestinationLength(int encodedLength, int leftOver) =>
 0251                leftOver > 0 ? (uint)(encodedLength - leftOver - 1) : (uint)(encodedLength - 4);
 252
 0253            public int GetMaxEncodedLength(int srcLength) => GetEncodedLength(srcLength);
 254
 255            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 256            public unsafe void EncodeOneOptionallyPadTwo(byte* oneByte, byte* dest, ref byte encodingMap)
 257            {
 258                uint t0 = oneByte[0];
 259
 0260                uint i = t0 << 8;
 261
 0262                byte i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 10));
 0263                byte i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 4) & 0x3F));
 264
 265                ushort result;
 266
 0267                if (BitConverter.IsLittleEndian)
 268                {
 0269                    result = (ushort)(i0 | (i1 << 8));
 270                }
 271                else
 272                {
 273                    result = (ushort)((i0 << 8) | i1);
 274                }
 275
 0276                Unsafe.WriteUnaligned(dest, result);
 0277            }
 278
 279            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 280            public unsafe void EncodeTwoOptionallyPadOne(byte* twoBytes, byte* dest, ref byte encodingMap)
 281            {
 0282                uint t0 = twoBytes[0];
 0283                uint t1 = twoBytes[1];
 284
 0285                uint i = (t0 << 16) | (t1 << 8);
 286
 0287                byte i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 18));
 0288                byte i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 12) & 0x3F));
 0289                byte i2 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 6) & 0x3F));
 290
 0291                dest[0] = i0;
 0292                dest[1] = i1;
 0293                dest[2] = i2;
 0294            }
 295
 296#if NET
 297            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 298            public unsafe void StoreVector512ToDestination(byte* dest, byte* destStart, int destLength, Vector512<byte> 
 0299                default(Base64EncoderByte).StoreVector512ToDestination(dest, destStart, destLength, str);
 300
 301            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 302            [CompExactlyDependsOn(typeof(Avx2))]
 303            public unsafe void StoreVector256ToDestination(byte* dest, byte* destStart, int destLength, Vector256<byte> 
 0304                default(Base64EncoderByte).StoreVector256ToDestination(dest, destStart, destLength, str);
 305
 306            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 307            public unsafe void StoreVector128ToDestination(byte* dest, byte* destStart, int destLength, Vector128<byte> 
 0308                default(Base64EncoderByte).StoreVector128ToDestination(dest, destStart, destLength, str);
 309
 310            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 311            [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
 312            public unsafe void StoreArmVector128x4ToDestination(byte* dest, byte* destStart, int destLength,
 313                Vector128<byte> res1, Vector128<byte> res2, Vector128<byte> res3, Vector128<byte> res4) =>
 0314                default(Base64EncoderByte).StoreArmVector128x4ToDestination(dest, destStart, destLength, res1, res2, res
 315#endif // NET
 316
 317            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 318            public unsafe void EncodeThreeAndWrite(byte* threeBytes, byte* destination, ref byte encodingMap) =>
 0319                default(Base64EncoderByte).EncodeThreeAndWrite(threeBytes, destination, ref encodingMap);
 320        }
 321
 322        private readonly struct Base64UrlEncoderChar : IBase64Encoder<ushort>
 323        {
 0324            public ReadOnlySpan<byte> EncodingMap => default(Base64UrlEncoderByte).EncodingMap;
 325
 0326            public sbyte Avx2LutChar62 => default(Base64UrlEncoderByte).Avx2LutChar62;
 327
 0328            public sbyte Avx2LutChar63 => default(Base64UrlEncoderByte).Avx2LutChar63;
 329
 0330            public ReadOnlySpan<byte> AdvSimdLut4 => default(Base64UrlEncoderByte).AdvSimdLut4;
 331
 0332            public uint Ssse3AdvSimdLutE3 => default(Base64UrlEncoderByte).Ssse3AdvSimdLutE3;
 333
 0334            public int IncrementPadTwo => default(Base64UrlEncoderByte).IncrementPadTwo;
 335
 0336            public int IncrementPadOne => default(Base64UrlEncoderByte).IncrementPadOne;
 337
 338            public int GetMaxSrcLength(int srcLength, int destLength) =>
 0339                default(Base64UrlEncoderByte).GetMaxSrcLength(srcLength, destLength);
 340
 0341            public uint GetInPlaceDestinationLength(int encodedLength, int _) => 0; // not used for char encoding
 342
 0343            public int GetMaxEncodedLength(int _) => 0;  // not used for char encoding
 344
 345            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 346            public unsafe void EncodeOneOptionallyPadTwo(byte* oneByte, ushort* dest, ref byte encodingMap) =>
 0347                Base64Helper.EncodeOneOptionallyPadTwo(oneByte, dest, ref encodingMap);
 348
 349            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 350            public unsafe void EncodeTwoOptionallyPadOne(byte* twoBytes, ushort* dest, ref byte encodingMap) =>
 0351                Base64Helper.EncodeTwoOptionallyPadOne(twoBytes, dest, ref encodingMap);
 352
 353#if NET
 354            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 355            public unsafe void StoreVector512ToDestination(ushort* dest, ushort* destStart, int destLength, Vector512<by
 0356                default(Base64EncoderChar).StoreVector512ToDestination(dest, destStart, destLength, str);
 357
 358            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 359            public unsafe void StoreVector256ToDestination(ushort* dest, ushort* destStart, int destLength, Vector256<by
 0360                default(Base64EncoderChar).StoreVector256ToDestination(dest, destStart, destLength, str);
 361
 362            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 363            public unsafe void StoreVector128ToDestination(ushort* dest, ushort* destStart, int destLength, Vector128<by
 0364                default(Base64EncoderChar).StoreVector128ToDestination(dest, destStart, destLength, str);
 365
 366            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 367            [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
 368            public unsafe void StoreArmVector128x4ToDestination(ushort* dest, ushort* destStart, int destLength,
 369                Vector128<byte> res1, Vector128<byte> res2, Vector128<byte> res3, Vector128<byte> res4) =>
 0370                default(Base64EncoderChar).StoreArmVector128x4ToDestination(dest, destStart, destLength, res1, res2, res
 371#endif // NET
 372
 373            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 374            public unsafe void EncodeThreeAndWrite(byte* threeBytes, ushort* destination, ref byte encodingMap) =>
 0375                default(Base64EncoderChar).EncodeThreeAndWrite(threeBytes, destination, ref encodingMap);
 376        }
 377    }
 378}
 379

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Url/Base64UrlValidator.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Diagnostics;
 5using System.Runtime.CompilerServices;
 6
 7namespace System.Buffers.Text
 8{
 9    public static partial class Base64Url
 10    {
 11        /// <summary>Validates that the specified span of text is comprised of valid Base64Url-encoded data.</summary>
 12        /// <param name="base64UrlText">A span of text to validate.</param>
 13        /// <returns><see langword="true"/> if <paramref name="base64UrlText"/> contains a valid, decodable sequence of 
 14        /// <remarks>
 15        /// If the method returns <see langword="true"/>, the same text passed to <see cref="Base64Url.DecodeFromChars(R
 16        /// <see cref="Base64Url.TryDecodeFromChars(ReadOnlySpan{char}, Span{byte}, out int)"/> would successfully decod
 17        /// of <see cref="Base64Url.TryDecodeFromChars(ReadOnlySpan{char}, Span{byte}, out int)"/> assuming sufficient o
 18        /// Any amount of whitespace is allowed anywhere in the input, where whitespace is defined as the characters ' '
 19        /// </remarks>
 20        public static bool IsValid(ReadOnlySpan<char> base64UrlText) =>
 021            Base64Helper.IsValid(default(Base64UrlCharValidatable), base64UrlText, out _);
 22
 23        /// <summary>Validates that the specified span of text is comprised of valid Base64Url-encoded data.</summary>
 24        /// <param name="base64UrlText">A span of text to validate.</param>
 25        /// <param name="decodedLength">If the method returns true, the number of decoded bytes that will result from de
 26        /// <returns><see langword="true"/> if <paramref name="base64UrlText"/> contains a valid, decodable sequence of 
 27        /// <remarks>
 28        /// If the method returns <see langword="true"/>, the same text passed to <see cref="Base64Url.DecodeFromChars(R
 29        /// <see cref="Base64Url.TryDecodeFromChars(ReadOnlySpan{char}, Span{byte}, out int)"/> would successfully decod
 30        /// of <see cref="Base64Url.TryDecodeFromChars(ReadOnlySpan{char}, Span{byte}, out int)"/> assuming sufficient o
 31        /// Any amount of whitespace is allowed anywhere in the input, where whitespace is defined as the characters ' '
 32        /// </remarks>
 33        public static bool IsValid(ReadOnlySpan<char> base64UrlText, out int decodedLength) =>
 034            Base64Helper.IsValid(default(Base64UrlCharValidatable), base64UrlText, out decodedLength);
 35
 36        /// <summary>Validates that the specified span of UTF-8 text is comprised of valid Base64Url-encoded data.</summ
 37        /// <param name="utf8Base64UrlText">A span of UTF-8 text to validate.</param>
 38        /// <returns><see langword="true"/> if <paramref name="utf8Base64UrlText"/> contains a valid, decodable sequence
 39        /// <remarks>
 40        /// where whitespace is defined as the characters ' ', '\t', '\r', or '\n' (as bytes).
 41        /// </remarks>
 42        public static bool IsValid(ReadOnlySpan<byte> utf8Base64UrlText) =>
 043            Base64Helper.IsValid(default(Base64UrlByteValidatable), utf8Base64UrlText, out _);
 44
 45        /// <summary>Validates that the specified span of UTF-8 text is comprised of valid Base64Url-encoded data.</summ
 46        /// <param name="utf8Base64UrlText">A span of UTF-8 text to validate.</param>
 47        /// <param name="decodedLength">If the method returns true, the number of decoded bytes that will result from de
 48        /// <returns><see langword="true"/> if <paramref name="utf8Base64UrlText"/> contains a valid, decodable sequence
 49        /// <remarks>
 50        /// where whitespace is defined as the characters ' ', '\t', '\r', or '\n' (as bytes).
 51        /// </remarks>
 52        public static bool IsValid(ReadOnlySpan<byte> utf8Base64UrlText, out int decodedLength) =>
 053            Base64Helper.IsValid(default(Base64UrlByteValidatable), utf8Base64UrlText, out decodedLength);
 54
 55        private const uint UrlEncodingPad = '%'; // allowed for url padding
 56
 57        private readonly struct Base64UrlCharValidatable : Base64Helper.IBase64Validatable<char>
 58        {
 59#if NET
 060            private static readonly SearchValues<char> s_validBase64UrlChars = SearchValues.Create("ABCDEFGHIJKLMNOPQRST
 61
 062            public int IndexOfAnyExcept(ReadOnlySpan<char> span) => span.IndexOfAnyExcept(s_validBase64UrlChars);
 63#else
 64            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 65            public int DecodeValue(char value)
 66            {
 67                if (value > byte.MaxValue)
 68                {
 69                    // Invalid char was found.
 70                    return -2;
 71                }
 72
 73                return default(Base64UrlDecoderByte).DecodingMap[value];
 74            }
 75#endif
 076            public bool IsWhiteSpace(char value) => Base64Helper.IsWhiteSpace(value);
 077            public bool IsEncodingPad(char value) => value == Base64Helper.EncodingPad || value == UrlEncodingPad;
 78            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 79            public bool ValidateAndDecodeLength(char lastChar, int length, int paddingCount, out int decodedLength) =>
 080                default(Base64UrlByteValidatable).ValidateAndDecodeLength((byte)lastChar, length, paddingCount, out deco
 81        }
 82
 83        private readonly struct Base64UrlByteValidatable : Base64Helper.IBase64Validatable<byte>
 84        {
 85#if NET
 086            private static readonly SearchValues<byte> s_validBase64UrlChars = SearchValues.Create(default(Base64UrlEnco
 87
 088            public int IndexOfAnyExcept(ReadOnlySpan<byte> span) => span.IndexOfAnyExcept(s_validBase64UrlChars);
 89#else
 90            public int DecodeValue(byte value) => default(Base64UrlDecoderByte).DecodingMap[value];
 91#endif
 092            public bool IsWhiteSpace(byte value) => Base64Helper.IsWhiteSpace(value);
 093            public bool IsEncodingPad(byte value) => value == Base64Helper.EncodingPad || value == UrlEncodingPad;
 94            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 95            public bool ValidateAndDecodeLength(byte lastChar, int length, int paddingCount, out int decodedLength)
 96            {
 97                // Padding is optional for Base64Url, so need to account remainder.
 098                int remainder = (int)((uint)length % 4);
 99
 0100                if (paddingCount != 0)
 101                {
 0102                    length -= paddingCount;
 0103                    remainder = (int)((uint)length % 4);
 104
 105                    // if there is a padding, there should be remainder and the sum of remainder and padding should not 
 0106                    if (remainder == 0 || remainder + paddingCount > 4)
 107                    {
 0108                        decodedLength = 0;
 0109                        return false;
 110                    }
 111                }
 112
 0113                decodedLength = (length >> 2) * 3 + (remainder > 0 ? remainder - 1 : 0);
 114
 0115                if (remainder > 0)
 116                {
 0117                    int decoded = default(Base64UrlDecoderByte).DecodingMap[lastChar];
 118                    switch (remainder)
 119                    {
 0120                        case 1: return false; // 1 byte is not decodable => invalid.
 0121                        case 2: return ((decoded & 0x0F) == 0); // if unused lower 4 bits are set to 0
 0122                        case 3: return ((decoded & 0x03) == 0); // if unused lower 2 bits are set to 0
 123                    }
 124                }
 125
 0126                return true;
 127            }
 128        }
 129    }
 130}
 131
Generated by: ReportGenerator 5.5.11.0
10/9/2026 - 5:46:17 PM
GitHub | reportgenerator.io

Methods/Properties

GetMaxDecodedLength(System.Int32)
DecodeFromUtf8(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>,System.Int32&,System.Int32&,System.Boolean)
DecodeFromUtf8InPlace(System.Span`1<System.Byte>)
DecodeFromUtf8(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>)
TryDecodeFromUtf8(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>,System.Int32&)
DecodeFromUtf8(System.ReadOnlySpan`1<System.Byte>)
DecodeFromChars(System.ReadOnlySpan`1<System.Char>,System.Span`1<System.Byte>,System.Int32&,System.Int32&,System.Boolean)
DecodeFromChars(System.ReadOnlySpan`1<System.Char>,System.Span`1<System.Byte>)
TryDecodeFromChars(System.ReadOnlySpan`1<System.Char>,System.Span`1<System.Byte>,System.Int32&)
DecodeFromChars(System.ReadOnlySpan`1<System.Char>)
DecodingMap()
VbmiLookup0()
VbmiLookup1()
Avx2LutHigh()
Avx2LutLow()
Avx2LutShift()
MaskSlashOrUnderscore()
Vector128LutHigh()
Vector128LutLow()
Vector128LutShift()
AdvSimdLutOne3()
AdvSimdLutTwo3Uint1()
GetMaxDecodedLength(System.Int32)
IsInvalidLength(System.Int32)
IsValidPadding(System.UInt32)
SrcLength(System.Boolean,System.Int32)
TryDecode128Core(System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.SByte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>&)
TryDecode256Core(System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>&)
TryLoadVector512(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector512`1<System.SByte>&)
TryLoadAvxVector256(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector256`1<System.SByte>&)
TryLoadVector128(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>&)
TryLoadArmVector128x4(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>&,System.Runtime.Intrinsics.Vector128`1<System.Byte>&,System.Runtime.Intrinsics.Vector128`1<System.Byte>&,System.Runtime.Intrinsics.Vector128`1<System.Byte>&)
DecodeFourElements(System.Byte*,System.SByte&)
DecodeRemaining(System.Byte*,System.SByte&,System.Int64,System.UInt32&,System.UInt32&)
IndexOfAnyExceptWhiteSpace(System.ReadOnlySpan`1<System.Byte>)
DecodeWithWhiteSpaceBlockwiseWrapper(TBase64Decoder,System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>,System.Int32&,System.Int32&,System.Boolean)
DecodingMap()
VbmiLookup0()
VbmiLookup1()
Avx2LutHigh()
Avx2LutLow()
Avx2LutShift()
MaskSlashOrUnderscore()
Vector128LutHigh()
Vector128LutLow()
Vector128LutShift()
AdvSimdLutOne3()
AdvSimdLutTwo3Uint1()
GetMaxDecodedLength(System.Int32)
IsInvalidLength(System.Int32)
IsValidPadding(System.UInt32)
SrcLength(System.Boolean,System.Int32)
TryDecode128Core(System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.SByte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>&)
TryDecode256Core(System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>&)
TryLoadVector512(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector512`1<System.SByte>&)
TryLoadAvxVector256(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector256`1<System.SByte>&)
TryLoadVector128(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>&)
TryLoadArmVector128x4(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>&,System.Runtime.Intrinsics.Vector128`1<System.Byte>&,System.Runtime.Intrinsics.Vector128`1<System.Byte>&,System.Runtime.Intrinsics.Vector128`1<System.Byte>&)
DecodeFourElements(System.UInt16*,System.SByte&)
DecodeRemaining(System.UInt16*,System.SByte&,System.Int64,System.UInt32&,System.UInt32&)
IndexOfAnyExceptWhiteSpace(System.ReadOnlySpan`1<System.UInt16>)
DecodeWithWhiteSpaceBlockwiseWrapper(TBase64Decoder,System.ReadOnlySpan`1<System.UInt16>,System.Span`1<System.Byte>,System.Int32&,System.Int32&,System.Boolean)
EncodeToUtf8(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>,System.Int32&,System.Int32&,System.Boolean)
GetEncodedLength(System.Int32)
EncodeToUtf8(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>)
EncodeToUtf8(System.ReadOnlySpan`1<System.Byte>)
EncodeToChars(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Char>,System.Int32&,System.Int32&,System.Boolean)
EncodeToChars(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Char>)
EncodeToChars(System.ReadOnlySpan`1<System.Byte>)
EncodeToString(System.ReadOnlySpan`1<System.Byte>)
TryEncodeToChars(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Char>,System.Int32&)
TryEncodeToUtf8(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>,System.Int32&)
TryEncodeToUtf8InPlace(System.Span`1<System.Byte>,System.Int32,System.Int32&)
EncodingMap()
Avx2LutChar62()
Avx2LutChar63()
AdvSimdLut4()
Ssse3AdvSimdLutE3()
IncrementPadTwo()
IncrementPadOne()
GetMaxSrcLength(System.Int32,System.Int32)
GetInPlaceDestinationLength(System.Int32,System.Int32)
GetMaxEncodedLength(System.Int32)
EncodeOneOptionallyPadTwo(System.Byte*,System.Byte*,System.Byte&)
EncodeTwoOptionallyPadOne(System.Byte*,System.Byte*,System.Byte&)
StoreVector512ToDestination(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector512`1<System.Byte>)
StoreVector256ToDestination(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector256`1<System.Byte>)
StoreVector128ToDestination(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>)
StoreArmVector128x4ToDestination(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>)
EncodeThreeAndWrite(System.Byte*,System.Byte*,System.Byte&)
EncodingMap()
Avx2LutChar62()
Avx2LutChar63()
AdvSimdLut4()
Ssse3AdvSimdLutE3()
IncrementPadTwo()
IncrementPadOne()
GetMaxSrcLength(System.Int32,System.Int32)
GetInPlaceDestinationLength(System.Int32,System.Int32)
GetMaxEncodedLength(System.Int32)
EncodeOneOptionallyPadTwo(System.Byte*,System.UInt16*,System.Byte&)
EncodeTwoOptionallyPadOne(System.Byte*,System.UInt16*,System.Byte&)
StoreVector512ToDestination(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector512`1<System.Byte>)
StoreVector256ToDestination(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector256`1<System.Byte>)
StoreVector128ToDestination(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>)
StoreArmVector128x4ToDestination(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>)
EncodeThreeAndWrite(System.Byte*,System.UInt16*,System.Byte&)
IsValid(System.ReadOnlySpan`1<System.Char>)
IsValid(System.ReadOnlySpan`1<System.Char>,System.Int32&)
IsValid(System.ReadOnlySpan`1<System.Byte>)
IsValid(System.ReadOnlySpan`1<System.Byte>,System.Int32&)
.cctor()
IndexOfAnyExcept(System.ReadOnlySpan`1<System.Char>)
IsWhiteSpace(System.Char)
IsEncodingPad(System.Char)
ValidateAndDecodeLength(System.Char,System.Int32,System.Int32,System.Int32&)
.cctor()
IndexOfAnyExcept(System.ReadOnlySpan`1<System.Byte>)
IsWhiteSpace(System.Byte)
IsEncodingPad(System.Byte)
ValidateAndDecodeLength(System.Byte,System.Int32,System.Int32,System.Int32&)