binary_serializer* m_serializer;

public:

binary_writer(binary_serializer* s) : m_serializer(s) { }

template<typename T>

inline static void write_int(binary_serializer* bs, const T& value) {

memcpy(bs->m_wr_pos, &value, sizeof(T));

bs->m_wr_pos += sizeof(T);

}

inline static void write_string(binary_serializer* bs,

const std::string& str) {

write_int(bs, static_cast<std::uint32_t>(str.size()));

memcpy(bs->m_wr_pos, str.c_str(), str.size());

bs->m_wr_pos += str.size();

}

template<typename T>

void operator()(const T& value,

typename enable_if<std::is_integral<T>::value>::type* = 0) {

m_serializer->acquire(sizeof(T));

write_int(m_serializer, value);

}

template<typename T>

void operator()(const T&,

typename enable_if<std::is_floating_point<T>::value>::type* = 0) {

throw std::logic_error("binary_serializer::write_floating_point "

"not implemented yet");

}

void operator()(const std::string& str) {

m_serializer->acquire(sizeof(std::uint32_t) + str.size());

write_string(m_serializer, str);

}

void operator()(const std::u16string& str) {

m_serializer->acquire(sizeof(std::uint32_t) + str.size());

write_int(m_serializer, static_cast<std::uint32_t>(str.size()));

for (char16_t c : str) {

// force writer to use exactly 16 bit

write_int(m_serializer, static_cast<std::uint16_t>(c));

}

}

void operator()(const std::u32string& str) {

m_serializer->acquire(sizeof(std::uint32_t) + str.size());

write_int(m_serializer, static_cast<std::uint32_t>(str.size()));

for (char32_t c : str) {

// force writer to use exactly 32 bit

write_int(m_serializer, static_cast<std::uint32_t>(c));

}

}

if (!m_begin) {

num_bytes += ui32_size;

size_t new_size = chunk_size;

while (new_size <= num_bytes) {

new_size += chunk_size;

}

m_begin = new char[new_size];

m_end = m_begin + new_size;

m_wr_pos = m_begin + ui32_size;

}

else {

char* next_wr_pos = m_wr_pos + num_bytes;

if (next_wr_pos > m_end) {

size_t new_size = static_cast<size_t>(m_end - m_begin)

+ chunk_size;

while ((m_begin + new_size) < next_wr_pos) {

new_size += chunk_size;

}

char* begin = new char[new_size];

auto used_bytes = static_cast<size_t>(m_wr_pos - m_begin);

if (used_bytes > 0) {

memcpy(m_begin, begin, used_bytes);

}

delete[] m_begin;

m_begin = begin;

m_end = m_begin + new_size;

m_wr_pos = m_begin + used_bytes;

}

}

acquire(sizeof(std::uint32_t));

detail::binary_writer::write_int(this,

static_cast<std::uint32_t>(list_size));

acquire(num_bytes);

memcpy(m_wr_pos, data, num_bytes);

m_wr_pos += num_bytes;

const primitive_variant* values) {

const primitive_variant* end = values + size;

for ( ; values != end; ++values) {

write_value(*values);

}