Variable<T>

Variable<T> encodes value-type T values with variable-sized encoding that uses 7 bits for payload and every 8th bit describes whether 'value' continues into next octet. Negative values are not-interleaved and require .MaxEncodedSize number of bytes to encode.

WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray( 0)));           // 00
WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(-1)));           // FFFFFFFF0F
WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(+1)));           // 01
WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(-2)));           // FEFFFFFF0F
WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(+2)));           // 02
WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(-3)));           // FDFFFFFF0F
WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(+3)));           // 03
WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(int.MinValue))); // 8080808008
WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(int.MaxValue))); // FFFFFFFF07

Variable<T>.Write(memory, value, bytesWritten, atIndex?) writes value-typed T to 'memory' using variable-sized encoding.

byte[] data = new byte[8];
var memory = new ListMemory<byte[], byte>(data);
Variable<ulong>.Write(memory, value: 0x100UL, out int bytesWritten);
WriteLine(bytesWritten);        // 2

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

byte[] data = new byte[8];
var memory = new ListMemory<byte[], byte>(data);
bool ok = Variable<ulong>.TryWrite(memory, value: 0x100UL, out int bytesWritten);
WriteLine(bytesWritten);        // 2

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

byte[] data = new byte[] { 128, 2, 0, 0, 0, 0, 0, 0 };
var memory = new ListMemory<byte[], byte>(data);
ulong value = Variable<ulong>.Read(memory, out int bytesRead);
WriteLine(value);               // 256
WriteLine(bytesRead);           // 2

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

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

Variable<T>.Insert(memory, value, bytesWritten, 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);
Variable<ulong>.Insert(ref memory, value: 0x100UL, out int bytesWritten);
WriteLine(bytesWritten);        // 2

Variable<T>.TryInsert(memory, value, bytesWritten, 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);
Variable<ulong>.TryInsert(ref memory, value: 0x100UL, out int bytesWritten);
WriteLine(bytesWritten);        // 2

Any value-type T can be read and written.

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

Variable<T>.FixedSize returns the fixed number of bytes of unencoded value-type T.

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

Variable<T>.MaxEncodedSize returns the maximum number of bytes that may be needed for encoding T.

WriteLine(Variable<bool>.MaxEncodedSize);            // 1
WriteLine(Variable<SByte>.MaxEncodedSize);           // 2
WriteLine(Variable<Byte>.MaxEncodedSize);            // 2
WriteLine(Variable<Int16>.MaxEncodedSize);           // 3
WriteLine(Variable<UInt16>.MaxEncodedSize);          // 3
WriteLine(Variable<Int32>.MaxEncodedSize);           // 5
WriteLine(Variable<UInt32>.MaxEncodedSize);          // 5
WriteLine(Variable<Int64>.MaxEncodedSize);           // 10
WriteLine(Variable<UInt64>.MaxEncodedSize);          // 10
WriteLine(Variable<Int128>.MaxEncodedSize);          // 19
WriteLine(Variable<UInt128>.MaxEncodedSize);         // 19
WriteLine(Variable<Guid>.MaxEncodedSize);            // 19
WriteLine(Variable<DateTime>.MaxEncodedSize);        // 10
WriteLine(Variable<DateTimeOffset>.MaxEncodedSize);  // 19

Variable<T>.EncodedSize(value) returns the exact number of bytes that are needed to encode 'value'.

WriteLine(Variable<UInt64>.EncodedSize(0));                 // 1
WriteLine(Variable<UInt64>.EncodedSize(1));                 // 1
WriteLine(Variable<UInt64>.EncodedSize(127));               // 1
WriteLine(Variable<UInt64>.EncodedSize(128));               // 2
WriteLine(Variable<UInt64>.EncodedSize(16383));             // 3
WriteLine(Variable<UInt64>.EncodedSize(16384));             // 4
WriteLine(Variable<UInt64>.EncodedSize(UInt64.MaxValue));   // 10

Full Example

Full example

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

public class variable
{
    public static void Run()
    {
        {
            // <00>
            WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray( 0)));           // 00
            WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(-1)));           // FFFFFFFF0F
            WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(+1)));           // 01
            WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(-2)));           // FEFFFFFF0F
            WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(+2)));           // 02
            WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(-3)));           // FDFFFFFF0F
            WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(+3)));           // 03
            WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(int.MinValue))); // 8080808008
            WriteLine(Hex.PrintFromBytes(Variable<int>.ToArray(int.MaxValue))); // FFFFFFFF07
            // </00>
        }

        {
            // <01>
            byte[] data = new byte[8];
            var memory = new ListMemory<byte[], byte>(data);
            Variable<ulong>.Write(memory, value: 0x100UL, out int bytesWritten);
            WriteLine(bytesWritten);        // 2
            // </01>
        }
        {
            // <02>
            byte[] data = new byte[8];
            var memory = new ListMemory<byte[], byte>(data);
            bool ok = Variable<ulong>.TryWrite(memory, value: 0x100UL, out int bytesWritten);
            WriteLine(bytesWritten);        // 2
            // </02>
        }
        {
            // <03>
            byte[] data = new byte[] { 128, 2, 0, 0, 0, 0, 0, 0 };
            var memory = new ListMemory<byte[], byte>(data);
            ulong value = Variable<ulong>.Read(memory, out int bytesRead);
            WriteLine(value);               // 256
            WriteLine(bytesRead);           // 2
            // </03>
        }
        {
            // <04>
            byte[] data = new byte[] { 128, 2, 0, 0, 0, 0, 0, 0 };
            var memory = new ListMemory<byte[], byte>(data);
            bool ok = Variable<ulong>.TryRead(memory, out ulong value, out int bytesRead);
            WriteLine(value);               // 256
            WriteLine(bytesRead);           // 2
            // </04>
        }
        {
            // <05>
            byte[] data = new byte[8];
            var memory = new Slice<ListMemory<byte[], byte>, byte>(new ListMemory<byte[], byte>(data), 0, 0, data.Length);
            Variable<ulong>.Insert(ref memory, value: 0x100UL, out int bytesWritten);
            WriteLine(bytesWritten);        // 2
            // </05>
        }
        {
            // <06>
            byte[] data = new byte[8];
            var memory = new Slice<ListMemory<byte[], byte>, byte>(new ListMemory<byte[], byte>(data), 0, 0, data.Length);
            Variable<ulong>.TryInsert(ref memory, value: 0x100UL, out int bytesWritten);
            WriteLine(bytesWritten);        // 2
            // </06>
        }
        {
            // <11>
            var memory = new BlockMemory<byte>();
            Variable<DateTime>.TryInsert(ref memory, DateTime.UtcNow, out int bytesWritten);
            Variable<Guid>.TryInsert(ref memory, Guid.NewGuid(), out bytesWritten, atIndex: memory.Count);
            Variable<UInt128>.TryInsert(ref memory, new UInt128(0, 0), out bytesWritten, atIndex: memory.Count);
            // </11>
        }
        {
            // <21>
            WriteLine(Variable<bool>.FixedSize);            // 1
            WriteLine(Variable<Byte>.FixedSize);            // 1
            WriteLine(Variable<SByte>.FixedSize);           // 1
            WriteLine(Variable<UInt16>.FixedSize);          // 1
            WriteLine(Variable<Int16>.FixedSize);           // 2
            WriteLine(Variable<Int32>.FixedSize);           // 4
            WriteLine(Variable<UInt32>.FixedSize);          // 4
            WriteLine(Variable<Int64>.FixedSize);           // 8
            WriteLine(Variable<UInt64>.FixedSize);          // 8
            WriteLine(Variable<Int128>.FixedSize);          // 16
            WriteLine(Variable<UInt128>.FixedSize);         // 16
            WriteLine(Variable<Guid>.FixedSize);            // 16
            WriteLine(Variable<DateTime>.FixedSize);        // 8
            WriteLine(Variable<DateTimeOffset>.FixedSize);  // 16
            // </21>
        }        
        {
            // <22>
            WriteLine(Variable<bool>.MaxEncodedSize);            // 1
            WriteLine(Variable<SByte>.MaxEncodedSize);           // 2
            WriteLine(Variable<Byte>.MaxEncodedSize);            // 2
            WriteLine(Variable<Int16>.MaxEncodedSize);           // 3
            WriteLine(Variable<UInt16>.MaxEncodedSize);          // 3
            WriteLine(Variable<Int32>.MaxEncodedSize);           // 5
            WriteLine(Variable<UInt32>.MaxEncodedSize);          // 5
            WriteLine(Variable<Int64>.MaxEncodedSize);           // 10
            WriteLine(Variable<UInt64>.MaxEncodedSize);          // 10
            WriteLine(Variable<Int128>.MaxEncodedSize);          // 19
            WriteLine(Variable<UInt128>.MaxEncodedSize);         // 19
            WriteLine(Variable<Guid>.MaxEncodedSize);            // 19
            WriteLine(Variable<DateTime>.MaxEncodedSize);        // 10
            WriteLine(Variable<DateTimeOffset>.MaxEncodedSize);  // 19
            // </22>
        }
        {
            // <23>
            WriteLine(Variable<UInt64>.EncodedSize(0));                 // 1
            WriteLine(Variable<UInt64>.EncodedSize(1));                 // 1
            WriteLine(Variable<UInt64>.EncodedSize(127));               // 1
            WriteLine(Variable<UInt64>.EncodedSize(128));               // 2
            WriteLine(Variable<UInt64>.EncodedSize(16383));             // 3
            WriteLine(Variable<UInt64>.EncodedSize(16384));             // 4
            WriteLine(Variable<UInt64>.EncodedSize(UInt64.MaxValue));   // 10
            // </23>
        }
    }
}