public:

binary_writer(util::buffer* sink) : m_sink(sink) { }

template<typename T>

static inline void write_int(util::buffer* sink, const T& value) {

sink->write(sizeof(T), &value, grow_if_needed);

}

static inline void write_string(util::buffer* sink,

const std::string& str) {

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

sink->write(str.size(), str.c_str(), grow_if_needed);

}

template<typename T>

void operator()(const T& value,

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

write_int(m_sink, value);

}

template<typename T>

void operator()(const T& value,

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

auto tmp = detail::pack754(value);

write_int(m_sink, tmp);

}

// the IEEE-754 conversion does not work for long double

// => fall back to string serialization (event though it sucks)

void operator()(const long double& v) {

std::ostringstream oss;

oss << std::setprecision(std::numeric_limits<long double>::digits) << v;

write_string(m_sink, oss.str());

}

void operator()(const atom_value& val) {

(*this)(static_cast<uint64_t>(val));

}

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

write_string(m_sink, str);

}

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

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

for (char16_t c : str) {

// force writer to use exactly 16 bit

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

}

}

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

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

for (char32_t c : str) {

// force writer to use exactly 32 bit

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

}

}

private:

util::buffer* m_sink;

CPPA_REQUIRE(uti != nullptr);

auto ot = outgoing_types();

std::uint32_t id = (ot) ? ot->id_of(uti) : 0;

std::uint8_t flag = (id == 0) ? 1 : 0;

binary_writer::write_int(m_sink, flag);

if (flag == 1) binary_writer::write_string(m_sink, uti->name());

else binary_writer::write_int(m_sink, id);

const primitive_variant* values) {

const primitive_variant* end = values + size;

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

write_value(*values);

}