//TODO: this should use ByteSpan public void Append(ReadOnlySpan<char> substring) { for (int i = 0; i < substring.Length; i++) { Append(substring[i]); } }
public static void DangerousGetPinnableReferenceArray() { int[] a = { 91, 92, 93, 94, 95 }; ReadOnlySpan<int> span = new ReadOnlySpan<int>(a, 1, 3); ref int pinnableReference = ref span.DangerousGetPinnableReference(); Assert.True(Unsafe.AreSame<int>(ref a[1], ref pinnableReference)); }
private static bool IsFalse(ReadOnlySpan<char> utf16Chars) { if (utf16Chars.Length < 5) return false; char firstChar = utf16Chars[0]; if (firstChar != 'f' && firstChar != 'F') return false; char secondChar = utf16Chars[1]; if (secondChar != 'a' && secondChar != 'A') return false; char thirdChar = utf16Chars[2]; if (thirdChar != 'l' && thirdChar != 'L') return false; char fourthChar = utf16Chars[3]; if (fourthChar != 's' && fourthChar != 'S') return false; char fifthChar = utf16Chars[4]; if (fifthChar != 'e' && fifthChar != 'E') return false; return true; }
internal JsonObject(ReadOnlySpan<byte> values, ReadOnlySpan<byte> db, BufferPool pool = null, OwnedMemory<byte> dbMemory = null) { _db = db; _values = values; _pool = pool; _dbMemory = dbMemory; }
/// <summary> /// /// </summary> /// <param name="source"></param> /// <param name="destination"></param> /// <returns>Number of bytes written to the destination.</returns> public static int Encode(ReadOnlySpan<byte> source, Span<byte> destination) { int di = 0; int si = 0; byte b0, b1, b2, b3; for (; si<source.Length - 2;) { var result = Encode(source.Slice(si)); si += 3; destination.Slice(di).Write(result); di += 4; } if (si == source.Length - 1) { Encode(source[si], 0, 0, out b0, out b1, out b2, out b3); destination[di++] = b0; destination[di++] = b1; destination[di++] = s_encodingMap[64]; destination[di++] = s_encodingMap[64]; } else if(si == source.Length - 2) { Encode(source[si++], source[si], 0, out b0, out b1, out b2, out b3); destination[di++] = b0; destination[di++] = b1; destination[di++] = b2; destination[di++] = s_encodingMap[64]; } return di; }
public static void CtorArrayIntStartEqualsLength() { // Valid for start to equal the array length. This returns an empty span that starts "just past the array." int[] a = { 91, 92, 93 }; ReadOnlySpan<int> span = new ReadOnlySpan<int>(a, 3); span.Validate<int>(); }
// TODO: format should be ReadOnlySpan<T> public static Format.Parsed Parse(ReadOnlySpan<char> format) { if (format.Length == 0) { return default(Format.Parsed); } uint precision = NoPrecision; if (format.Length > 1) { var span = format.Slice(1, format.Length - 1); if (!PrimitiveParser.TryParseUInt32(span, out precision)) { throw new NotImplementedException("UnableToParsePrecision"); } if (precision > Parsed.MaxPrecision) { // TODO: this is a contract violation throw new Exception("PrecisionValueOutOfRange"); } } // TODO: this is duplicated from above. It needs to be refactored var specifier = format[0]; return new Parsed(specifier, (byte)precision); }
// TODO: format should be ReadOnlySpan<char> internal static bool TryFormatInt64(long value, byte numberOfBytes, Span<byte> buffer, ReadOnlySpan<char> format, EncodingData formattingData, out int bytesWritten) { Precondition.Require(numberOfBytes <= sizeof(long)); TextFormat parsedFormat = TextFormat.Parse(format); return TryFormatInt64(value, numberOfBytes, buffer, parsedFormat, formattingData, out bytesWritten); }
public static void SliceIntIntPastEnd() { int[] a = { 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 }; ReadOnlySpan<int> span = new ReadOnlySpan<int>(a).Slice(a.Length, 0); Assert.Equal(0, span.Length); Assert.True(Unsafe.AreSame<int>(ref a[a.Length - 1], ref Unsafe.Subtract<int>(ref span.DangerousGetPinnableReference(), 1))); }
public void TwoReadOnlySpansCreatedOverSameIntArrayAreEqual() { for (int i = 0; i < 2; i++) { var ints = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // Try out two ways of creating a slice: ReadOnlySpan<int> slice; if (i == 0) { slice = new ReadOnlySpan<int>(ints); } else { slice = ints.Slice(); } Assert.Equal(ints.Length, slice.Length); // Now try out two ways of walking the slice's contents: for (int j = 0; j < ints.Length; j++) { Assert.Equal(ints[j], slice[j]); } { int j = 0; foreach (var x in slice) { Assert.Equal(ints[j], x); j++; } } } }
public static void SliceIntIntUpToEnd() { int[] a = { 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 }; ReadOnlySpan<int> span = new ReadOnlySpan<int>(a).Slice(4, 6); Assert.Equal(6, span.Length); Assert.True(Unsafe.AreSame<int>(ref a[4], ref span.DangerousGetPinnableReference())); }
public void CtorReadOnlySpanOverByteArrayValidCasesWithPropertiesAndBasicOperationsChecks(byte[] array) { ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(array); Assert.Equal(array.Length, span.Length); Assert.NotSame(array, span.CreateArray()); Assert.False(span.Equals(array)); ReadOnlySpan<byte>.Enumerator it = span.GetEnumerator(); for (int i = 0; i < span.Length; i++) { Assert.True(it.MoveNext()); Assert.Equal(array[i], it.Current); Assert.Equal(array[i], span.Slice(i).Read<byte>()); Assert.Equal(array[i], span.Slice(i).Read<MyByte>().Value); array[i] = unchecked((byte)(array[i] + 1)); Assert.Equal(array[i], it.Current); Assert.Equal(array[i], span.Slice(i).Read<byte>()); Assert.Equal(array[i], span.Slice(i).Read<MyByte>().Value); } Assert.False(it.MoveNext()); it.Reset(); for (int i = 0; i < span.Length; i++) { Assert.True(it.MoveNext()); Assert.Equal(array[i], it.Current); } Assert.False(it.MoveNext()); }
public unsafe void ByteReadOnlySpanEqualsTestsTwoDifferentInstancesOfBuffersWithOneValueDifferent() { const int bufferLength = 128; byte[] buffer1 = new byte[bufferLength]; byte[] buffer2 = new byte[bufferLength]; for (int i = 0; i < bufferLength; i++) { buffer1[i] = (byte)(bufferLength + 1 - i); buffer2[i] = (byte)(bufferLength + 1 - i); } fixed (byte* buffer1pinned = buffer1) fixed (byte* buffer2pinned = buffer2) { ReadOnlySpan<byte> b1 = new ReadOnlySpan<byte>(buffer1pinned, bufferLength); ReadOnlySpan<byte> b2 = new ReadOnlySpan<byte>(buffer2pinned, bufferLength); for (int i = 0; i < bufferLength; i++) { for (int diffPosition = i; diffPosition < bufferLength; diffPosition++) { buffer1[diffPosition] = unchecked((byte)(buffer1[diffPosition] + 1)); Assert.False(b1.Slice(i).SequenceEqual(b2.Slice(i))); } } } }
public unsafe static bool TryParseUInt16(char* text, int length, out ushort value, out int charactersConsumed) { var span = new ReadOnlySpan<byte>(text, length * sizeof(char)); int bytesConsumed; bool result = PrimitiveParser.TryParseUInt16(span, out value, out bytesConsumed, EncodingData.InvariantUtf16, 'X'); charactersConsumed = bytesConsumed / sizeof(char); return result; }
public static bool TryParseBoolean(ReadOnlySpan<char> text, out bool value, out int charactersConsumed) { var byteSpan = text.Cast<char, byte>(); int bytesConsumed; bool result = PrimitiveParser.TryParseBoolean(byteSpan, out value, out bytesConsumed, EncodingData.InvariantUtf16); charactersConsumed = bytesConsumed / 2; return result; }
public static int GetByteCount(ReadOnlySpan buffer) { var count = 0; foreach (var x in buffer) if ((x & 0b1100_0000) != 0b1000_0000) count++; return count; }
public static void ToArray1() { int[] a = { 91, 92, 93 }; ReadOnlySpan<int> span = new ReadOnlySpan<int>(a); int[] copy = span.ToArray(); Assert.Equal<int>(a, copy); Assert.NotSame(a, copy); }
// Helper methods similar to System.ArrayExtension: // String helper methods, offering methods like String on Slice<char>: // TODO(joe): culture-sensitive comparisons. // TODO: should these move to string/text related assembly public static bool Contains(this ReadOnlySpan<char> str, ReadOnlySpan<char> value) { if (value.Length > str.Length) { return false; } return str.IndexOf(value) >= 0; }
public unsafe static bool TryParseBoolean(char* text, int length, out bool value, out int charactersConsumed) { var span = new ReadOnlySpan<byte>(text, length * 2); int bytesConsumed; bool result = PrimitiveParser.TryParseBoolean(span, out value, out bytesConsumed, EncodingData.InvariantUtf16); charactersConsumed = bytesConsumed / 2; return result; }
public static bool TryParseUInt16(ReadOnlySpan<char> text, out ushort value, out int charactersConsumed) { var byteSpan = text.Cast<char, byte>(); int bytesConsumed; bool result = PrimitiveParser.TryParseUInt16(byteSpan, out value, out bytesConsumed, EncodingData.InvariantUtf16, 'X'); charactersConsumed = bytesConsumed / sizeof(char); return result; }
public static void EqualityReflexivity() { int[] a = { 91, 92, 93, 94, 95 }; ReadOnlySpan<int> left = new ReadOnlySpan<int>(a, 2, 3); Assert.True(left == left); Assert.True(!(left != left)); }
public static void EqualityComparesRangeNotContent() { ReadOnlySpan<int> left = new ReadOnlySpan<int>(new int[] { 0, 1, 2 }, 1, 1); ReadOnlySpan<int> right = new ReadOnlySpan<int>(new int[] { 0, 1, 2 }, 1, 1); Assert.False(left == right); Assert.False(!(left != right)); }
public static void EmptySpansNotUnified() { ReadOnlySpan<int> left = new ReadOnlySpan<int>(new int[0]); ReadOnlySpan<int> right = new ReadOnlySpan<int>(new int[0]); Assert.False(left == right); Assert.False(!(left != right)); }
public static void CtorPointerNull() { unsafe { ReadOnlySpan<int> span = new ReadOnlySpan<int>((void*)null, 0); span.Validate<int>(); Assert.True(Unsafe.AreSame<int>(ref Unsafe.AsRef<int>((void*)null), ref span.DangerousGetPinnableReference())); } }
public static void EqualityIncludesBase() { int[] a = { 91, 92, 93, 94, 95 }; ReadOnlySpan<int> left = new ReadOnlySpan<int>(a, 1, 3); ReadOnlySpan<int> right = new ReadOnlySpan<int>(a, 2, 3); Assert.False(left == right); Assert.False(!(left != right)); }
public static void AsBytesUIntToByte() { uint[] a = { 0x44332211, 0x88776655 }; ReadOnlySpan<uint> span = new ReadOnlySpan<uint>(a); ReadOnlySpan<byte> asBytes = span.AsBytes<uint>(); Assert.True(Unsafe.AreSame<byte>(ref Unsafe.As<uint, byte>(ref span.DangerousGetPinnableReference()), ref asBytes.DangerousGetPinnableReference())); asBytes.Validate<byte>(0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88); }
public static void PortableCastUIntToUShort() { uint[] a = { 0x44332211, 0x88776655 }; ReadOnlySpan<uint> span = new ReadOnlySpan<uint>(a); ReadOnlySpan<ushort> asUShort = span.NonPortableCast<uint, ushort>(); Assert.True(Unsafe.AreSame<ushort>(ref Unsafe.As<uint, ushort>(ref span.DangerousGetPinnableReference()), ref asUShort.DangerousGetPinnableReference())); asUShort.Validate<ushort>(0x2211, 0x4433, 0x6655, 0x8877); }
public static bool TryParse(ReadOnlySpan<byte> text, FormattingData.Encoding encoding, out uint value, out int bytesConsumed) { Precondition.Require(text.Length > 0); Precondition.Require(encoding == FormattingData.Encoding.Utf8 || text.Length > 1); value = 0; bytesConsumed = 0; if (text[0] == '0') { if (encoding == FormattingData.Encoding.Utf16) { bytesConsumed = 2; return text[1] == 0; } bytesConsumed = 1; return true; } for (int byteIndex = 0; byteIndex < text.Length; byteIndex++) { byte nextByte = text[byteIndex]; if (nextByte < '0' || nextByte > '9') { if (bytesConsumed == 0) { value = default(uint); return false; } else { return true; } } uint candidate = value * 10; candidate += (uint)nextByte - '0'; if (candidate > value) { value = candidate; } else { return true; } bytesConsumed++; if (encoding == FormattingData.Encoding.Utf16) { byteIndex++; if (byteIndex >= text.Length || text[byteIndex] != 0) { return false; } bytesConsumed++; } } return true; }
public static void TryCopyTo() { int[] src = { 1, 2, 3 }; int[] dst = { 99, 100, 101 }; ReadOnlySpan<int> srcSpan = new ReadOnlySpan<int>(src); bool success = srcSpan.TryCopyTo(dst); Assert.True(success); Assert.Equal<int>(src, dst); }
public static void CopyToShorter() { int[] src = { 1, 2, 3 }; int[] dst = { 99, 100 }; ReadOnlySpan<int> srcSpan = new ReadOnlySpan<int>(src); AssertThrows<ArgumentException, int>(srcSpan, (_srcSpan) => _srcSpan.CopyTo(dst)); int[] expected = { 99, 100 }; Assert.Equal<int>(expected, dst); // CopyTo() checks for sufficient space before doing any copying. }
public new bool TryHashData(ReadOnlySpan <byte> source, Span <byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten) => base.TryHashData(source, destination, hashAlgorithm, out bytesWritten);
private bool TryPinAsTensor <T>( out MemoryHandle pinnedMemoryHandle, out IntPtr dataBufferPointer, out int dataBufferLength, out ReadOnlySpan <int> shape, out int rank, out TensorElementType nativeElementType ) { nativeElementType = TensorElementType.DataTypeMax; //invalid dataBufferPointer = IntPtr.Zero; dataBufferLength = 0; shape = null; rank = 0; pinnedMemoryHandle = default; Debug.Assert(typeof(T) != typeof(string), "NamedOnnxValue.TryPinAsTensor() must not be called with a string Tensor value"); if (_value is Tensor <T> ) { Tensor <T> t = _value as Tensor <T>; if (t.IsReversedStride) { //TODO: not sure how to support reverse stride. may be able to calculate the shape differently throw new NotSupportedException(nameof(Tensor <T>) + " of reverseStride is not supported"); } DenseTensor <T> dt = null; if (_value is DenseTensor <T> ) { dt = _value as DenseTensor <T>; } else { dt = t.ToDenseTensor(); } shape = dt.Dimensions; // does not work for reverse stride rank = dt.Rank; pinnedMemoryHandle = dt.Buffer.Pin(); unsafe { dataBufferPointer = (IntPtr)pinnedMemoryHandle.Pointer; } // find the native type if (typeof(T) == typeof(float)) { nativeElementType = TensorElementType.Float; dataBufferLength = dt.Buffer.Length * sizeof(float); } else if (typeof(T) == typeof(double)) { nativeElementType = TensorElementType.Double; dataBufferLength = dt.Buffer.Length * sizeof(double); } else if (typeof(T) == typeof(int)) { nativeElementType = TensorElementType.Int32; dataBufferLength = dt.Buffer.Length * sizeof(int); } else if (typeof(T) == typeof(uint)) { nativeElementType = TensorElementType.UInt32; dataBufferLength = dt.Buffer.Length * sizeof(uint); } else if (typeof(T) == typeof(long)) { nativeElementType = TensorElementType.Int64; dataBufferLength = dt.Buffer.Length * sizeof(long); } else if (typeof(T) == typeof(ulong)) { nativeElementType = TensorElementType.UInt64; dataBufferLength = dt.Buffer.Length * sizeof(ulong); } else if (typeof(T) == typeof(short)) { nativeElementType = TensorElementType.Int16; dataBufferLength = dt.Buffer.Length * sizeof(short); } else if (typeof(T) == typeof(ushort)) { nativeElementType = TensorElementType.UInt16; dataBufferLength = dt.Buffer.Length * sizeof(ushort); } else if (typeof(T) == typeof(byte)) { nativeElementType = TensorElementType.UInt8; dataBufferLength = dt.Buffer.Length * sizeof(byte); } else if (typeof(T) == typeof(sbyte)) { nativeElementType = TensorElementType.Int8; dataBufferLength = dt.Buffer.Length * sizeof(sbyte); } else if (typeof(T) == typeof(string)) { nativeElementType = TensorElementType.String; dataBufferLength = dt.Buffer.Length * IntPtr.Size; } else if (typeof(T) == typeof(bool)) { nativeElementType = TensorElementType.Bool; dataBufferLength = dt.Buffer.Length * sizeof(bool); // Assumes sizeof(BOOL) is always 1 byte in native } else { //TODO: may extend the supported types // do not throw exception, rather assign the sentinel value nativeElementType = TensorElementType.DataTypeMax; } return(true); } return(false); }
public static bool IsPathRooted(ReadOnlySpan <char> path) { return(path.Length > 0 && path[0] == PathInternal.DirectorySeparatorChar); }
/// <inheritdoc /> public ReadOnlySpan <byte> TransformBlock(ReadOnlySpan <byte> block) { return(block); }
/// <summary> /// Attempts to Pin the buffer, and create a native OnnxValue out of it. the pinned MemoryHandle is passed to output. /// In this case, the pinnedHandle should be kept alive till the native OnnxValue is used, then dispose it. /// If it is not possible to Pin the buffer, then creates OnnxValue from the copy of the data. The output pinnedMemoryHandle /// contains a default value in that case. /// Attempts to infer the type of the value while creating the OnnxValue /// </summary> /// <param name="onnxValue"></param> /// <param name="pinnedMemoryHandle"></param> unsafe internal void ToNativeOnnxValue(out IntPtr onnxValue, out MemoryHandle pinnedMemoryHandle) { //try to cast _value to Tensor<T> TensorElementType nativeElementType = TensorElementType.DataTypeMax; //invalid IntPtr dataBufferPointer = IntPtr.Zero; int dataBufferLength = 0; ReadOnlySpan <int> shape = null; int rank = 0; onnxValue = IntPtr.Zero; if (TryPinAsTensor <float>(out pinnedMemoryHandle, out dataBufferPointer, out dataBufferLength, out shape, out rank, out nativeElementType )) { } else if (TryPinAsTensor <double>(out pinnedMemoryHandle, out dataBufferPointer, out dataBufferLength, out shape, out rank, out nativeElementType )) { } else if (TryPinAsTensor <int>(out pinnedMemoryHandle, out dataBufferPointer, out dataBufferLength, out shape, out rank, out nativeElementType )) { } else if (TryPinAsTensor <uint>(out pinnedMemoryHandle, out dataBufferPointer, out dataBufferLength, out shape, out rank, out nativeElementType )) { } else if (TryPinAsTensor <long>(out pinnedMemoryHandle, out dataBufferPointer, out dataBufferLength, out shape, out rank, out nativeElementType )) { } else if (TryPinAsTensor <ulong>(out pinnedMemoryHandle, out dataBufferPointer, out dataBufferLength, out shape, out rank, out nativeElementType )) { } else if (TryPinAsTensor <short>(out pinnedMemoryHandle, out dataBufferPointer, out dataBufferLength, out shape, out rank, out nativeElementType )) { } else if (TryPinAsTensor <ushort>(out pinnedMemoryHandle, out dataBufferPointer, out dataBufferLength, out shape, out rank, out nativeElementType )) { } else if (TryPinAsTensor <byte>(out pinnedMemoryHandle, out dataBufferPointer, out dataBufferLength, out shape, out rank, out nativeElementType )) { } else if (TryPinAsTensor <sbyte>(out pinnedMemoryHandle, out dataBufferPointer, out dataBufferLength, out shape, out rank, out nativeElementType )) { } else if (TryPinAsTensor <bool>(out pinnedMemoryHandle, out dataBufferPointer, out dataBufferLength, out shape, out rank, out nativeElementType )) { } //TODO: add other types // special case for string Tensor, data needs to be copied to the native buffer else if (!(_value is Tensor <string>)) { // nothing to cleanup here, since no memory has been pinned throw new NotSupportedException("The inference value " + nameof(_value) + " is not of a supported type"); } if (_value is Tensor <string> ) { // calculate native tensor length (sum of string lengths in utf-8) var tensorValue = _value as Tensor <string>; int totalLength = 0; for (int i = 0; i < tensorValue.Length; i++) { totalLength += Encoding.UTF8.GetByteCount(tensorValue.GetValue(i)); } long[] longShape = new long[tensorValue.Dimensions.Length]; for (int i = 0; i < tensorValue.Dimensions.Length; i++) { longShape[i] = tensorValue.Dimensions[i]; } // allocate the native tensor IntPtr nativeTensor = IntPtr.Zero; try { NativeApiStatus.VerifySuccess(NativeMethods.OrtCreateTensorAsOrtValue( NativeMemoryAllocator.DefaultInstance.Handle, longShape, (UIntPtr)(longShape.Length), TensorElementType.String, out nativeTensor )); // fill the native tensor, using GetValue(index) from the Tensor<string> var len = tensorValue.Length; var stringsInTensor = new IntPtr[len]; var pinnedHandles = new GCHandle[len + 1]; pinnedHandles[len] = GCHandle.Alloc(stringsInTensor, GCHandleType.Pinned); try { for (int i = 0; i < len; i++) { var utf8str = UTF8Encoding.UTF8.GetBytes(tensorValue.GetValue(i) + "\0"); pinnedHandles[i] = GCHandle.Alloc(utf8str, GCHandleType.Pinned); stringsInTensor[i] = pinnedHandles[i].AddrOfPinnedObject(); } NativeApiStatus.VerifySuccess(NativeMethods.OrtFillStringTensor(nativeTensor, stringsInTensor, (UIntPtr)len)); } finally { foreach (var handle in pinnedHandles) { if (handle.IsAllocated) { handle.Free(); } } } } catch (OnnxRuntimeException e) { if (nativeTensor != IntPtr.Zero) { NativeMethods.OrtReleaseValue(nativeTensor); throw e; } } onnxValue = nativeTensor; // set the output pinnedMemoryHandle = default; // dummy value for the output } else { Debug.Assert(dataBufferPointer != IntPtr.Zero, "dataBufferPointer must be non-null after obtaining the pinned buffer"); // copy to an ulong[] shape to match size_t[] var longShape = stackalloc long[rank]; for (int i = 0; i < rank; i++) { longShape[i] = shape[i]; } IntPtr status = NativeMethods.OrtCreateTensorWithDataAsOrtValue( NativeMemoryInfo.DefaultInstance.Handle, dataBufferPointer, (UIntPtr)(dataBufferLength), longShape, (UIntPtr)rank, nativeElementType, out onnxValue ); try { NativeApiStatus.VerifySuccess(status); } catch (OnnxRuntimeException e) { pinnedMemoryHandle.Dispose(); throw e; } } }
// 4-pattern, lower/upper and '-' or no public GuidBits(ReadOnlySpan <byte> utf8string) { this = default(GuidBits); // 32 if (utf8string.Length == 32) { if (BitConverter.IsLittleEndian) { this.Byte0 = Parse(utf8string, 6); this.Byte1 = Parse(utf8string, 4); this.Byte2 = Parse(utf8string, 2); this.Byte3 = Parse(utf8string, 0); this.Byte4 = Parse(utf8string, 10); this.Byte5 = Parse(utf8string, 8); this.Byte6 = Parse(utf8string, 14); this.Byte7 = Parse(utf8string, 12); } else { this.Byte0 = Parse(utf8string, 0); this.Byte1 = Parse(utf8string, 2); this.Byte2 = Parse(utf8string, 4); this.Byte3 = Parse(utf8string, 6); this.Byte4 = Parse(utf8string, 8); this.Byte5 = Parse(utf8string, 10); this.Byte6 = Parse(utf8string, 12); this.Byte7 = Parse(utf8string, 14); } this.Byte8 = Parse(utf8string, 16); this.Byte9 = Parse(utf8string, 18); this.Byte10 = Parse(utf8string, 20); this.Byte11 = Parse(utf8string, 22); this.Byte12 = Parse(utf8string, 24); this.Byte13 = Parse(utf8string, 26); this.Byte14 = Parse(utf8string, 28); this.Byte15 = Parse(utf8string, 30); return; } else if (utf8string.Length == 36) { // '-' => 45 if (BitConverter.IsLittleEndian) { this.Byte0 = Parse(utf8string, 6); this.Byte1 = Parse(utf8string, 4); this.Byte2 = Parse(utf8string, 2); this.Byte3 = Parse(utf8string, 0); if (utf8string[8] != '-') { goto ERROR; } this.Byte4 = Parse(utf8string, 11); this.Byte5 = Parse(utf8string, 9); if (utf8string[13] != '-') { goto ERROR; } this.Byte6 = Parse(utf8string, 16); this.Byte7 = Parse(utf8string, 14); } else { this.Byte0 = Parse(utf8string, 0); this.Byte1 = Parse(utf8string, 2); this.Byte2 = Parse(utf8string, 4); this.Byte3 = Parse(utf8string, 6); if (utf8string[8] != '-') { goto ERROR; } this.Byte4 = Parse(utf8string, 9); this.Byte5 = Parse(utf8string, 11); if (utf8string[13] != '-') { goto ERROR; } this.Byte6 = Parse(utf8string, 14); this.Byte7 = Parse(utf8string, 16); } if (utf8string[18] != '-') { goto ERROR; } this.Byte8 = Parse(utf8string, 19); this.Byte9 = Parse(utf8string, 21); if (utf8string[23] != '-') { goto ERROR; } this.Byte10 = Parse(utf8string, 24); this.Byte11 = Parse(utf8string, 26); this.Byte12 = Parse(utf8string, 28); this.Byte13 = Parse(utf8string, 30); this.Byte14 = Parse(utf8string, 32); this.Byte15 = Parse(utf8string, 34); return; } ERROR: throw new MessagePackSerializationException("Invalid Guid Pattern."); }
private byte[] ExportEncryptedPkcs8(ReadOnlySpan<char> pkcs8Password, int kdfCount) { return Key.ExportPkcs8KeyBlob(pkcs8Password, kdfCount); }
internal override void WriteSpan(AsnWriter writer, Asn1Tag tag, ReadOnlySpan <char> s) => writer.WriteCharacterString(UniversalTagNumber.BMPString, s, tag);
public bool MoveNext() { var status = Rune.DecodeFromUtf8(_utf8, out _current, out int consumed); _utf8 = _utf8[consumed..];
/// <summary> /// Concatenates 2 byte strings. /// </summary> /// <param name="dest"></param> /// <param name="source"></param> /// <returns>The length of the resulting string.</returns> /// <remarks>This function appends the source string to the end of the null-terminated destination string. /// If the destination buffer is not large enough to contain the resulting string, /// bytes from the source string will be appended to the destination string util the buffer is full. /// If the length of the final string is the same length of the destination buffer, /// no null terminating byte will be written to the end of the string.</remarks> public static int Concat(Span <byte> dest, ReadOnlySpan <byte> source) { return(Concat(dest, GetLength(dest), source)); }
internal static bool TryParseStatusFile(string statusFilePath, out ParsedStatus result, ReusableTextReader reusableReader) { if (!TryReadFile(statusFilePath, reusableReader, out string?fileContents)) { // Between the time that we get an ID and the time that we try to read the associated stat // file(s), the process could be gone. result = default(ParsedStatus); return(false); } ParsedStatus results = default(ParsedStatus); ReadOnlySpan <char> statusFileContents = fileContents.AsSpan(); int unitSliceLength = -1; #if DEBUG int nonUnitSliceLength = -1; #endif while (!statusFileContents.IsEmpty) { int startIndex = statusFileContents.IndexOf(':'); if (startIndex == -1) { // Reached end of file break; } ReadOnlySpan <char> title = statusFileContents.Slice(0, startIndex); statusFileContents = statusFileContents.Slice(startIndex + 1); int endIndex = statusFileContents.IndexOf('\n'); if (endIndex == -1) { endIndex = statusFileContents.Length - 1; unitSliceLength = statusFileContents.Length - 3; #if DEBUG nonUnitSliceLength = statusFileContents.Length; #endif } else { unitSliceLength = endIndex - 3; #if DEBUG nonUnitSliceLength = endIndex; #endif } ReadOnlySpan <char> value = default; bool valueParsed = true; #if DEBUG if (title.SequenceEqual("Pid".AsSpan())) { value = statusFileContents.Slice(0, nonUnitSliceLength); valueParsed = int.TryParse(value, out results.Pid); } #endif if (title.SequenceEqual("VmHWM".AsSpan())) { value = statusFileContents.Slice(0, unitSliceLength); valueParsed = ulong.TryParse(value, out results.VmHWM); } else if (title.SequenceEqual("VmRSS".AsSpan())) { value = statusFileContents.Slice(0, unitSliceLength); valueParsed = ulong.TryParse(value, out results.VmRSS); } else if (title.SequenceEqual("VmData".AsSpan())) { value = statusFileContents.Slice(0, unitSliceLength); valueParsed = ulong.TryParse(value, out ulong vmData); results.VmData += vmData; } else if (title.SequenceEqual("VmSwap".AsSpan())) { value = statusFileContents.Slice(0, unitSliceLength); valueParsed = ulong.TryParse(value, out results.VmSwap); } else if (title.SequenceEqual("VmSize".AsSpan())) { value = statusFileContents.Slice(0, unitSliceLength); valueParsed = ulong.TryParse(value, out results.VmSize); } else if (title.SequenceEqual("VmPeak".AsSpan())) { value = statusFileContents.Slice(0, unitSliceLength); valueParsed = ulong.TryParse(value, out results.VmPeak); } else if (title.SequenceEqual("VmStk".AsSpan())) { value = statusFileContents.Slice(0, unitSliceLength); valueParsed = ulong.TryParse(value, out ulong vmStack); results.VmData += vmStack; } Debug.Assert(valueParsed); statusFileContents = statusFileContents.Slice(endIndex + 1); } results.VmData *= 1024; results.VmPeak *= 1024; results.VmSize *= 1024; results.VmSwap *= 1024; results.VmRSS *= 1024; results.VmHWM *= 1024; result = results; return(true); }
public static string Utf8ToString(ReadOnlySpan <byte> value) { return(Encoding.UTF8.GetString(value)); }
public static string Utf8ZToString(ReadOnlySpan <byte> value) { return(Utf8ToString(value.Slice(0, GetLength(value)))); }
/// <summary> /// Verifies that the signature is valid for the message's content using the specified key. /// </summary> /// <param name="key">The private key used to sign the content.</param> /// <param name="detachedContent">The content that was previously signed.</param> /// <param name="associatedData">The extra data associated with the signature, which must match the value provided during signing.</param> /// <returns><see langword="true"/> if the signature is valid; otherwise, <see langword="false"/>.</returns> /// <exception cref="ArgumentNullException"><paramref name="key"/> is <see langword="null"/>.</exception> /// <exception cref="ArgumentException"><paramref name="key"/> is of an unsupported type.</exception> /// <exception cref="InvalidOperationException">The content is embedded on the associated message, use an overload that uses embedded content.</exception> /// <exception cref="CryptographicException"> /// <para> /// <see cref="CoseMessage.ProtectedHeaders"/> does not have a value for the <see cref="CoseHeaderLabel.Algorithm"/> header. /// </para> /// <para>-or-</para> /// <para> /// The algorithm protected header was incorrectly formatted. /// </para> /// <para>-or-</para> /// <para> /// The algorithm protected header was not one of the values supported by this implementation. /// </para> /// <para>-or-</para> /// <para> /// The algorithm protected header doesn't match with the algorithms supported by the specified <paramref name="key"/>. /// </para> /// </exception> /// <seealso cref="VerifyEmbedded(AsymmetricAlgorithm, ReadOnlySpan{byte})"/> /// <seealso cref="CoseMessage.Content"/> public bool VerifyDetached(AsymmetricAlgorithm key, ReadOnlySpan <byte> detachedContent, ReadOnlySpan <byte> associatedData = default) { if (key is null) { throw new ArgumentNullException(nameof(key)); } if (!Message.IsDetached) { throw new InvalidOperationException(SR.ContentWasEmbedded); } return(VerifyCore(key, detachedContent, null, associatedData, CoseHelpers.GetKeyType(key))); }
private void AnalysisAction(RequestData requestData) { var line = _line.AsSpan(); int len = requestData.Data.Count; var receiveData = requestData.GetSpan(); ReadOnlySpan <byte> http = line; ReadOnlySpan <byte> method = line; ReadOnlySpan <byte> url = line; int offset2 = 0; int count = 0; for (int i = 0; i < len; i++) { if (receiveData[i] == line[0]) { http = receiveData.Slice(offset2, i - offset2); break; } else { if (receiveData[i] == _Space) { if (count != 0) { url = receiveData.Slice(offset2, i - offset2); offset2 = i + 1; } else { method = receiveData.Slice(offset2, i - offset2); offset2 = i + 1; count++; } } } } int queryIndex = AnalysisUrl(url); ReadOnlySpan <byte> baseUrl = default; ReadOnlySpan <byte> queryString = default; if (queryIndex > 0) { baseUrl = url.Slice(0, queryIndex); queryString = url.Slice(queryIndex + 1, url.Length - queryIndex - 1); requestData.QueryString = Encoding.ASCII.GetString(queryString); } else { baseUrl = url; } if (baseUrl.Length == _path_Plaintext.Length && baseUrl.StartsWith(_path_Plaintext)) { requestData.Action = ActionType.Plaintext; } else if (baseUrl.Length == _path_Json.Length && baseUrl.StartsWith(_path_Json)) { requestData.Action = ActionType.Json; } else if (baseUrl.Length == _path_Db.Length && baseUrl.StartsWith(_path_Db)) { requestData.Action = ActionType.Db; } else if (baseUrl.Length == _path_Queries.Length && baseUrl.StartsWith(_path_Queries)) { requestData.Action = ActionType.Queries; } else if (baseUrl.Length == _cached_worlds.Length && baseUrl.StartsWith(_cached_worlds)) { requestData.Action = ActionType.Caching; } else if (baseUrl.Length == _path_Updates.Length && baseUrl.StartsWith(_path_Updates)) { requestData.Action = ActionType.Updates; } else if (baseUrl.Length == _path_Fortunes.Length && baseUrl.StartsWith(_path_Fortunes)) { requestData.Action = ActionType.Fortunes; } else { requestData.Action = ActionType.Other; } }
public Utf8RuneEnumerator(ReadOnlySpan <byte> utf8) { _utf8 = utf8; _current = default; }
static List <MiniYamlNode> FromLines(IEnumerable <ReadOnlyMemory <char> > lines, string filename, bool discardCommentsAndWhitespace, Dictionary <string, string> stringPool) { if (stringPool == null) { stringPool = new Dictionary <string, string>(); } var levels = new List <List <MiniYamlNode> >(); levels.Add(new List <MiniYamlNode>()); var lineNo = 0; foreach (var ll in lines) { var line = ll.Span; ++lineNo; var keyStart = 0; var level = 0; var spaces = 0; var textStart = false; ReadOnlySpan <char> key = default; ReadOnlySpan <char> value = default; ReadOnlySpan <char> comment = default; var location = new MiniYamlNode.SourceLocation { Filename = filename, Line = lineNo }; if (line.Length > 0) { var currChar = line[keyStart]; while (!(currChar == '\n' || currChar == '\r') && keyStart < line.Length && !textStart) { currChar = line[keyStart]; switch (currChar) { case ' ': spaces++; if (spaces >= SpacesPerLevel) { spaces = 0; level++; } keyStart++; break; case '\t': level++; keyStart++; break; default: textStart = true; break; } } if (levels.Count <= level) { throw new YamlException($"Bad indent in miniyaml at {location}"); } while (levels.Count > level + 1) { levels[levels.Count - 1].TrimExcess(); levels.RemoveAt(levels.Count - 1); } // Extract key, value, comment from line as `<key>: <value>#<comment>` // The # character is allowed in the value if escaped (\#). // Leading and trailing whitespace is always trimmed from keys. // Leading and trailing whitespace is trimmed from values unless they // are marked with leading or trailing backslashes var keyLength = line.Length - keyStart; var valueStart = -1; var valueLength = 0; var commentStart = -1; for (var i = 0; i < line.Length; i++) { if (valueStart < 0 && line[i] == ':') { valueStart = i + 1; keyLength = i - keyStart; valueLength = line.Length - i - 1; } if (commentStart < 0 && line[i] == '#' && (i == 0 || line[i - 1] != '\\')) { commentStart = i + 1; if (commentStart <= keyLength) { keyLength = i - keyStart; } else { valueLength = i - valueStart; } break; } } if (keyLength > 0) { key = line.Slice(keyStart, keyLength).Trim(); } if (valueStart >= 0) { var trimmed = line.Slice(valueStart, valueLength).Trim(); if (trimmed.Length > 0) { value = trimmed; } } if (commentStart >= 0 && !discardCommentsAndWhitespace) { comment = line.Slice(commentStart); } if (value.Length > 1) { // Remove leading/trailing whitespace guards var trimLeading = value[0] == '\\' && (value[1] == ' ' || value[1] == '\t') ? 1 : 0; var trimTrailing = value[value.Length - 1] == '\\' && (value[value.Length - 2] == ' ' || value[value.Length - 2] == '\t') ? 1 : 0; if (trimLeading + trimTrailing > 0) { value = value.Slice(trimLeading, value.Length - trimLeading - trimTrailing); } // Remove escape characters from # if (value.Contains("\\#", StringComparison.Ordinal)) { value = value.ToString().Replace("\\#", "#"); } } } if (!key.IsEmpty || !discardCommentsAndWhitespace) { var keyString = key.IsEmpty ? null : key.ToString(); var valueString = value.IsEmpty ? null : value.ToString(); // Note: We need to support empty comments here to ensure that empty comments // (i.e. a lone # at the end of a line) can be correctly re-serialized var commentString = comment == default ? null : comment.ToString(); keyString = keyString == null ? null : stringPool.GetOrAdd(keyString, keyString); valueString = valueString == null ? null : stringPool.GetOrAdd(valueString, valueString); commentString = commentString == null ? null : stringPool.GetOrAdd(commentString, commentString); var nodes = new List <MiniYamlNode>(); levels[level].Add(new MiniYamlNode(keyString, valueString, commentString, nodes, location)); levels.Add(nodes); } } foreach (var nodes in levels) { nodes.TrimExcess(); } return(levels[0]); }
private static ProcessInfo[] GetProcessInfos(PerformanceCounterLib library, int processIndex, int threadIndex, ReadOnlySpan <byte> data) { Dictionary <int, ProcessInfo> processInfos = new Dictionary <int, ProcessInfo>(); List <ThreadInfo> threadInfos = new List <ThreadInfo>(); ref readonly PERF_DATA_BLOCK dataBlock = ref MemoryMarshal.AsRef <PERF_DATA_BLOCK>(data);
private static byte Parse(ReadOnlySpan <byte> bytes, int highOffset) { return(unchecked ((byte)((SwitchParse(bytes[highOffset]) * 16) + SwitchParse(bytes[highOffset + 1])))); }
// Fast parsing for single span in ReadOnlySequence private void ParseFormValuesFast(ReadOnlySpan<byte> span, ref KeyValueAccumulator accumulator, bool isFinalBlock, out int consumed) { ReadOnlySpan<byte> key; ReadOnlySpan<byte> value; consumed = 0; var equalsDelimiter = GetEqualsForEncoding(); var andDelimiter = GetAndForEncoding(); while (span.Length > 0) { // Find the end of the key=value pair. var ampersand = span.IndexOf(andDelimiter); ReadOnlySpan<byte> keyValuePair; int equals; var foundAmpersand = ampersand != -1; if (foundAmpersand) { keyValuePair = span.Slice(0, ampersand); span = span.Slice(keyValuePair.Length + andDelimiter.Length); consumed += keyValuePair.Length + andDelimiter.Length; } else { // We can't know that what is currently read is the end of the form value, that's only the case if this is the final block // If we're not in the final block, then consume nothing if (!isFinalBlock) { // Don't buffer indefinitely if ((uint)span.Length > (uint)KeyLengthLimit + (uint)ValueLengthLimit) { ThrowKeyOrValueTooLargeException(); } return; } keyValuePair = span; span = default; consumed += keyValuePair.Length; } equals = keyValuePair.IndexOf(equalsDelimiter); if (equals == -1) { // Too long for the whole segment to be a key. if (keyValuePair.Length > KeyLengthLimit) { ThrowKeyTooLargeException(); } // There is no more data, this segment must be "key" with no equals or value. key = keyValuePair; value = default; } else { key = keyValuePair.Slice(0, equals); if (key.Length > KeyLengthLimit) { ThrowKeyTooLargeException(); } value = keyValuePair.Slice(equals + equalsDelimiter.Length); if (value.Length > ValueLengthLimit) { ThrowValueTooLargeException(); } } var decodedKey = GetDecodedString(key); var decodedValue = GetDecodedString(value); AppendAndVerify(ref accumulator, decodedKey, decodedValue); } }
/// <summary> /// Returns the <see cref="EllipticalCurve"/> corresponding to the <paramref name="crv"/>. /// </summary> /// <param name="crv"></param> /// <returns></returns> internal static EllipticalCurve FromSpan(ReadOnlySpan<byte> crv) { ref byte crvRef = ref MemoryMarshal.GetReference(crv);
internal ReadOnlySpanWhereRefEnumerable(ReadOnlySpan <TSource> source, Predicate <TSource> predicate) { this.source = source; this.predicate = predicate; }
public override void WriteSurrogateCharEntity(char lowCh, char highCh) { ReadOnlySpan <char> entity = stackalloc char[] { highCh, lowCh }; AddString(new string(entity)); }
public static ReadOnlySpan <char> GetPathRoot(ReadOnlySpan <char> path) { return(IsPathRooted(path) ? PathInternal.DirectorySeparatorCharAsString.AsSpan() : ReadOnlySpan <char> .Empty); }
public static int NeedsEscaping(ReadOnlySpan <byte> value, JavaScriptEncoder?encoder) { return((encoder ?? JavaScriptEncoder.Default).FindFirstCharacterToEncodeUtf8(value)); }
private static int ParseQueries(ReadOnlySpan <byte> parameter) { if (!Utf8Parser.TryParse(parameter, out int queries, out _) || queries < 1) { queries = 1; }
public static ReadOnlySpanWhereAtRefEnumerable<TSource, TPredicate> WhereAtRef<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate = default) where TPredicate : struct, IFunctionIn<TSource, int, bool> => new(source, predicate);
/// <summary> /// Creates a new Tensor of a different type with the specified dimensions and the same layout as this tensor with elements initialized to their default value. /// </summary> /// <typeparam name="TResult">Type contained in the returned Tensor.</typeparam> /// <param name="dimensions">An span of integers that represent the size of each dimension of the DenseTensor to create.</param> /// <returns>A new tensor with the same layout as this tensor but different type and dimensions.</returns> public override Tensor <TResult> CloneEmpty <TResult>(ReadOnlySpan <int> dimensions) { return(new DenseTensor <TResult>(dimensions, IsReversedStride)); }
private static ulong ApplyRound(ulong acc, ReadOnlySpan <byte> lane) { return(ApplyRound(acc, BinaryPrimitives.ReadUInt64LittleEndian(lane))); }
public void StringExtensionsTest() { bool boolVal; string strVal; char[] charArray; ReadOnlyMemory <char> charRom; ReadOnlySpan <char> charRos; boolVal = StringExtensions.TryToBoolean(string.Empty, out boolVal); boolVal = StringExtensions.ToBoolean("true"); strVal = StringExtensions.Abridge(string.Empty, 4); strVal = StringExtensions.RemoveControlChars(string.Empty); strVal = StringExtensions.RemoveControlChars(string.Empty, true); strVal = StringExtensions.RemoveControlChars(string.Empty, ControlCharsReplaceMode.RemoveAll); strVal = StringExtensions.RemoveControlChars(string.Empty, ControlCharsReplaceMode.RemoveAll, false); strVal = StringExtensions.RemoveControlChars(string.Empty, ControlCharsReplaceMode.RemoveAll, false, true); strVal = StringExtensions.RemoveControlChars(string.Empty, ControlCharsReplaceMode.RemoveAll, false, true, false); charArray = StringExtensions.RemoveControlChars(Array.Empty <char>(), ControlCharsReplaceMode.RemoveAll); charArray = StringExtensions.RemoveControlChars(Array.Empty <char>(), ControlCharsReplaceMode.RemoveAll, false); charArray = StringExtensions.RemoveControlChars(Array.Empty <char>(), ControlCharsReplaceMode.RemoveAll, false, true); charArray = StringExtensions.RemoveControlChars(Array.Empty <char>(), ControlCharsReplaceMode.RemoveAll, false, true, false); charRom = StringExtensions.RemoveControlChars(new Memory <char>(), ControlCharsReplaceMode.RemoveAll); charRom = StringExtensions.RemoveControlChars(new Memory <char>(), ControlCharsReplaceMode.RemoveAll, false); charRom = StringExtensions.RemoveControlChars(new Memory <char>(), ControlCharsReplaceMode.RemoveAll, false, true); charRom = StringExtensions.RemoveControlChars(new Memory <char>(), ControlCharsReplaceMode.RemoveAll, false, true, false); charRom = StringExtensions.RemoveControlChars(new ReadOnlyMemory <char>(), ControlCharsReplaceMode.RemoveAll); charRom = StringExtensions.RemoveControlChars(new ReadOnlyMemory <char>(), ControlCharsReplaceMode.RemoveAll, false); charRom = StringExtensions.RemoveControlChars(new ReadOnlyMemory <char>(), ControlCharsReplaceMode.RemoveAll, false, true); charRom = StringExtensions.RemoveControlChars(new ReadOnlyMemory <char>(), ControlCharsReplaceMode.RemoveAll, false, true, false); charRos = StringExtensions.RemoveControlChars(new ReadOnlySpan <char>(), ControlCharsReplaceMode.RemoveAll); charRos = StringExtensions.RemoveControlChars(new ReadOnlySpan <char>(), ControlCharsReplaceMode.RemoveAll, false); charRos = StringExtensions.RemoveControlChars(new ReadOnlySpan <char>(), ControlCharsReplaceMode.RemoveAll, false, true); charRos = StringExtensions.RemoveControlChars(new ReadOnlySpan <char>(), ControlCharsReplaceMode.RemoveAll, false, true, false); charRos = StringExtensions.RemoveControlChars(new Span <char>(), ControlCharsReplaceMode.RemoveAll); charRos = StringExtensions.RemoveControlChars(new Span <char>(), ControlCharsReplaceMode.RemoveAll, false); charRos = StringExtensions.RemoveControlChars(new Span <char>(), ControlCharsReplaceMode.RemoveAll, false, true); charRos = StringExtensions.RemoveControlChars(new Span <char>(), ControlCharsReplaceMode.RemoveAll, false, true, false); boolVal = string.Empty.TryToBoolean(out boolVal); boolVal = "true".ToBoolean(); strVal = string.Empty.Abridge(4); strVal = string.Empty.RemoveControlChars(); strVal = string.Empty.RemoveControlChars(true); strVal = string.Empty.RemoveControlChars(ControlCharsReplaceMode.RemoveAll); strVal = string.Empty.RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false); strVal = string.Empty.RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false, true); strVal = string.Empty.RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false, true, false); charArray = Array.Empty <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll); charArray = Array.Empty <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false); charArray = Array.Empty <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false, true); charArray = Array.Empty <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false, true, false); charRom = new Memory <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll); charRom = new Memory <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false); charRom = new Memory <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false, true); charRom = new Memory <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false, true, false); charRom = new ReadOnlyMemory <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll); charRom = new ReadOnlyMemory <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false); charRom = new ReadOnlyMemory <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false, true); charRom = new ReadOnlyMemory <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false, true, false); charRos = new ReadOnlySpan <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll); charRos = new ReadOnlySpan <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false); charRos = new ReadOnlySpan <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false, true); charRos = new ReadOnlySpan <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false, true, false); charRos = new Span <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll); charRos = new Span <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false); charRos = new Span <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false, true); charRos = new Span <char>().RemoveControlChars(ControlCharsReplaceMode.RemoveAll, false, true, false); }