/// <inheritdoc /> internal override unsafe void ToVector4(Span <RgbaVector> sourceColors, Span <Vector4> destVectors, int count) { Guard.MustBeSizedAtLeast(sourceColors, count, nameof(sourceColors)); Guard.MustBeSizedAtLeast(destVectors, count, nameof(destVectors)); SpanHelper.Copy(sourceColors.AsBytes(), destVectors.AsBytes(), count * sizeof(Vector4)); }
public void Write(char character) { if (character <= 127) { var free = Free; if (free.Length < 1) { Resize(); free = Free; } free[0] = (byte)character; _written++; } else { // TODO: this needs to be optimized. Span <byte> utf8Span = stackalloc byte[4]; Span <char> utf16Span = stackalloc char[1]; utf16Span[0] = character; if (Encodings.Utf8.FromUtf16(utf16Span.AsBytes(), utf8Span, out int consumed, out int written) == OperationStatus.Done) { var encoded = utf8Span.Slice(0, written); while (!encoded.TryCopyTo(Free)) { Resize(); } _written += written; } } }
/// <summary> /// Attempts to parse cluster member identifier. /// </summary> /// <param name="identifier">The hexadecimal representation of identifier.</param> /// <param name="value">The parsed identifier.</param> /// <returns><see langword="true"/> if identifier parsed successfully; otherwise, <see langword="false"/>.</returns> public static bool TryParse(ReadOnlySpan <char> identifier, out ClusterMemberId value) { value = default; var bytes = Span.AsBytes(ref value); return(identifier.FromHex(bytes) == bytes.Length); }
public static void AsBytesUIntToByte() { uint[] a = { 0x44332211, 0x88776655 }; Span <uint> span = new Span <uint>(a); Span <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 AsBytesUIntToByte() { uint[] a = { 0x44332211, 0x88776655 }; Span<uint> span = new Span<uint>(a); Span<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 AsBytesUIntToByte() { uint[] a = { 0x44332211, 0x88776655 }; Span <uint> span = new Span <uint>(a); Span <byte> asBytes = span.AsBytes <uint>(); Assert.True(Unsafe.AreSame <byte>(ref Unsafe.As <uint, byte>(ref MemoryMarshal.GetReference(span)), ref MemoryMarshal.GetReference(asBytes))); asBytes.Validate <byte>(0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88); }
public void AsBytes_Read(int length, int start, int index, int byteOffset) { TestStructs.Foo[] a = TestStructs.Foo.CreateArray(length); Span <TestStructs.Foo> span = new Span <TestStructs.Foo>(a, start); Span <byte> bytes = span.AsBytes(); byte actual = bytes[index * Unsafe.SizeOf <TestStructs.Foo>() + byteOffset]; ref byte baseRef = ref Unsafe.As <TestStructs.Foo, byte>(ref a[0]);
internal ClusterMemberId(IPEndPoint endpoint) { address = default; var bytes = Span.AsBytes(ref address); if (!endpoint.Address.TryWriteBytes(bytes, out length)) { throw new ArgumentException(ExceptionMessages.UnsupportedAddressFamily, nameof(endpoint)); } port = endpoint.Port; family = (int)endpoint.AddressFamily; }
public decimal ReadDecimal() { Span <int> parts = stackalloc int[4]; ReadBytes(parts.AsBytes()); var sign = (parts[3] & 0x80000000) != 0; var scale = (byte)((parts[3] >> 16) & 0x7F); var newValue = new decimal(parts[0], parts[1], parts[2], sign, scale); return(newValue); }
protected override void OnDataMessage(NetIncomingMessage message, DataMessageType type) { switch (type) { case DataMessageType.ChunkData: { ChunkPosition position = message.ReadPoint32(); int length = message.ReadUInt16(); Span <byte> compressedChunkBytes = stackalloc byte[length]; message.Read(compressedChunkBytes); Span <Tile> tiles = stackalloc Tile[Chunk.Size * Chunk.Size]; LZ4Codec.Decode(compressedChunkBytes, tiles.AsBytes()); OnChunkData(new ChunkData(position, tiles)); break; } case DataMessageType.BuildOrders: { int updateCount = message.ReadByte() + 1; for (int i = 0; i < updateCount; i++) { TilePosition position = message.ReadPoint32(); ushort tileID = message.ReadUInt16(); var tile = new Tile(tileID); BuildOrders.Enqueue(new BuildOrder(position, tile)); //var chunkPos = ChunkPosition.FromTile(order.Position); //var chunk = ClientGame._chunks[chunkPos.X, chunkPos.Y]; //if (chunk == null) //{ // // TODO: build order may arrive before chunk data so // // add orders to a set and discard them if they're not used in time // // Log.Warning($"Tried to update unloaded chunk {chunkPos}."); // return; //} // //if (!chunk.TrySetTile(order.Position, order.Tile)) // Log.Warning($"Invalid chunk update at position {order.Position} to chunk {chunkPos}."); } break; } } }
public void IntToBytes(int count) { int destCount = count * sizeof(int); int[] source = CreateTestInts(count + 2); byte[] dest = new byte[destCount + sizeof(int) + 1]; var apSource = new Span <int>(source); var apDest = new Span <byte>(dest); apSource.AsBytes().Slice(0, count * sizeof(int)).CopyTo(apDest); AssertNotDefault(source, 1); Assert.True((bool)ElementsAreEqual(source, dest, 0)); Assert.True((bool)ElementsAreEqual(source, dest, count - 1)); Assert.False((bool)ElementsAreEqual(source, dest, count)); }
public void BytesToGeneric(int count) { int srcCount = count * sizeof(TestStructs.Foo); byte[] source = CreateTestBytes(srcCount); var dest = new TestStructs.Foo[count + 2]; var apSource = new Span <byte>(source); var apDest = new Span <TestStructs.Foo>(dest); apSource.Slice(0, count * sizeof(TestStructs.Foo)).CopyTo(apDest.AsBytes()); AssertNotDefault(source, sizeof(TestStructs.Foo) + 1); AssertNotDefault(dest, 1); Assert.True((bool)ElementsAreEqual(dest, source, 0)); Assert.True((bool)ElementsAreEqual(dest, source, 1)); Assert.True((bool)ElementsAreEqual(dest, source, count - 1)); Assert.False((bool)ElementsAreEqual(dest, source, count)); }
public void GenericToBytes_Aligned(int count) { int destCount = count * sizeof(TestStructs.Foo); TestStructs.AlignedFoo[] source = TestStructs.AlignedFoo.CreateArray(count + 2); byte[] dest = new byte[destCount + sizeof(TestStructs.AlignedFoo) * 2]; var apSource = new Span <TestStructs.AlignedFoo>(source, 1, source.Length - 1); var apDest = new Span <byte>(dest, sizeof(TestStructs.AlignedFoo), dest.Length - sizeof(TestStructs.AlignedFoo)); apSource.AsBytes().Slice(0, (count - 1) * sizeof(TestStructs.AlignedFoo)).CopyTo(apDest); AssertNotDefault(source, 1); Assert.False((bool)ElementsAreEqual(source, dest, 0)); Assert.True((bool)ElementsAreEqual(source, dest, 1)); Assert.True((bool)ElementsAreEqual(source, dest, 2)); Assert.True((bool)ElementsAreEqual(source, dest, count - 1)); Assert.False((bool)ElementsAreEqual(source, dest, count)); }
public void Writable() { Span <byte> buffer = stackalloc byte[256]; var writer = Text.BufferWriter.Create(buffer); var ulonger = new UInt128(); ulonger.Lower = ulong.MaxValue; ulonger.Upper = 1; writer.WriteBytes(ulonger, s_base64); var result = Encodings.Utf8.ToString(writer.Written); Assert.Equal("//////////8BAAAAAAAAAA==", result); var ulongerSpan = new Span <UInt128>(new UInt128[1]); Assert.Equal(OperationStatus.Done, Base64.DecodeFromUtf8(writer.Written, ulongerSpan.AsBytes(), out int consumed, out int written)); Assert.Equal(ulongerSpan[0].Lower, ulonger.Lower); Assert.Equal(ulongerSpan[0].Upper, ulonger.Upper); }
public override int GetHashCode() { if (_hashCode != 0) { return(_hashCode); } // For IPv6 addresses, we calculate the hashcode by using Marvin // on a stack-allocated array containing the Address bytes and ScopeId. int hashCode; if (IsIPv6) { const int addressAndScopeIdLength = IPAddressParserStatics.IPv6AddressBytes + sizeof(uint); Span <byte> addressAndScopeIdSpan = stackalloc byte[addressAndScopeIdLength]; new ReadOnlySpan <ushort>(_numbers).AsBytes().CopyTo(addressAndScopeIdSpan); Span <byte> scopeIdSpan = addressAndScopeIdSpan.Slice(IPAddressParserStatics.IPv6AddressBytes); bool scopeWritten = BitConverter.TryWriteBytes(scopeIdSpan, _addressOrScopeId); Debug.Assert(scopeWritten); hashCode = Marvin.ComputeHash32( addressAndScopeIdSpan, Marvin.DefaultSeed); } else { Span <uint> addressOrScopeIdSpan = stackalloc uint[1]; addressOrScopeIdSpan[0] = _addressOrScopeId; // For IPv4 addresses, we use Marvin on the integer representation of the Address. hashCode = Marvin.ComputeHash32( addressOrScopeIdSpan.AsBytes(), Marvin.DefaultSeed); } _hashCode = hashCode; return(_hashCode); }
static void MustNotCastSpanOfValueTypesWithPointers() { var spanOfValueTypeWithPointers = new Span <ValueTypeWithPointers>(new[] { new ValueTypeWithPointers(new object()) }); try { var impossible = spanOfValueTypeWithPointers.AsBytes(); AssertTrue(false, "Expected exception for wrong type not thrown"); } catch (System.ArgumentException ex) { AssertTrue(ex.Message == "Cannot use type 'ValueTypeWithPointers'. Only value types without pointers or references are supported.", "Exception message is incorrect"); } try { var impossible = spanOfValueTypeWithPointers.NonPortableCast <ValueTypeWithPointers, byte>(); AssertTrue(false, "Expected exception for wrong type not thrown"); } catch (System.ArgumentException ex) { AssertTrue(ex.Message == "Cannot use type 'ValueTypeWithPointers'. Only value types without pointers or references are supported.", "Exception message is incorrect"); } var spanOfBytes = new Span <byte>(new byte[10]); try { var impossible = spanOfBytes.NonPortableCast <byte, ValueTypeWithPointers>(); AssertTrue(false, "Expected exception for wrong type not thrown"); } catch (System.ArgumentException ex) { AssertTrue(ex.Message == "Cannot use type 'ValueTypeWithPointers'. Only value types without pointers or references are supported.", "Exception message is incorrect"); } }
// TODO: this should be moved to System.Text.Primitives. Probably to Utf8 class static string Utf8ToString(ReadOnlySpan <byte> utf8) { var result = Utf8.ToUtf16Length(utf8, out int bytesNeeded); if (result == TransformationStatus.InvalidData || result == TransformationStatus.NeedMoreSourceData) { throw new Exception("invalid UTF8 byte"); } var str = new string(' ', bytesNeeded / sizeof(char)); unsafe { fixed(char *pStr = str) { var strSpan = new Span <char>(pStr, str.Length); if (Utf8.ToUtf16(utf8, strSpan.AsBytes(), out int consumed, out int written) != TransformationStatus.Done) { throw new Exception(); } } } return(str); }
void IBufferReader <T> .Append(ReadOnlySpan <byte> block, ref int consumedBytes) { block.CopyTo(Span.AsBytes(ref result).Slice(offset)); offset += block.Length; }
public static void Save(this Stream s, Point[] points) { Span <Point> span = points; s.Write(span.AsBytes()); }
public static void Load(this Stream s, Point[] points) { Span <Point> span = points; s.Read(span.AsBytes()); }
public static void Lerp(ReadOnlySpan <Alpha8> left, ReadOnlySpan <Alpha8> right, int amount, Span <Alpha8> dst) { Vector4Streaming.Lerp(left.AsBytes(), right.AsBytes(), amount, dst.AsBytes()); }