Fixed<T>

Fixed<T> encodes value-typed T values with fixed-size encoding in little-endian byte order.

WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray( 0)));           // 00000000
WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(-1)));           // FFFFFFFF
WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(+1)));           // 01000000
WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(-2)));           // FEFFFFFF
WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(+2)));           // 02000000
WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(-3)));           // FDFFFFFF
WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(+3)));           // 03000000
WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(int.MinValue))); // 00000080
WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(int.MaxValue))); // FFFFFF7F

Fixed<T>.Write(memory, value, atIndex?) writes value-typed T to 'memory'.

byte[] data = new byte[8];
var memory = new ListMemory<byte[], byte>(data);
Fixed<ulong>.Write(memory, value: 0x100UL);

Fixed<T>.TryWrite(memory, value, atIndex?) tries to write 'value' to 'memory'.

byte[] data = new byte[8];
var memory = new ListMemory<byte[], byte>(data);
bool ok = Fixed<ulong>.TryWrite(memory, value: 0x100UL);

Fixed<T>.Read(memory, atIndex?) reads value-typed T from 'memory'.

byte[] data = new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 };
var memory = new ListMemory<byte[], byte>(data);
ulong value = Fixed<ulong>.Read(memory);
WriteLine(value); // 256

Fixed<T>.TryRead(memory, out value, atIndex?) tries to read value-typed T from 'memory'.

byte[] data = new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 };
var memory = new ListMemory<byte[], byte>(data);
bool ok = Fixed<ulong>.TryRead(memory, out ulong value);
WriteLine(value); // 256

Fixed<T>.Insert(memory, value, atIndex?) inserts value-typed T to 'memory'.

byte[] data = new byte[8];
var memory = new Slice<ListMemory<byte[], byte>, byte>(new ListMemory<byte[], byte>(data), 0, 0, data.Length);
Fixed<ulong>.Insert(ref memory, value: 0x100UL);

Fixed<T>.TryInsert(memory, value, atIndex?) tries to insert 'value' to 'memory'.

byte[] data = new byte[8];
var memory = new Slice<ListMemory<byte[], byte>, byte>(new ListMemory<byte[], byte>(data), 0, 0, data.Length);
Fixed<ulong>.TryInsert(ref memory, value: 0x100UL);

Any value-type T can be read and written.

var memory = new BlockMemory<byte>();
Fixed<DateTime>.TryInsert(ref memory, DateTime.UtcNow);
Fixed<Guid>.TryInsert(ref memory, Guid.NewGuid(), atIndex: memory.Count);
Fixed<UInt128>.TryInsert(ref memory, new UInt128(0, 0), atIndex: memory.Count);

Fixed<T>.Size returns the number of bytes allocated by an element of T.

WriteLine(Fixed<bool>.Size);            // 1
WriteLine(Fixed<SByte>.Size);           // 1
WriteLine(Fixed<Byte>.Size);            // 1
WriteLine(Fixed<Int16>.Size);           // 2
WriteLine(Fixed<UInt16>.Size);          // 1
WriteLine(Fixed<Int32>.Size);           // 4
WriteLine(Fixed<UInt32>.Size);          // 4
WriteLine(Fixed<Int64>.Size);           // 8
WriteLine(Fixed<UInt64>.Size);          // 8
WriteLine(Fixed<Int128>.Size);          // 16
WriteLine(Fixed<UInt128>.Size);         // 16
WriteLine(Fixed<Guid>.Size);            // 16
WriteLine(Fixed<DateTime>.Size);        // 8
WriteLine(Fixed<DateTimeOffset>.Size);  // 16

Full Example

Full example

using Avalanche.Memory;
using Avalanche.Utilities;
using static System.Console;

public class @fixed
{
    public static void Run()
    {
        {
            // <00>
            WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray( 0)));           // 00000000
            WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(-1)));           // FFFFFFFF
            WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(+1)));           // 01000000
            WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(-2)));           // FEFFFFFF
            WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(+2)));           // 02000000
            WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(-3)));           // FDFFFFFF
            WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(+3)));           // 03000000
            WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(int.MinValue))); // 00000080
            WriteLine(Hex.PrintFromBytes(Fixed<int>.ToArray(int.MaxValue))); // FFFFFF7F
            // </00>
        }

        {
            // <01>
            byte[] data = new byte[8];
            var memory = new ListMemory<byte[], byte>(data);
            Fixed<ulong>.Write(memory, value: 0x100UL);
            // </01>
        }
        {
            // <02>
            byte[] data = new byte[8];
            var memory = new ListMemory<byte[], byte>(data);
            bool ok = Fixed<ulong>.TryWrite(memory, value: 0x100UL);
            // </02>
        }
        {
            // <03>
            byte[] data = new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 };
            var memory = new ListMemory<byte[], byte>(data);
            ulong value = Fixed<ulong>.Read(memory);
            WriteLine(value); // 256
            // </03>
        }
        {
            // <04>
            byte[] data = new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 };
            var memory = new ListMemory<byte[], byte>(data);
            bool ok = Fixed<ulong>.TryRead(memory, out ulong value);
            WriteLine(value); // 256
            // </04>
        }
        {
            // <05>
            byte[] data = new byte[8];
            var memory = new Slice<ListMemory<byte[], byte>, byte>(new ListMemory<byte[], byte>(data), 0, 0, data.Length);
            Fixed<ulong>.Insert(ref memory, value: 0x100UL);
            // </05>
        }
        {
            // <06>
            byte[] data = new byte[8];
            var memory = new Slice<ListMemory<byte[], byte>, byte>(new ListMemory<byte[], byte>(data), 0, 0, data.Length);
            Fixed<ulong>.TryInsert(ref memory, value: 0x100UL);
            // </06>
        }
        {
            // <11>
            var memory = new BlockMemory<byte>();
            Fixed<DateTime>.TryInsert(ref memory, DateTime.UtcNow);
            Fixed<Guid>.TryInsert(ref memory, Guid.NewGuid(), atIndex: memory.Count);
            Fixed<UInt128>.TryInsert(ref memory, new UInt128(0, 0), atIndex: memory.Count);
            // </11>
        }
        {
            // <21>
            WriteLine(Fixed<bool>.Size);            // 1
            WriteLine(Fixed<SByte>.Size);           // 1
            WriteLine(Fixed<Byte>.Size);            // 1
            WriteLine(Fixed<Int16>.Size);           // 2
            WriteLine(Fixed<UInt16>.Size);          // 1
            WriteLine(Fixed<Int32>.Size);           // 4
            WriteLine(Fixed<UInt32>.Size);          // 4
            WriteLine(Fixed<Int64>.Size);           // 8
            WriteLine(Fixed<UInt64>.Size);          // 8
            WriteLine(Fixed<Int128>.Size);          // 16
            WriteLine(Fixed<UInt128>.Size);         // 16
            WriteLine(Fixed<Guid>.Size);            // 16
            WriteLine(Fixed<DateTime>.Size);        // 8
            WriteLine(Fixed<DateTimeOffset>.Size);  // 16
            // </21>
        }
    }
}