BinaryReader reads primitive types in binary from any type that satisfies the IO::StreamReader concept.

BinaryWriter writes primitive types in binary to any type that satisfies the IO::StreamWriter concept.

Reading and writing boolean values

constexpr bool value1 = false;
constexpr bool value2 = true;
std::optional<bool> optional1;
std::optional<bool> optional2 = value1;
std::optional<bool> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<bool>( );
auto v2 = reader.Read<bool>( );
auto v3 = reader.Read<std::optional<bool>>( );
auto v4 = reader.Read<std::optional<bool>>( );
auto v5 = reader.Read<std::optional<bool>>( );

Reading and writing SByte values

constexpr SByte value1 = 10;
constexpr SByte value2 = 100;
std::optional<SByte> optional1;
std::optional<SByte> optional2 = value1;
std::optional<SByte> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<SByte>( );
auto v2 = reader.Read<SByte>( );
auto v3 = reader.Read<std::optional<SByte>>( );
auto v4 = reader.Read<std::optional<SByte>>( );
auto v5 = reader.Read<std::optional<SByte>>( );

Reading and writing Byte values

constexpr Byte value1 = 10;
constexpr Byte value2 = 100;
std::optional<Byte> optional1;
std::optional<Byte> optional2 = value1;
std::optional<Byte> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<Byte>( );
auto v2 = reader.Read<Byte>( );
auto v3 = reader.Read<std::optional<Byte>>( );
auto v4 = reader.Read<std::optional<Byte>>( );
auto v5 = reader.Read<std::optional<Byte>>( );

Reading and writing Int16 values

constexpr Int16 value1 = 10;
constexpr Int16 value2 = 100;
std::optional<Int16> optional1;
std::optional<Int16> optional2 = value1;
std::optional<Int16> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<Int16>( );
auto v2 = reader.Read<Int16>( );
auto v3 = reader.Read<std::optional<Int16>>( );
auto v4 = reader.Read<std::optional<Int16>>( );
auto v5 = reader.Read<std::optional<Int16>>( );

Reading and writing UInt16 values

constexpr UInt16 value1 = 10;
constexpr UInt16 value2 = 100;
std::optional<UInt16> optional1;
std::optional<UInt16> optional2 = value1;
std::optional<UInt16> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<UInt16>( );
auto v2 = reader.Read<UInt16>( );
auto v3 = reader.Read<std::optional<UInt16>>( );
auto v4 = reader.Read<std::optional<UInt16>>( );
auto v5 = reader.Read<std::optional<UInt16>>( );

Reading and writing Int32 values

constexpr Int32 value1 = 10;
constexpr Int32 value2 = 100;
std::optional<Int32> optional1;
std::optional<Int32> optional2 = value1;
std::optional<Int32> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<Int32>( );
auto v2 = reader.Read<Int32>( );
auto v3 = reader.Read<std::optional<Int32>>( );
auto v4 = reader.Read<std::optional<Int32>>( );
auto v5 = reader.Read<std::optional<Int32>>( );

Reading and writing UInt32 values

constexpr UInt32 value1 = 10;
constexpr UInt32 value2 = 100;
std::optional<UInt32> optional1;
std::optional<UInt32> optional2 = value1;
std::optional<UInt32> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<UInt32>( );
auto v2 = reader.Read<UInt32>( );
auto v3 = reader.Read<std::optional<UInt32>>( );
auto v4 = reader.Read<std::optional<UInt32>>( );
auto v5 = reader.Read<std::optional<UInt32>>( );

Reading and writing Int64 values

constexpr Int64 value1 = 10;
constexpr Int64 value2 = 100;
std::optional<Int64> optional1;
std::optional<Int64> optional2 = value1;
std::optional<Int64> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<Int64>( );
auto v2 = reader.Read<Int64>( );
auto v3 = reader.Read<std::optional<Int64>>( );
auto v4 = reader.Read<std::optional<Int64>>( );
auto v5 = reader.Read<std::optional<Int64>>( );

Reading and writing UInt64 values

constexpr UInt64 value1 = 10;
constexpr UInt64 value2 = 100;
std::optional<UInt64> optional1;
std::optional<UInt64> optional2 = value1;
std::optional<UInt64> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<UInt64>( );
auto v2 = reader.Read<UInt64>( );
auto v3 = reader.Read<std::optional<UInt64>>( );
auto v4 = reader.Read<std::optional<UInt64>>( );
auto v5 = reader.Read<std::optional<UInt64>>( );

Reading and writing float values

constexpr float value1 = 10;
constexpr float value2 = 100;
std::optional<float> optional1;
std::optional<float> optional2 = value1;
std::optional<float> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<float>( );
auto v2 = reader.Read<float>( );
auto v3 = reader.Read<std::optional<float>>( );
auto v4 = reader.Read<std::optional<float>>( );
auto v5 = reader.Read<std::optional<float>>( );

Reading and writing double values

constexpr double value1 = 10;
constexpr double value2 = 100;
std::optional<double> optional1;
std::optional<double> optional2 = value1;
std::optional<double> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<double>( );
auto v2 = reader.Read<double>( );
auto v3 = reader.Read<std::optional<double>>( );
auto v4 = reader.Read<std::optional<double>>( );
auto v5 = reader.Read<std::optional<double>>( );

Reading and writing DateTime values

DateTime value1(2020,1,10);
DateTime value2(2020,1,20);
std::optional<DateTime> optional1;
std::optional<DateTime> optional2 = value1;
std::optional<DateTime> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<DateTime>( );
auto v2 = reader.Read<DateTime>( );
auto v3 = reader.Read<std::optional<DateTime>>( );
auto v4 = reader.Read<std::optional<DateTime>>( );
auto v5 = reader.Read<std::optional<DateTime>>( );

Reading and writing TimeSpan values

TimeSpan value1(2000LL);
TimeSpan value2(3000LL);
std::optional<TimeSpan> optional1;
std::optional<TimeSpan> optional2 = value1;
std::optional<TimeSpan> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<TimeSpan>( );
auto v2 = reader.Read<TimeSpan>( );
auto v3 = reader.Read<std::optional<TimeSpan>>( );
auto v4 = reader.Read<std::optional<TimeSpan>>( );
auto v5 = reader.Read<std::optional<TimeSpan>>( );

Reading and writing Guid values

Guid value1( L"{A69ED24E-E20D-4A5A-93AF-828ED3D46119}" );
Guid value2( L"{4C42B1DB-9209-4EA3-8700-C438789FB47F}" );
std::optional<Guid> optional1;
std::optional<Guid> optional2 = value1;
std::optional<Guid> optional3 = value2;

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
writer.Write( optional1 );
writer.Write( optional2 );
writer.Write( optional3 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<Guid>( );
auto v2 = reader.Read<Guid>( );
auto v3 = reader.Read<std::optional<Guid>>( );
auto v4 = reader.Read<std::optional<Guid>>( );
auto v5 = reader.Read<std::optional<Guid>>( );

Reading and writing AnsiString values

AnsiString value1( "s1" );
AnsiString value2( "s2" );

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<AnsiString>( );
auto v2 = reader.Read<AnsiString>( );

Reading and writing WideString values

WideString value1( L"s1" );
WideString value2( L"s2" );

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<WideString>( );
auto v2 = reader.Read<WideString>( );

Reading and writing std::string values

std::string value1( "s1" );
std::string value2( "s2" );

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<std::string>( );
auto v2 = reader.Read<std::string>( );

Reading and writing std::wstring values

std::wstring value1( L"s1" );
std::wstring value2( L"s2" );

IO::MemoryStream stream;
IO::BinaryWriter writer( stream );
writer.Write( value1 );
writer.Write( value2 );
stream.SetPosition( 0 );
IO::BinaryReader reader( stream );

auto v1 = reader.Read<std::wstring>( );
auto v2 = reader.Read<std::wstring>( );

Reading and writing SByte values

Reading and writing SByte values

Reading and writing SByte values

Reading and writing SByte values

Reading and writing SByte values