Microsoft.Bcl.Memory
Returns the maximum length (in bytes) of the result if you were to decode base 64 encoded text from a span of size .
The specified is less than 0.
Decodes the span of UTF-8 encoded text represented as Base64Url into binary data.
The input span which contains UTF-8 encoded text in Base64Url that needs to be decoded.
The output span which contains the result of the operation, i.e. the decoded binary data.
When this method returns, contains the number of input bytes consumed during the operation. This can be used to slice the input for subsequent calls, if necessary. This parameter is treated as uninitialized.
When this method returns, contains the number of bytes written into the output span. This can be used to slice the output for subsequent calls, if necessary. This parameter is treated as uninitialized.
when the input span contains the entirety of data to encode; when more data may follow,
such as when calling in a loop. Calls with should be followed up with another call where this parameter is call. The default is .
One of the enumeration values that indicates the success or failure of the operation.
As padding is optional for Base64Url the length not required to be a multiple of 4 even if is .
If the length is not a multiple of 4 and is the remainders decoded accordingly:
- Remainder of 3 bytes - decoded into 2 bytes data, decoding succeeds.
- Remainder of 2 bytes - decoded into 1 byte data. decoding succeeds.
- Remainder of 1 byte - will cause OperationStatus.InvalidData result.
Decodes the span of UTF-8 encoded text in Base64Url into binary data, in-place.
The decoded binary output is smaller than the text data contained in the input (the operation deflates the data).
The input span which contains the base 64 text data that needs to be decoded.
The number of bytes written into . This can be used to slice the output for subsequent calls, if necessary.
contains an invalid Base64Url character,
more than two padding characters, or a non white space character among the padding characters.
As padding is optional for Base64Url the length not required to be a multiple of 4.
If the length is not a multiple of 4 the remainders decoded accordingly:
- Remainder of 3 bytes - decoded into 2 bytes data, decoding succeeds.
- Remainder of 2 bytes - decoded into 1 byte data. decoding succeeds.
- Remainder of 1 byte - is invalid input, causes FormatException.
Decodes the span of UTF-8 encoded text represented as Base64Url into binary data.
The input span which contains UTF-8 encoded text in Base64Url that needs to be decoded.
The output span which contains the result of the operation, i.e. the decoded binary data.
The number of bytes written into . This can be used to slice the output for subsequent calls, if necessary.
The buffer in is too small to hold the encoded output.
contains an invalid Base64Url character,
more than two padding characters, or a non white space character among the padding characters.
As padding is optional for Base64Url the length not required to be a multiple of 4.
If the length is not a multiple of 4 the remainders decoded accordingly:
- Remainder of 3 bytes - decoded into 2 bytes data, decoding succeeds.
- Remainder of 2 bytes - decoded into 1 byte data. decoding succeeds.
- Remainder of 1 byte - is invalid input, causes FormatException.
Decodes the span of UTF-8 encoded text represented as Base64Url into binary data.
The input span which contains UTF-8 encoded text in Base64Url that needs to be decoded.
The output span which contains the result of the operation, i.e. the decoded binary data.
When this method returns, contains the number of bytes written into the output span. This can be used to slice the output for subsequent calls, if necessary. This parameter is treated as uninitialized.
if bytes decoded successfully, otherwise .
contains an invalid Base64Url character,
more than two padding characters, or a non white space character among the padding characters.
Decodes the span of UTF-8 encoded text represented as Base64Url into binary data.
The input span which contains UTF-8 encoded text in Base64Url that needs to be decoded.
>A byte array which contains the result of the decoding operation.
contains an invalid Base64Url character,
more than two padding characters, or a non white space character among the padding characters.
Decodes the span of unicode ASCII chars represented as Base64Url into binary data.
The input span which contains unicode ASCII chars in Base64Url that needs to be decoded.
The output span which contains the result of the operation, i.e. the decoded binary data.
When this method returns, contains the number of input chars consumed during the operation. This can be used to slice the input for subsequent calls, if necessary. This parameter is treated as uninitialized.
When this method returns, contains the number of bytes written into the output span. This can be used to slice the output for subsequent calls, if necessary. This parameter is treated as uninitialized.
when the input span contains the entirety of data to encode; when more data may follow,
such as when calling in a loop. Calls with should be followed up with another call where this parameter is call. The default is .
One of the enumeration values that indicates the success or failure of the operation.
As padding is optional for Base64Url the length not required to be a multiple of 4 even if is .
If the length is not a multiple of 4 and is the remainders decoded accordingly:
- Remainder of 3 chars - decoded into 2 bytes data, decoding succeeds.
- Remainder of 2 chars - decoded into 1 byte data. decoding succeeds.
- Remainder of 1 char - will cause OperationStatus.InvalidData result.
Decodes the span of unicode ASCII chars represented as Base64Url into binary data.
The input span which contains ASCII chars in Base64Url that needs to be decoded.
The output span which contains the result of the operation, i.e. the decoded binary data.
The number of bytes written into the output span. This can be used to slice the output for subsequent calls, if necessary.
The buffer in is too small to hold the encoded output.
contains a invalid Base64Url character,
more than two padding characters, or a non white space character among the padding characters.
Decodes the span of unicode ASCII chars represented as Base64Url into binary data.
The input span which contains ASCII chars in Base64Url that needs to be decoded.
The output span which contains the result of the operation, i.e. the decoded binary data.
When this method returns, contains the number of bytes written into the output span. This can be used to slice the output for subsequent calls, if necessary. This parameter is treated as uninitialized.
if bytes decoded successfully, otherwise .
contains an invalid Base64Url character,
more than two padding characters, or a non white space character among the padding characters.
Decodes the span of unicode ASCII chars represented as Base64Url into binary data.
The input span which contains ASCII chars in Base64Url that needs to be decoded.
A byte array which contains the result of the decoding operation.
contains a invalid Base64Url character,
more than two padding characters, or a non white space character among the padding characters.
Encodes the span of binary data into UTF-8 encoded text represented as Base64Url.
The input span which contains binary data that needs to be encoded.
The output span which contains the result of the operation, i.e. the UTF-8 encoded text in Base64Url.
When this method returns, contains the number of input bytes consumed during the operation. This can be used to slice the input for subsequent calls, if necessary. This parameter is treated as uninitialized.
When this method returns, contains the number of bytes written into the output span. This can be used to slice the output for subsequent calls, if necessary. This parameter is treated as uninitialized.
when the input span contains the entirety of data to encode; when more data may follow,
such as when calling in a loop, subsequent calls with should end with call. The default is .
One of the enumeration values that indicates the success or failure of the operation.
This implementation of the base64url encoding omits the optional padding characters.
Returns the length (in bytes) of the result if you were to encode binary data within a byte span of size .
is less than 0 or greater than 1610612733.
Encodes the span of binary data into UTF-8 encoded text represented as Base64Url.
The input span which contains binary data that needs to be encoded.
The output span which contains the result of the operation, i.e. the UTF-8 encoded text in Base64Url.
The number of bytes written into the destination span. This can be used to slice the output for subsequent calls, if necessary.
The buffer in is too small to hold the encoded output.
This implementation of the base64url encoding omits the optional padding characters.
Encodes the span of binary data into UTF-8 encoded text represented as Base64Url.
The input span which contains binary data that needs to be encoded.
The output byte array which contains the result of the operation, i.e. the UTF-8 encoded text in Base64Url.
This implementation of the base64url encoding omits the optional padding characters.
Encodes the span of binary data into unicode ASCII chars represented as Base64Url.
The input span which contains binary data that needs to be encoded.
The output span which contains the result of the operation, i.e. the ASCII chars in Base64Url.
>When this method returns, contains the number of input bytes consumed during the operation. This can be used to slice the input for subsequent calls, if necessary. This parameter is treated as uninitialized.
>When this method returns, contains the number of chars written into the output span. This can be used to slice the output for subsequent calls, if necessary. This parameter is treated as uninitialized.
when the input span contains the entirety of data to encode; when more data may follow,
such as when calling in a loop, subsequent calls with should end with call. The default is .
One of the enumeration values that indicates the success or failure of the operation.
This implementation of the base64url encoding omits the optional padding characters.
Encodes the span of binary data into unicode ASCII chars represented as Base64Url.
The input span which contains binary data that needs to be encoded.
The output span which contains the result of the operation, i.e. the ASCII chars in Base64Url.
The number of bytes written into the destination span. This can be used to slice the output for subsequent calls, if necessary.
The buffer in is too small to hold the encoded output.
This implementation of the base64url encoding omits the optional padding characters.
Encodes the span of binary data into unicode ASCII chars represented as Base64Url.
The input span which contains binary data that needs to be encoded.
A char array which contains the result of the operation, i.e. the ASCII chars in Base64Url.
This implementation of the base64url encoding omits the optional padding characters.
Encodes the span of binary data into unicode string represented as Base64Url ASCII chars.
The input span which contains binary data that needs to be encoded.
A string which contains the result of the operation, i.e. the ASCII string in Base64Url.
This implementation of the base64url encoding omits the optional padding characters.
Encodes the span of binary data into unicode ASCII chars represented as Base64Url.
The input span which contains binary data that needs to be encoded.
The output span which contains the result of the operation, i.e. the ASCII chars in Base64Url.
When this method returns, contains the number of chars written into the output span. This can be used to slice the output for subsequent calls, if necessary. This parameter is treated as uninitialized.
if chars encoded successfully, otherwise .
This implementation of the base64url encoding omits the optional padding characters.
Encodes the span of binary data into UTF-8 encoded chars represented as Base64Url.
The input span which contains binary data that needs to be encoded.
The output span which contains the result of the operation, i.e. the UTF-8 encoded text in Base64Url.
When this method returns, contains the number of chars written into the output span. This can be used to slice the output for subsequent calls, if necessary. This parameter is treated as uninitialized.
if bytes encoded successfully, otherwise .
This implementation of the base64url encoding omits the optional padding characters.
Encodes the span of binary data (in-place) into UTF-8 encoded text represented as base 64.
The encoded text output is larger than the binary data contained in the input (the operation inflates the data).
The input span which contains binary data that needs to be encoded.
It needs to be large enough to fit the result of the operation.
The amount of binary data contained within the buffer that needs to be encoded
(and needs to be smaller than the buffer length).
When this method returns, contains the number of bytes written into the buffer. This parameter is treated as uninitialized.
if bytes encoded successfully, otherwise .
This implementation of the base64url encoding omits the optional padding characters.
Validates that the specified span of text is comprised of valid base-64 encoded data.
A span of text to validate.
if contains a valid, decodable sequence of base-64 encoded data; otherwise, .
If the method returns , the same text passed to and
would successfully decode (in the case
of assuming sufficient output space).
Any amount of whitespace is allowed anywhere in the input, where whitespace is defined as the characters ' ', '\t', '\r', or '\n'.
Validates that the specified span of text is comprised of valid base-64 encoded data.
A span of text to validate.
If the method returns true, the number of decoded bytes that will result from decoding the input text.
if contains a valid, decodable sequence of base-64 encoded data; otherwise, .
If the method returns , the same text passed to and
would successfully decode (in the case
of assuming sufficient output space).
Any amount of whitespace is allowed anywhere in the input, where whitespace is defined as the characters ' ', '\t', '\r', or '\n'.
Validates that the specified span of UTF-8 text is comprised of valid base-64 encoded data.
A span of UTF-8 text to validate.
if contains a valid, decodable sequence of base-64 encoded data; otherwise, .
where whitespace is defined as the characters ' ', '\t', '\r', or '\n' (as bytes).
Validates that the specified span of UTF-8 text is comprised of valid base-64 encoded data.
A span of UTF-8 text to validate.
If the method returns true, the number of decoded bytes that will result from decoding the input UTF-8 text.
if contains a valid, decodable sequence of base-64 encoded data; otherwise, .
where whitespace is defined as the characters ' ', '\t', '\r', or '\n' (as bytes).
Indicates that the specified member requires the caller to be in an unsafe context.
Initializes a new instance of the class.
Specifies that null is allowed as an input even if the corresponding type disallows it.
Specifies that null is disallowed as an input even if the corresponding type allows it.
Specifies that an output may be null even if the corresponding type disallows it.
Specifies that an output will not be null even if the corresponding type allows it. Specifies that an input argument was not null when the call returns.
Specifies that when a method returns , the parameter may be null even if the corresponding type disallows it.
Initializes the attribute with the specified return value condition.
The return value condition. If the method returns this value, the associated parameter may be null.
Gets the return value condition.
Specifies that when a method returns , the parameter will not be null even if the corresponding type allows it.
Initializes the attribute with the specified return value condition.
The return value condition. If the method returns this value, the associated parameter will not be null.
Gets the return value condition.
Specifies that the output will be non-null if the named parameter is non-null.
Initializes the attribute with the associated parameter name.
The associated parameter name. The output will be non-null if the argument to the parameter specified is non-null.
Gets the associated parameter name.
Applied to a method that will never return under any circumstance.
Specifies that the method will not return if the associated Boolean parameter is passed the specified value.
Initializes the attribute with the specified parameter value.
The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to
the associated parameter matches this value.
Gets the condition parameter value.
Specifies that the method or property will ensure that the listed field and property members have not-null values.
Initializes the attribute with a field or property member.
The field or property member that is promised to be not-null.
Initializes the attribute with the list of field and property members.
The list of field and property members that are promised to be not-null.
Gets field or property member names.
Specifies that the method or property will ensure that the listed field and property members have not-null values when returning with the specified return value condition.
Initializes the attribute with the specified return value condition and a field or property member.
The return value condition. If the method returns this value, the associated field or property member will not be null.
The field or property member that is promised to be not-null.
Initializes the attribute with the specified return value condition and list of field and property members.
The return value condition. If the method returns this value, the associated field and property members will not be null.
The list of field and property members that are promised to be not-null.
Gets the return value condition.
Gets field or property member names.
Count the number of trailing zero bits in an integer value.
Similar in behavior to the x86 instruction TZCNT.
The value.
Rotates the specified value left by the specified number of bits.
Similar in behavior to the x86 instruction ROL.
The value to rotate.
The number of bits to rotate by.
Any value outside the range [0..31] is treated as congruent mod 32.
The rotated value.
Rotates the specified value right by the specified number of bits.
Similar in behavior to the x86 instruction ROR.
The value to rotate.
The number of bits to rotate by.
Any value outside the range [0..31] is treated as congruent mod 32.
The rotated value.
Returns iff all bytes in are ASCII.
Returns iff all chars in are ASCII.
Returns iff all chars in are ASCII.
Given a DWORD which represents two packed chars in machine-endian order,
iff the first char (in machine-endian order) is ASCII.
Returns the index in where the first non-ASCII byte is found.
Returns if the buffer is empty or all-ASCII.
An ASCII byte is defined as 0x00 - 0x7F, inclusive.
Returns the index in where the first non-ASCII char is found.
Returns if the buffer is empty or all-ASCII.
An ASCII char is defined as 0x0000 - 0x007F, inclusive.
Given a QWORD which represents a buffer of 4 ASCII chars in machine-endian order,
narrows each WORD to a BYTE, then writes the 4-byte result to the output buffer
also in machine-endian order.
Given a DWORD which represents a buffer of 2 ASCII chars in machine-endian order,
narrows each WORD to a BYTE, then writes the 2-byte result to the output buffer also in
machine-endian order.
Copies as many ASCII characters (U+0000..U+007F) as possible from
to , stopping when the first non-ASCII character is encountered
or once elements have been converted. Returns the total number
of elements that were able to be converted.
Copies as many ASCII bytes (00..7F) as possible from
to , stopping when the first non-ASCII byte is encountered
or once elements have been converted. Returns the total number
of elements that were able to be converted.
Given a DWORD which represents a buffer of 4 bytes, widens the buffer into 4 WORDs and
writes them to the output buffer with machine endianness.
A mask which selects only the high bit of each byte of the given .
A mask which selects only the high bit of each byte of the given .
Returns iff all bytes in are ASCII.
Given a DWORD which represents a four-byte buffer read in machine endianness, and which
the caller has asserted contains a non-ASCII byte *somewhere* in the data, counts the
number of consecutive ASCII bytes starting from the beginning of the buffer. Returns
a value 0 - 3, inclusive. (The caller is responsible for ensuring that the buffer doesn't
contain all-ASCII data.)
Represents a Unicode scalar value ([ U+0000..U+D7FF ], inclusive; or [ U+E000..U+10FFFF ], inclusive).
This type's constructors and conversion operators validate the input, so consumers can call the APIs
assuming that the underlying instance is well-formed.
Creates a from the provided UTF-16 code unit.
If represents a UTF-16 surrogate code point
U+D800..U+DFFF, inclusive.
Creates a from the provided UTF-16 surrogate pair.
If does not represent a UTF-16 high surrogate code point
or does not represent a UTF-16 low surrogate code point.
Creates a from the provided Unicode scalar value.
If does not represent a value Unicode scalar value.
Creates a from the provided Unicode scalar value.
If does not represent a value Unicode scalar value.
Returns true if and only if this scalar value is ASCII ([ U+0000..U+007F ])
and therefore representable by a single UTF-8 code unit.
Returns true if and only if this scalar value is within the BMP ([ U+0000..U+FFFF ])
and therefore representable by a single UTF-16 code unit.
Returns the Unicode plane (0 to 16, inclusive) which contains this scalar.
A instance that represents the Unicode replacement character U+FFFD.
Returns the length in code units () of the
UTF-16 sequence required to represent this scalar value.
The return value will be 1 or 2.
Returns the length in code units of the
UTF-8 sequence required to represent this scalar value.
The return value will be 1 through 4, inclusive.
Returns the Unicode scalar value as an integer.
Decodes the at the beginning of the provided UTF-16 source buffer.
If the source buffer begins with a valid UTF-16 encoded scalar value, returns ,
and outs via the decoded and via the
number of s used in the input buffer to encode the .
If the source buffer is empty or contains only a standalone UTF-16 high surrogate character, returns ,
and outs via and via the length of the input buffer.
If the source buffer begins with an ill-formed UTF-16 encoded scalar value, returns ,
and outs via and via the number of
s used in the input buffer to encode the ill-formed sequence.
The general calling convention is to call this method in a loop, slicing the buffer by
elements on each iteration of the loop. On each iteration of the loop
will contain the real scalar value if successfully decoded, or it will contain if
the data could not be successfully decoded. This pattern provides convenient automatic U+FFFD substitution of
invalid sequences while iterating through the loop.
Decodes the at the beginning of the provided UTF-8 source buffer.
If the source buffer begins with a valid UTF-8 encoded scalar value, returns ,
and outs via the decoded and via the
number of s used in the input buffer to encode the .
If the source buffer is empty or contains only a partial UTF-8 subsequence, returns ,
and outs via and via the length of the input buffer.
If the source buffer begins with an ill-formed UTF-8 encoded scalar value, returns ,
and outs via and via the number of
s used in the input buffer to encode the ill-formed sequence.
The general calling convention is to call this method in a loop, slicing the buffer by
elements on each iteration of the loop. On each iteration of the loop
will contain the real scalar value if successfully decoded, or it will contain if
the data could not be successfully decoded. This pattern provides convenient automatic U+FFFD substitution of
invalid sequences while iterating through the loop.
Decodes the at the end of the provided UTF-16 source buffer.
This method is very similar to , but it allows
the caller to loop backward instead of forward. The typical calling convention is that on each iteration
of the loop, the caller should slice off the final elements of
the buffer.
Decodes the at the end of the provided UTF-8 source buffer.
This method is very similar to , but it allows
the caller to loop backward instead of forward. The typical calling convention is that on each iteration
of the loop, the caller should slice off the final elements of
the buffer.
Encodes this to a UTF-16 destination buffer.
The buffer to which to write this value as UTF-16.
The number of s written to .
If is not large enough to hold the output.
Encodes this to a UTF-8 destination buffer.
The buffer to which to write this value as UTF-8.
The number of s written to .
If is not large enough to hold the output.
Returns a value that indicates whether the current instance and a specified rune are equal using the specified comparison option.
The rune to compare with the current instance.
One of the enumeration values that specifies the rules to use in the comparison.
if the current instance and are equal; otherwise, .
Returns iff is a valid Unicode scalar
value, i.e., is in [ U+0000..U+D7FF ], inclusive; or [ U+E000..U+10FFFF ], inclusive.
Returns iff is a valid Unicode scalar
value, i.e., is in [ U+0000..U+D7FF ], inclusive; or [ U+E000..U+10FFFF ], inclusive.
Returns a representation of this instance.
Attempts to create a from the provided input value.
Attempts to create a from the provided UTF-16 surrogate pair.
Returns if the input values don't represent a well-formed UTF-16surrogate pair.
Attempts to create a from the provided input value.
Attempts to create a from the provided input value.
Encodes this to a UTF-16 destination buffer.
The buffer to which to write this value as UTF-16.
The number of s written to ,
or 0 if the destination buffer is not large enough to contain the output.
True if the value was written to the buffer; otherwise, false.
The property can be queried ahead of time to determine
the required size of the buffer.
Encodes this to a destination buffer as UTF-8 bytes.
The buffer to which to write this value as UTF-8.
The number of s written to ,
or 0 if the destination buffer is not large enough to contain the output.
True if the value was written to the buffer; otherwise, false.
The property can be queried ahead of time to determine
the required size of the buffer.
Creates a without performing validation on the input.
Formats a code point as the hex string "U+XXXX".
The input value doesn't have to be a real code point in the Unicode codespace. It can be any integer.
The Unicode replacement character U+FFFD.
Returns the Unicode plane (0 through 16, inclusive) which contains this code point.
Returns a Unicode scalar value from two code points representing a UTF-16 surrogate pair.
Given a Unicode scalar value, gets the number of UTF-16 code units required to represent this value.
Decomposes an astral Unicode scalar into UTF-16 high and low surrogate code units.
Given a Unicode scalar value, gets the number of UTF-8 code units required to represent this value.
Returns iff is an ASCII
character ([ U+0000..U+007F ]).
Per http://www.unicode.org/glossary/#ASCII, ASCII is only U+0000..U+007F.
Returns iff is in the
Basic Multilingual Plane (BMP).
Returns iff is a UTF-16 high surrogate code point,
i.e., is in [ U+D800..U+DBFF ], inclusive.
Returns iff is between
and , inclusive.
Returns iff is a UTF-16 low surrogate code point,
i.e., is in [ U+DC00..U+DFFF ], inclusive.
Returns iff is a UTF-16 surrogate code point,
i.e., is in [ U+D800..U+DFFF ], inclusive.
Returns iff is a valid Unicode code
point, i.e., is in [ U+0000..U+10FFFF ], inclusive.
Returns iff is a valid Unicode scalar
value, i.e., is in [ U+0000..U+D7FF ], inclusive; or [ U+E000..U+10FFFF ], inclusive.
Returns true iff the UInt32 represents two ASCII UTF-16 characters in machine endianness.
Returns true iff the UInt64 represents four ASCII UTF-16 characters in machine endianness.
Given a UInt32 that represents two ASCII UTF-16 characters, returns the invariant
lowercase representation of those characters. Requires the input value to contain
two ASCII UTF-16 characters in machine endianness.
This is a branchless implementation.
Given a UInt32 that represents two ASCII UTF-16 characters, returns the invariant
uppercase representation of those characters. Requires the input value to contain
two ASCII UTF-16 characters in machine endianness.
This is a branchless implementation.
Given a UInt64 that represents four ASCII UTF-16 characters, returns the invariant
uppercase representation of those characters. Requires the input value to contain
four ASCII UTF-16 characters in machine endianness.
This is a branchless implementation.
Given a UInt64 that represents four ASCII UTF-16 characters, returns the invariant
lowercase representation of those characters. Requires the input value to contain
four ASCII UTF-16 characters in machine endianness.
This is a branchless implementation.
Given a UInt32 that represents two ASCII UTF-16 characters, returns true iff
the input contains one or more lowercase ASCII characters.
This is a branchless implementation.
Given a UInt32 that represents two ASCII UTF-16 characters, returns true iff
the input contains one or more uppercase ASCII characters.
This is a branchless implementation.
Given two UInt32s that represent two ASCII UTF-16 characters each, returns true iff
the two inputs are equal using an ordinal case-insensitive comparison.
This is a branchless implementation.
Given two UInt64s that represent four ASCII UTF-16 characters each, returns true iff
the two inputs are equal using an ordinal case-insensitive comparison.
This is a branchless implementation.
Provides static methods that convert chunked data between UTF-8 and UTF-16 encodings.
Transcodes the UTF-16 buffer to as UTF-8.
If is , invalid UTF-16 sequences
in will be replaced with U+FFFD in , and
this method will not return .
Transcodes the UTF-8 buffer to as UTF-16.
If is , invalid UTF-8 sequences
in will be replaced with U+FFFD in , and
this method will not return .
Validates that the value is well-formed UTF-8.
The string.
true if value is well-formed UTF-8, false otherwise.
The maximum number of bytes that can result from UTF-8 transcoding
any Unicode scalar value.
Returns the byte index in where the first invalid UTF-8 sequence begins,
or -1 if the buffer contains no invalid sequences. Also outs the parameter
stating whether all data observed (up to the first invalid sequence or the end of the buffer, whichever
comes first) is ASCII.
Returns true iff the UInt32 represents four ASCII UTF-8 characters in machine endianness.
Returns true iff the UInt64 represents eighty ASCII UTF-8 characters in machine endianness.
Given a UInt32 that represents four ASCII UTF-8 characters, returns the invariant
lowercase representation of those characters. Requires the input value to contain
four ASCII UTF-8 characters in machine endianness.
This is a branchless implementation.
Given a UInt32 that represents four ASCII UTF-8 characters, returns the invariant
uppercase representation of those characters. Requires the input value to contain
four ASCII UTF-8 characters in machine endianness.
This is a branchless implementation.
Given a UInt64 that represents eight ASCII UTF-8 characters, returns the invariant
uppercase representation of those characters. Requires the input value to contain
eight ASCII UTF-8 characters in machine endianness.
This is a branchless implementation.
Given a UInt64 that represents eight ASCII UTF-8 characters, returns the invariant
uppercase representation of those characters. Requires the input value to contain
eight ASCII UTF-8 characters in machine endianness.
This is a branchless implementation.
Given two UInt32s that represent four ASCII UTF-8 characters each, returns true iff
the two inputs are equal using an ordinal case-insensitive comparison.
This is a branchless implementation.
Given two UInt64s that represent eight ASCII UTF-8 characters each, returns true iff
the two inputs are equal using an ordinal case-insensitive comparison.
This is a branchless implementation.
Given a machine-endian DWORD which four bytes of UTF-8 data, interprets the
first three bytes as a three-byte UTF-8 subsequence and returns the UTF-16 representation.
Given a machine-endian DWORD which four bytes of UTF-8 data, interprets the
first two bytes as a two-byte UTF-8 subsequence and returns the UTF-16 representation.
Given a machine-endian DWORD which represents four bytes of UTF-8 data, interprets the input as a
four-byte UTF-8 sequence and returns the machine-endian DWORD of the UTF-16 representation.
Given a 32-bit integer that represents a valid packed UTF-16 surrogate pair, all in machine-endian order,
returns the packed 4-byte UTF-8 representation of this scalar value, also in machine-endian order.
Given a machine-endian DWORD which represents two adjacent UTF-8 two-byte sequences,
returns the machine-endian DWORD representation of that same data as two adjacent
UTF-16 byte sequences.
Given a machine-endian DWORD which represents two adjacent UTF-16 sequences,
returns the machine-endian DWORD representation of that same data as two
adjacent UTF-8 two-byte sequences.
Given a machine-endian DWORD which represents two adjacent UTF-16 sequences,
returns the machine-endian DWORD representation of the first UTF-16 char
as a UTF-8 two-byte sequence packed into a WORD and zero-extended to DWORD.
Given a 32-bit integer that represents two packed UTF-16 characters, all in machine-endian order,
returns true iff the first UTF-16 character is ASCII.
Given a 32-bit integer that represents two packed UTF-16 characters, all in machine-endian order,
returns true iff the first UTF-16 character requires *at least* 3 bytes to encode in UTF-8.
This also returns true if the first UTF-16 character is a surrogate character (well-formedness is not validated).
Given a 32-bit integer that represents two packed UTF-16 characters, all in machine-endian order,
returns true iff the first UTF-16 character is a surrogate character (either high or low).
Given a 32-bit integer that represents two packed UTF-16 characters, all in machine-endian order,
returns true iff the first UTF-16 character would be encoded as exactly 2 bytes in UTF-8.
Returns iff the low byte of
is a UTF-8 continuation byte.
Given a 32-bit integer that represents two packed UTF-16 characters, all in machine-endian order,
returns true iff the second UTF-16 character is ASCII.
Given a 32-bit integer that represents two packed UTF-16 characters, all in machine-endian order,
returns true iff the second UTF-16 character requires *at least* 3 bytes to encode in UTF-8.
This also returns true if the second UTF-16 character is a surrogate character (well-formedness is not validated).
Given a 32-bit integer that represents two packed UTF-16 characters, all in machine-endian order,
returns true iff the second UTF-16 character is a surrogate character (either high or low).
Given a 32-bit integer that represents two packed UTF-16 characters, all in machine-endian order,
returns true iff the second UTF-16 character would be encoded as exactly 2 bytes in UTF-8.
Returns iff is a UTF-8 continuation byte;
i.e., has binary representation 10xxxxxx, where x is any bit.
Given a 32-bit integer that represents two packed UTF-16 characters, all in machine-endian order,
returns true iff the two characters represent a well-formed UTF-16 surrogate pair.
Converts a DWORD from machine-endian to little-endian.
Given a UTF-8 buffer which has been read into a DWORD in machine endianness,
returns iff the first two bytes of the buffer are
an overlong representation of a sequence that should be represented as one byte.
This method *does not* validate that the sequence matches the appropriate
2-byte sequence mask (see ).
Given a UTF-8 buffer which has been read into a DWORD in machine endianness,
returns iff the first four bytes of the buffer match
the UTF-8 4-byte sequence mask [ 11110www 10zzzzzz 10yyyyyy 10xxxxxx ]. This
method *does not* validate that the sequence is well-formed; the caller must
still perform overlong form or out-of-range checking.
Given a UTF-8 buffer which has been read into a DWORD in machine endianness,
returns iff the first three bytes of the buffer match
the UTF-8 3-byte sequence mask [ 1110zzzz 10yyyyyy 10xxxxxx ]. This method *does not*
validate that the sequence is well-formed; the caller must still perform
overlong form or surrogate checking.
Given a UTF-8 buffer which has been read into a DWORD in machine endianness,
returns iff the first two bytes of the buffer match
the UTF-8 2-byte sequence mask [ 110yyyyy 10xxxxxx ]. This method *does not*
validate that the sequence is well-formed; the caller must still perform
overlong form checking.
Given a UTF-8 buffer which has been read into a DWORD in machine endianness,
returns iff the first two bytes of the buffer are
an overlong representation of a sequence that should be represented as one byte.
This method *does not* validate that the sequence matches the appropriate
2-byte sequence mask (see ).
Given a UTF-8 buffer which has been read into a DWORD in machine endianness,
returns iff the last two bytes of the buffer match
the UTF-8 2-byte sequence mask [ 110yyyyy 10xxxxxx ]. This method *does not*
validate that the sequence is well-formed; the caller must still perform
overlong form checking.
Given a UTF-8 buffer which has been read into a DWORD on a little-endian machine,
returns iff the first two bytes of the buffer are a well-formed
UTF-8 two-byte sequence. This wraps the mask check and the overlong check into a
single operation. Returns if running on a big-endian machine.
Given a UTF-8 buffer which has been read into a DWORD on a little-endian machine,
returns iff the last two bytes of the buffer are a well-formed
UTF-8 two-byte sequence. This wraps the mask check and the overlong check into a
single operation. Returns if running on a big-endian machine.
Given a UTF-8 buffer which has been read into a DWORD in machine endianness,
returns iff the first byte of the buffer is ASCII.
Given a UTF-8 buffer which has been read into a DWORD in machine endianness,
returns iff the fourth byte of the buffer is ASCII.
Given a UTF-8 buffer which has been read into a DWORD in machine endianness,
returns iff the second byte of the buffer is ASCII.
Given a UTF-8 buffer which has been read into a DWORD in machine endianness,
returns iff the third byte of the buffer is ASCII.
Given a DWORD which represents a buffer of 2 packed UTF-16 values in machine endianness,
converts those scalar values to their 3-byte UTF-8 representation and writes the
resulting 6 bytes to the destination buffer.
Given a DWORD which represents a buffer of 2 packed UTF-16 values in machine endianness,
converts the first UTF-16 value to its 3-byte UTF-8 representation and writes the
resulting 3 bytes to the destination buffer.
Given an input buffer of byte length ,
returns a pointer to where the first invalid data appears in .
Returns a pointer to the end of if the buffer is well-formed.
Represent a type can be used to index a collection either from the start or the end.
Index is used by the C# compiler to support the new index syntax
int[] someArray = new int[5] { 1, 2, 3, 4, 5 } ;
int lastElement = someArray[^1]; // lastElement = 5
Construct an Index using a value and indicating if the index is from the start or from the end.
The index value. it has to be zero or positive number.
Indicating if the index is from the start or from the end.
If the Index constructed from the end, index value 1 means pointing at the last element and index value 0 means pointing at beyond last element.
Create an Index pointing at first element.
Create an Index pointing at beyond last element.
Create an Index from the start at the position indicated by the value.
The index value from the start.
Create an Index from the end at the position indicated by the value.
The index value from the end.
Returns the index value.
Indicates whether the index is from the start or the end.
Calculate the offset from the start using the giving collection length.
The length of the collection that the Index will be used with. length has to be a positive value
For performance reason, we don't validate the input length parameter and the returned offset value against negative values.
we don't validate either the returned offset is greater than the input length.
It is expected Index will be used with collections which always have non negative length/count. If the returned offset is negative and
then used to index a collection will get out of range exception which will be same affect as the validation.
Indicates whether the current Index object is equal to another object of the same type.
An object to compare with this object
Indicates whether the current Index object is equal to another Index object.
An object to compare with this object
Returns the hash code for this instance.
Converts integer number to an Index.
Converts the value of the current Index object to its equivalent string representation.
Represent a range has start and end indexes.
Range is used by the C# compiler to support the range syntax.
int[] someArray = new int[5] { 1, 2, 3, 4, 5 };
int[] subArray1 = someArray[0..2]; // { 1, 2 }
int[] subArray2 = someArray[1..^0]; // { 2, 3, 4, 5 }
Represent the inclusive start index of the Range.
Represent the exclusive end index of the Range.
Construct a Range object using the start and end indexes.
Represent the inclusive start index of the range.
Represent the exclusive end index of the range.
Indicates whether the current Range object is equal to another object of the same type.
An object to compare with this object
Indicates whether the current Range object is equal to another Range object.
An object to compare with this object
Returns the hash code for this instance.
Converts the value of the current Range object to its equivalent string representation.
Create a Range object starting from start index to the end of the collection.
Create a Range object starting from first element in the collection to the end Index.
Create a Range object starting from first element to the end.
Calculate the start offset and length of range object using a collection length.
The length of the collection that the range will be used with. length has to be a positive value.
For performance reason, we don't validate the input length parameter against negative values.
It is expected Range will be used with collections which always have non negative length/count.
We validate the range is inside the length scope though.
Destination is too short.
The input is not a valid Base64Url string as it contains a non-Base64Url character, more than two padding characters, or an illegal character among the padding characters.
Attribute used to indicate a source generator should create a function for marshalling
arguments instead of relying on the runtime to generate an equivalent marshalling function at run-time.
This attribute is meaningless if the source generator associated with it is not enabled.
The current built-in source generator only supports C# and only supplies an implementation when
applied to static, partial, non-generic methods.
Initializes a new instance of the .
Name of the library containing the import.
Gets the name of the library containing the import.
Gets or sets the name of the entry point to be called.
Gets or sets how to marshal string arguments to the method.
If this field is set to a value other than ,
must not be specified.
Gets or sets the used to control how string arguments to the method are marshalled.
If this field is specified, must not be specified
or must be set to .
Gets or sets whether the callee sets an error (SetLastError on Windows or errno
on other platforms) before returning from the attributed method.
Specifies how strings should be marshalled for generated p/invokes
Indicates the user is supplying a specific marshaller in .
Use the platform-provided UTF-8 marshaller.
Use the platform-provided UTF-16 marshaller.
Provides downlevel polyfills for static methods on Exception-derived types.