c++ header-only library for primitive type serialization similar(conceptually) to java's bytebuffer and datastream classes. It can read/write data in memory/file sequences(streams) and can be extended for other streams as well.
No external dependencies.
There are only two concepts used:
- the first one is the data sequence type, which contains the data, be it in a file, in memory, etc.
- and the second one is the data handler, i.e. readers and writers, which are applied to the data sequences.
#include <data-seqv.hxx>
{
// write an int and a float to a memory sequence and then read them back
data_seqv_rw_mem_ops sequence;
sequence.w.write_i32(42);
sequence.w.write_f32(666.66f);
sequence.rewind();
int32_t meaning_of_life = sequence.r.read_i32();
assert(meaning_of_life == 42);
float how_much_for_an_apple = sequence.r.read_f32();
assert(how_much_for_an_apple == 666.66f);
sequence.rewind();
// write an int to a memory sequence and then read it back as a float
sequence.w.write_u32(0x5f3759df);
sequence.rewind();
float magic_number = sequence.r.read_f32();
}
{
// same steps, but with a file sequence now
// and also showing the equivalent template versions for reading/writing
data_seqv_rw_file_ops sequence(data_seqv_std_file_wrapper(file_path, "w+b"));
sequence.w.write(42);
sequence.w.write(666.66f);
sequence.rewind();
int32_t meaning_of_life = sequence.r.read<int>();
assert(meaning_of_life == 42);
float how_much_for_an_apple = sequence.r.read<float>();
assert(how_much_for_an_apple == 666.66f);
sequence.rewind();
sequence.w.write(0x5f3759df);
sequence.rewind();
float magic_number = sequence.r.read_f32();
}
{
// sequence readers and writers also work with pointers to data sequences
data_seqv_rw_mem* sequence_ptr = new data_seqv_rw_mem();
data_seqv_writer_ptr dsw_ptr(sequence_ptr);
data_seqv_reader_ptr dsr_ptr(sequence_ptr);
dsw_ptr.write_u32(0x5f3759df);
dsr_ptr.dsv()->rewind(); // equivalent to sequence_ptr->rewind();
float magic_number = dsr_ptr.read_f32();
delete sequence_ptr;
}
{
// and shared pointers
std::shared_ptr<data_seqv_rw_mem> sequence_sp = std::make_shared<data_seqv_rw_mem>();
data_seqv_writer_shr dsw_sp(sequence_sp);
data_seqv_reader_shr dsr_sp(sequence_sp);
dsw_sp.write_u32(0x5f3759df);
dsr_sp.dsv()->rewind(); // equivalent to sequence_sp->rewind();
float magic_number = dsr_sp.read_f32();
}
// same steps also work for a file sequence by replacing data_seqv_rw_mem with
// data_seqv_file( "new data_seqv_file(..);" or "std::make_shared<data_seqv_file>(..);" )
{
const uint32_t nr = 0x12345678;
data_seqv_rw_mem_ops seqv;
seqv.w.write_u32(nr);
seqv.w.write(nr);
seqv.rewind();
uint32_t t0 = seqv.r.read_u32();
uint32_t t1 = seqv.r.read<uint32_t>();
seqv.rewind();
uint32_t t2 = seqv.r.read<uint32_t>();
uint32_t t3 = seqv.r.read_u32();
assert(t0 == nr);
assert(t0 == t1);
assert(t0 == t2);
assert(t0 == t3);
seqv.rewind();
seqv.w.write_u32(nr);
seqv.rewind();
float f0 = seqv.r.read_f32();
seqv.rewind();
seqv.w.write_f32(f0);
seqv.rewind();
uint32_t t4 = seqv.r.read_u32();
assert(t0 == t4);
}