pbf_writer.hpp
Go to the documentation of this file.
#ifndef PROTOZERO_PBF_WRITER_HPP
#define PROTOZERO_PBF_WRITER_HPP
/*****************************************************************************
protozero - Minimalistic protocol buffer decoder and encoder in C++.
This file is from https://github.com/mapbox/protozero where you can find more
documentation.
*****************************************************************************/
#include <protozero/config.hpp>
#include <protozero/data_view.hpp>
#include <protozero/types.hpp>
#include <protozero/varint.hpp>
#if PROTOZERO_BYTE_ORDER != PROTOZERO_LITTLE_ENDIAN
# include <protozero/byteswap.hpp>
#endif
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <initializer_list>
#include <iterator>
#include <limits>
#include <string>
#include <utility>
namespace protozero {
namespace detail {
template <typename T> class packed_field_varint;
template <typename T> class packed_field_svarint;
template <typename T> class packed_field_fixed;
} // end namespace detail
class pbf_writer {
// A pointer to a string buffer holding the data already written to the
// PBF message. For default constructed writers or writers that have been
// rolled back, this is a nullptr.
std::string* m_data = nullptr;
// A pointer to a parent writer object if this is a submessage. If this
// is a top-level writer, it is a nullptr.
pbf_writer* m_parent_writer = nullptr;
// This is usually 0. If there is an open submessage, this is set in the
// parent to the rollback position, ie. the last position before the
// submessage was started. This is the position where the header of the
// submessage starts.
std::size_t m_rollback_pos = 0;
// This is usually 0. If there is an open submessage, this is set in the
// parent to the position where the data of the submessage is written to.
std::size_t m_pos = 0;
void add_varint(uint64_t value) {
protozero_assert(m_pos == 0 && "you can't add fields to a parent pbf_writer if there is an existing pbf_writer for a submessage");
protozero_assert(m_data);
write_varint(std::back_inserter(*m_data), value);
}
void add_field(pbf_tag_type tag, pbf_wire_type type) {
protozero_assert(((tag > 0 && tag < 19000) || (tag > 19999 && tag <= ((1u << 29u) - 1))) && "tag out of range");
const uint32_t b = (tag << 3u) | uint32_t(type);
add_varint(b);
}
void add_tagged_varint(pbf_tag_type tag, uint64_t value) {
add_field(tag, pbf_wire_type::varint);
add_varint(value);
}
template <typename T>
void add_fixed(T value) {
protozero_assert(m_pos == 0 && "you can't add fields to a parent pbf_writer if there is an existing pbf_writer for a submessage");
protozero_assert(m_data);
#if PROTOZERO_BYTE_ORDER != PROTOZERO_LITTLE_ENDIAN
byteswap_inplace(&value);
#endif
m_data->append(reinterpret_cast<const char*>(&value), sizeof(T));
}
template <typename T, typename It>
void add_packed_fixed(pbf_tag_type tag, It first, It last, std::input_iterator_tag /*unused*/) {
if (first == last) {
return;
}
pbf_writer sw{*this, tag};
while (first != last) {
sw.add_fixed<T>(*first++);
}
}
template <typename T, typename It>
void add_packed_fixed(pbf_tag_type tag, It first, It last, std::forward_iterator_tag /*unused*/) {
if (first == last) {
return;
}
const auto length = std::distance(first, last);
add_length_varint(tag, sizeof(T) * pbf_length_type(length));
reserve(sizeof(T) * std::size_t(length));
while (first != last) {
add_fixed<T>(*first++);
}
}
template <typename It>
void add_packed_varint(pbf_tag_type tag, It first, It last) {
if (first == last) {
return;
}
pbf_writer sw{*this, tag};
while (first != last) {
sw.add_varint(uint64_t(*first++));
}
}
template <typename It>
void add_packed_svarint(pbf_tag_type tag, It first, It last) {
if (first == last) {
return;
}
pbf_writer sw{*this, tag};
while (first != last) {
sw.add_varint(encode_zigzag64(*first++));
}
}
// The number of bytes to reserve for the varint holding the length of
// a length-delimited field. The length has to fit into pbf_length_type,
// and a varint needs 8 bit for every 7 bit.
enum constant_reserve_bytes : int {
reserve_bytes = sizeof(pbf_length_type) * 8 / 7 + 1
};
// If m_rollpack_pos is set to this special value, it means that when
// the submessage is closed, nothing needs to be done, because the length
// of the submessage has already been written correctly.
enum constant_size_is_known : std::size_t {
size_is_known = std::numeric_limits<std::size_t>::max()
};
void open_submessage(pbf_tag_type tag, std::size_t size) {
protozero_assert(m_pos == 0);
protozero_assert(m_data);
if (size == 0) {
m_rollback_pos = m_data->size();
add_field(tag, pbf_wire_type::length_delimited);
m_data->append(std::size_t(reserve_bytes), '\0');
} else {
m_rollback_pos = size_is_known;
add_length_varint(tag, pbf_length_type(size));
reserve(size);
}
m_pos = m_data->size();
}
void rollback_submessage() {
protozero_assert(m_pos != 0);
protozero_assert(m_rollback_pos != size_is_known);
protozero_assert(m_data);
m_data->resize(m_rollback_pos);
m_pos = 0;
}
void commit_submessage() {
protozero_assert(m_pos != 0);
protozero_assert(m_rollback_pos != size_is_known);
protozero_assert(m_data);
const auto length = pbf_length_type(m_data->size() - m_pos);
protozero_assert(m_data->size() >= m_pos - reserve_bytes);
const auto n = write_varint(m_data->begin() + int64_t(m_pos) - reserve_bytes, length);
m_data->erase(m_data->begin() + int64_t(m_pos) - reserve_bytes + n, m_data->begin() + int64_t(m_pos));
m_pos = 0;
}
void close_submessage() {
protozero_assert(m_data);
if (m_pos == 0 || m_rollback_pos == size_is_known) {
return;
}
if (m_data->size() - m_pos == 0) {
rollback_submessage();
} else {
commit_submessage();
}
}
void add_length_varint(pbf_tag_type tag, pbf_length_type length) {
add_field(tag, pbf_wire_type::length_delimited);
add_varint(length);
}
public:
explicit pbf_writer(std::string& data) noexcept :
m_data{&data} {
}
pbf_writer() noexcept = default;
pbf_writer(pbf_writer& parent_writer, pbf_tag_type tag, std::size_t size=0) :
m_data{parent_writer.m_data},
m_parent_writer{&parent_writer} {
m_parent_writer->open_submessage(tag, size);
}
pbf_writer(const pbf_writer&) = delete;
pbf_writer& operator=(const pbf_writer&) = delete;
pbf_writer(pbf_writer&& other) noexcept :
m_data{other.m_data},
m_parent_writer{other.m_parent_writer},
m_rollback_pos{other.m_rollback_pos},
m_pos{other.m_pos} {
other.m_data = nullptr;
other.m_parent_writer = nullptr;
other.m_rollback_pos = 0;
other.m_pos = 0;
}
pbf_writer& operator=(pbf_writer&& other) noexcept {
m_data = other.m_data;
m_parent_writer = other.m_parent_writer;
m_rollback_pos = other.m_rollback_pos;
m_pos = other.m_pos;
other.m_data = nullptr;
other.m_parent_writer = nullptr;
other.m_rollback_pos = 0;
other.m_pos = 0;
return *this;
}
~pbf_writer() {
if (m_parent_writer != nullptr) {
m_parent_writer->close_submessage();
}
}
bool valid() const noexcept {
return m_data != nullptr;
}
void swap(pbf_writer& other) noexcept {
using std::swap;
swap(m_data, other.m_data);
swap(m_parent_writer, other.m_parent_writer);
swap(m_rollback_pos, other.m_rollback_pos);
swap(m_pos, other.m_pos);
}
void reserve(std::size_t size) {
protozero_assert(m_data);
m_data->reserve(m_data->size() + size);
}
void commit() {
protozero_assert(m_parent_writer && "you can't call commit() on a pbf_writer without a parent");
protozero_assert(m_pos == 0 && "you can't call commit() on a pbf_writer that has an open nested submessage");
m_parent_writer->close_submessage();
m_parent_writer = nullptr;
m_data = nullptr;
}
void rollback() {
protozero_assert(m_parent_writer && "you can't call rollback() on a pbf_writer without a parent");
protozero_assert(m_pos == 0 && "you can't call rollback() on a pbf_writer that has an open nested submessage");
m_parent_writer->rollback_submessage();
m_parent_writer = nullptr;
m_data = nullptr;
}
void add_bool(pbf_tag_type tag, bool value) {
add_field(tag, pbf_wire_type::varint);
protozero_assert(m_pos == 0 && "you can't add fields to a parent pbf_writer if there is an existing pbf_writer for a submessage");
protozero_assert(m_data);
m_data->append(1, char(value));
}
void add_enum(pbf_tag_type tag, int32_t value) {
add_tagged_varint(tag, uint64_t(value));
}
void add_int32(pbf_tag_type tag, int32_t value) {
add_tagged_varint(tag, uint64_t(value));
}
void add_sint32(pbf_tag_type tag, int32_t value) {
add_tagged_varint(tag, encode_zigzag32(value));
}
void add_uint32(pbf_tag_type tag, uint32_t value) {
add_tagged_varint(tag, value);
}
void add_int64(pbf_tag_type tag, int64_t value) {
add_tagged_varint(tag, uint64_t(value));
}
void add_sint64(pbf_tag_type tag, int64_t value) {
add_tagged_varint(tag, encode_zigzag64(value));
}
void add_uint64(pbf_tag_type tag, uint64_t value) {
add_tagged_varint(tag, value);
}
void add_fixed32(pbf_tag_type tag, uint32_t value) {
add_field(tag, pbf_wire_type::fixed32);
add_fixed<uint32_t>(value);
}
void add_sfixed32(pbf_tag_type tag, int32_t value) {
add_field(tag, pbf_wire_type::fixed32);
add_fixed<int32_t>(value);
}
void add_fixed64(pbf_tag_type tag, uint64_t value) {
add_field(tag, pbf_wire_type::fixed64);
add_fixed<uint64_t>(value);
}
void add_sfixed64(pbf_tag_type tag, int64_t value) {
add_field(tag, pbf_wire_type::fixed64);
add_fixed<int64_t>(value);
}
void add_float(pbf_tag_type tag, float value) {
add_field(tag, pbf_wire_type::fixed32);
add_fixed<float>(value);
}
void add_double(pbf_tag_type tag, double value) {
add_field(tag, pbf_wire_type::fixed64);
add_fixed<double>(value);
}
void add_bytes(pbf_tag_type tag, const char* value, std::size_t size) {
protozero_assert(m_pos == 0 && "you can't add fields to a parent pbf_writer if there is an existing pbf_writer for a submessage");
protozero_assert(m_data);
protozero_assert(size <= std::numeric_limits<pbf_length_type>::max());
add_length_varint(tag, pbf_length_type(size));
m_data->append(value, size);
}
void add_bytes(pbf_tag_type tag, const data_view& value) {
add_bytes(tag, value.data(), value.size());
}
void add_bytes(pbf_tag_type tag, const std::string& value) {
add_bytes(tag, value.data(), value.size());
}
void add_bytes(pbf_tag_type tag, const char* value) {
add_bytes(tag, value, std::strlen(value));
}
template <typename... Ts>
void add_bytes_vectored(pbf_tag_type tag, Ts&&... values) {
protozero_assert(m_pos == 0 && "you can't add fields to a parent pbf_writer if there is an existing pbf_writer for a submessage");
protozero_assert(m_data);
size_t sum_size = 0;
(void)std::initializer_list<size_t>{sum_size += values.size()...};
protozero_assert(sum_size <= std::numeric_limits<pbf_length_type>::max());
add_length_varint(tag, pbf_length_type(sum_size));
m_data->reserve(m_data->size() + sum_size);
(void)std::initializer_list<int>{(m_data->append(values.data(), values.size()), 0)...};
}
void add_string(pbf_tag_type tag, const char* value, std::size_t size) {
add_bytes(tag, value, size);
}
void add_string(pbf_tag_type tag, const data_view& value) {
add_bytes(tag, value.data(), value.size());
}
void add_string(pbf_tag_type tag, const std::string& value) {
add_bytes(tag, value.data(), value.size());
}
void add_string(pbf_tag_type tag, const char* value) {
add_bytes(tag, value, std::strlen(value));
}
void add_message(pbf_tag_type tag, const char* value, std::size_t size) {
add_bytes(tag, value, size);
}
void add_message(pbf_tag_type tag, const data_view& value) {
add_bytes(tag, value.data(), value.size());
}
void add_message(pbf_tag_type tag, const std::string& value) {
add_bytes(tag, value.data(), value.size());
}
template <typename InputIterator>
void add_packed_bool(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_varint(tag, first, last);
}
template <typename InputIterator>
void add_packed_enum(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_varint(tag, first, last);
}
template <typename InputIterator>
void add_packed_int32(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_varint(tag, first, last);
}
template <typename InputIterator>
void add_packed_sint32(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_svarint(tag, first, last);
}
template <typename InputIterator>
void add_packed_uint32(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_varint(tag, first, last);
}
template <typename InputIterator>
void add_packed_int64(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_varint(tag, first, last);
}
template <typename InputIterator>
void add_packed_sint64(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_svarint(tag, first, last);
}
template <typename InputIterator>
void add_packed_uint64(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_varint(tag, first, last);
}
template <typename ValueType, typename InputIterator>
void add_packed_fixed(pbf_tag_type tag, InputIterator first, InputIterator last) {
static_assert(std::is_same<ValueType, uint32_t>::value ||
std::is_same<ValueType, int32_t>::value ||
std::is_same<ValueType, int64_t>::value ||
std::is_same<ValueType, uint64_t>::value ||
std::is_same<ValueType, double>::value ||
std::is_same<ValueType, float>::value, "Only some types are allowed");
add_packed_fixed<ValueType, InputIterator>(tag, first, last,
typename std::iterator_traits<InputIterator>::iterator_category{});
}
template <typename InputIterator>
void add_packed_fixed32(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_fixed<uint32_t, InputIterator>(tag, first, last,
typename std::iterator_traits<InputIterator>::iterator_category{});
}
template <typename InputIterator>
void add_packed_sfixed32(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_fixed<int32_t, InputIterator>(tag, first, last,
typename std::iterator_traits<InputIterator>::iterator_category{});
}
template <typename InputIterator>
void add_packed_fixed64(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_fixed<uint64_t, InputIterator>(tag, first, last,
typename std::iterator_traits<InputIterator>::iterator_category{});
}
template <typename InputIterator>
void add_packed_sfixed64(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_fixed<int64_t, InputIterator>(tag, first, last,
typename std::iterator_traits<InputIterator>::iterator_category{});
}
template <typename InputIterator>
void add_packed_float(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_fixed<float, InputIterator>(tag, first, last,
typename std::iterator_traits<InputIterator>::iterator_category{});
}
template <typename InputIterator>
void add_packed_double(pbf_tag_type tag, InputIterator first, InputIterator last) {
add_packed_fixed<double, InputIterator>(tag, first, last,
typename std::iterator_traits<InputIterator>::iterator_category{});
}
template <typename T> friend class detail::packed_field_varint;
template <typename T> friend class detail::packed_field_svarint;
template <typename T> friend class detail::packed_field_fixed;
}; // class pbf_writer
inline void swap(pbf_writer& lhs, pbf_writer& rhs) noexcept {
lhs.swap(rhs);
}
namespace detail {
class packed_field {
protected:
pbf_writer m_writer{};
public:
packed_field(const packed_field&) = delete;
packed_field& operator=(const packed_field&) = delete;
packed_field(packed_field&&) noexcept = default;
packed_field& operator=(packed_field&&) noexcept = default;
packed_field() = default;
packed_field(pbf_writer& parent_writer, pbf_tag_type tag) :
m_writer{parent_writer, tag} {
}
packed_field(pbf_writer& parent_writer, pbf_tag_type tag, std::size_t size) :
m_writer{parent_writer, tag, size} {
}
~packed_field() noexcept = default;
bool valid() const noexcept {
return m_writer.valid();
}
void commit() {
m_writer.commit();
}
void rollback() {
m_writer.rollback();
}
}; // class packed_field
template <typename T>
class packed_field_fixed : public packed_field {
public:
packed_field_fixed() :
packed_field{} {
}
template <typename P>
packed_field_fixed(pbf_writer& parent_writer, P tag) :
packed_field{parent_writer, static_cast<pbf_tag_type>(tag)} {
}
template <typename P>
packed_field_fixed(pbf_writer& parent_writer, P tag, std::size_t size) :
packed_field{parent_writer, static_cast<pbf_tag_type>(tag), size * sizeof(T)} {
}
void add_element(T value) {
m_writer.add_fixed<T>(value);
}
}; // class packed_field_fixed
template <typename T>
class packed_field_varint : public packed_field {
public:
packed_field_varint() :
packed_field{} {
}
template <typename P>
packed_field_varint(pbf_writer& parent_writer, P tag) :
packed_field{parent_writer, static_cast<pbf_tag_type>(tag)} {
}
void add_element(T value) {
m_writer.add_varint(uint64_t(value));
}
}; // class packed_field_varint
template <typename T>
class packed_field_svarint : public packed_field {
public:
packed_field_svarint() :
packed_field{} {
}
template <typename P>
packed_field_svarint(pbf_writer& parent_writer, P tag) :
packed_field{parent_writer, static_cast<pbf_tag_type>(tag)} {
}
void add_element(T value) {
m_writer.add_varint(encode_zigzag64(value));
}
}; // class packed_field_svarint
} // end namespace detail
using packed_field_bool = detail::packed_field_varint<bool>;
using packed_field_enum = detail::packed_field_varint<int32_t>;
using packed_field_int32 = detail::packed_field_varint<int32_t>;
using packed_field_sint32 = detail::packed_field_svarint<int32_t>;
using packed_field_uint32 = detail::packed_field_varint<uint32_t>;
using packed_field_int64 = detail::packed_field_varint<int64_t>;
using packed_field_sint64 = detail::packed_field_svarint<int64_t>;
using packed_field_uint64 = detail::packed_field_varint<uint64_t>;
using packed_field_fixed32 = detail::packed_field_fixed<uint32_t>;
using packed_field_sfixed32 = detail::packed_field_fixed<int32_t>;
using packed_field_fixed64 = detail::packed_field_fixed<uint64_t>;
using packed_field_sfixed64 = detail::packed_field_fixed<int64_t>;
using packed_field_float = detail::packed_field_fixed<float>;
using packed_field_double = detail::packed_field_fixed<double>;
} // end namespace protozero
#endif // PROTOZERO_PBF_WRITER_HPP
protozero::pbf_writer::add_packed_fixed64
void add_packed_fixed64(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:857
protozero::pbf_writer::add_packed_sint32
void add_packed_sint32(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:728
protozero::packed_field_float
detail::packed_field_fixed< float > packed_field_float
Class for generating packed repeated float fields.
Definition: pbf_writer.hpp:1071
protozero::pbf_writer::add_packed_sint64
void add_packed_sint64(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:770
protozero::pbf_writer::add_string
void add_string(pbf_tag_type tag, const char *value)
Definition: pbf_writer.hpp:634
protozero::pbf_writer::add_packed_sfixed64
void add_packed_sfixed64(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:872
protozero::pbf_writer::rollback
void rollback()
Definition: pbf_writer.hpp:357
protozero::pbf_writer::add_packed_sfixed32
void add_packed_sfixed32(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:842
protozero::encode_zigzag64
constexpr uint64_t encode_zigzag64(int64_t value) noexcept
Definition: varint.hpp:185
protozero::pbf_writer::reserve
void reserve(std::size_t size)
Definition: pbf_writer.hpp:328
protozero::pbf_writer::add_sint64
void add_sint64(pbf_tag_type tag, int64_t value)
Definition: pbf_writer.hpp:439
protozero::pbf_writer::add_message
void add_message(pbf_tag_type tag, const char *value, std::size_t size)
Definition: pbf_writer.hpp:645
protozero::pbf_writer::pbf_writer
pbf_writer(pbf_writer &&other) noexcept
Definition: pbf_writer.hpp:265
protozero::packed_field_int64
detail::packed_field_varint< int64_t > packed_field_int64
Class for generating packed repeated int64 fields.
Definition: pbf_writer.hpp:1050
protozero::pbf_writer::add_sfixed64
void add_sfixed64(pbf_tag_type tag, int64_t value)
Definition: pbf_writer.hpp:492
protozero::pbf_writer::add_uint32
void add_uint32(pbf_tag_type tag, uint32_t value)
Definition: pbf_writer.hpp:419
protozero::pbf_writer::add_bytes
void add_bytes(pbf_tag_type tag, const std::string &value)
Definition: pbf_writer.hpp:550
protozero::pbf_writer::add_string
void add_string(pbf_tag_type tag, const char *value, std::size_t size)
Definition: pbf_writer.hpp:603
protozero::pbf_writer::add_packed_enum
void add_packed_enum(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:700
protozero::packed_field_sfixed64
detail::packed_field_fixed< int64_t > packed_field_sfixed64
Class for generating packed repeated sfixed64 fields.
Definition: pbf_writer.hpp:1068
protozero::pbf_writer::add_message
void add_message(pbf_tag_type tag, const data_view &value)
Definition: pbf_writer.hpp:655
protozero::pbf_writer::add_packed_fixed
void add_packed_fixed(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:806
protozero::pbf_writer
Definition: pbf_writer.hpp:53
protozero::pbf_writer::add_int64
void add_int64(pbf_tag_type tag, int64_t value)
Definition: pbf_writer.hpp:429
config.hpp
Contains macro checks for different configurations.
protozero::packed_field_bool
detail::packed_field_varint< bool > packed_field_bool
Class for generating packed repeated bool fields.
Definition: pbf_writer.hpp:1035
protozero::packed_field_double
detail::packed_field_fixed< double > packed_field_double
Class for generating packed repeated double fields.
Definition: pbf_writer.hpp:1074
types.hpp
Contains the declaration of low-level types used in the pbf format.
protozero::encode_zigzag32
constexpr uint32_t encode_zigzag32(int32_t value) noexcept
Definition: varint.hpp:178
protozero::pbf_writer::add_int32
void add_int32(pbf_tag_type tag, int32_t value)
Definition: pbf_writer.hpp:399
protozero::pbf_writer::add_string
void add_string(pbf_tag_type tag, const std::string &value)
Definition: pbf_writer.hpp:623
protozero::pbf_writer::operator=
pbf_writer & operator=(pbf_writer &&other) noexcept
Definition: pbf_writer.hpp:280
protozero::write_varint
int write_varint(T data, uint64_t value)
Definition: varint.hpp:145
protozero::pbf_writer::add_uint64
void add_uint64(pbf_tag_type tag, uint64_t value)
Definition: pbf_writer.hpp:449
protozero::data_view::size
constexpr std::size_t size() const noexcept
Return length of data in bytes.
Definition: data_view.hpp:99
protozero::pbf_writer::add_string
void add_string(pbf_tag_type tag, const data_view &value)
Definition: pbf_writer.hpp:613
protozero::packed_field_int32
detail::packed_field_varint< int32_t > packed_field_int32
Class for generating packed repeated int32 fields.
Definition: pbf_writer.hpp:1041
protozero::pbf_wire_type
pbf_wire_type
Definition: types.hpp:40
protozero::pbf_writer::add_message
void add_message(pbf_tag_type tag, const std::string &value)
Definition: pbf_writer.hpp:665
protozero::pbf_writer::add_float
void add_float(pbf_tag_type tag, float value)
Definition: pbf_writer.hpp:503
data_view.hpp
Contains the implementation of the data_view class.
protozero::pbf_writer::swap
void swap(pbf_writer &other) noexcept
Definition: pbf_writer.hpp:312
protozero::pbf_writer::add_enum
void add_enum(pbf_tag_type tag, int32_t value)
Definition: pbf_writer.hpp:389
protozero::packed_field_sint64
detail::packed_field_svarint< int64_t > packed_field_sint64
Class for generating packed repeated sint64 fields.
Definition: pbf_writer.hpp:1053
protozero::pbf_writer::add_packed_uint64
void add_packed_uint64(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:784
protozero::pbf_writer::add_bytes_vectored
void add_bytes_vectored(pbf_tag_type tag, Ts &&... values)
Definition: pbf_writer.hpp:585
byteswap.hpp
Contains functions to swap bytes in values (for different endianness).
protozero::pbf_writer::add_packed_uint32
void add_packed_uint32(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:742
protozero::pbf_writer::add_packed_int64
void add_packed_int64(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:756
protozero::pbf_writer::add_fixed64
void add_fixed64(pbf_tag_type tag, uint64_t value)
Definition: pbf_writer.hpp:481
protozero::pbf_length_type
uint32_t pbf_length_type
Definition: types.hpp:62
protozero::pbf_writer::add_bool
void add_bool(pbf_tag_type tag, bool value)
Definition: pbf_writer.hpp:376
protozero::pbf_writer::add_packed_bool
void add_packed_bool(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:686
protozero::packed_field_fixed64
detail::packed_field_fixed< uint64_t > packed_field_fixed64
Class for generating packed repeated fixed64 fields.
Definition: pbf_writer.hpp:1065
protozero::packed_field_sfixed32
detail::packed_field_fixed< int32_t > packed_field_sfixed32
Class for generating packed repeated sfixed32 fields.
Definition: pbf_writer.hpp:1062
protozero::pbf_tag_type
uint32_t pbf_tag_type
Definition: types.hpp:33
protozero::packed_field_uint32
detail::packed_field_varint< uint32_t > packed_field_uint32
Class for generating packed repeated uint32 fields.
Definition: pbf_writer.hpp:1047
protozero::pbf_writer::commit
void commit()
Definition: pbf_writer.hpp:341
protozero::swap
void swap(pbf_writer &lhs, pbf_writer &rhs) noexcept
Definition: pbf_writer.hpp:921
protozero::pbf_writer::add_packed_double
void add_packed_double(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:902
protozero::data_view
Definition: data_view.hpp:39
protozero::pbf_writer::add_packed_float
void add_packed_float(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:887
protozero::packed_field_uint64
detail::packed_field_varint< uint64_t > packed_field_uint64
Class for generating packed repeated uint64 fields.
Definition: pbf_writer.hpp:1056
protozero::byteswap_inplace
void byteswap_inplace(uint32_t *ptr) noexcept
byteswap the data pointed to by ptr in-place.
Definition: byteswap.hpp:55
protozero::pbf_writer::add_packed_int32
void add_packed_int32(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:714
protozero::pbf_writer::pbf_writer
pbf_writer(pbf_writer &parent_writer, pbf_tag_type tag, std::size_t size=0)
Definition: pbf_writer.hpp:249
protozero::data_view::data
constexpr const char * data() const noexcept
Return pointer to data.
Definition: data_view.hpp:94
protozero::pbf_writer::add_sfixed32
void add_sfixed32(pbf_tag_type tag, int32_t value)
Definition: pbf_writer.hpp:470
protozero::pbf_writer::pbf_writer
pbf_writer(std::string &data) noexcept
Definition: pbf_writer.hpp:229
varint.hpp
Contains low-level varint and zigzag encoding and decoding functions.
protozero::pbf_writer::add_sint32
void add_sint32(pbf_tag_type tag, int32_t value)
Definition: pbf_writer.hpp:409
protozero::packed_field_enum
detail::packed_field_varint< int32_t > packed_field_enum
Class for generating packed repeated enum fields.
Definition: pbf_writer.hpp:1038
protozero::pbf_writer::add_fixed32
void add_fixed32(pbf_tag_type tag, uint32_t value)
Definition: pbf_writer.hpp:459
protozero::packed_field_fixed32
detail::packed_field_fixed< uint32_t > packed_field_fixed32
Class for generating packed repeated fixed32 fields.
Definition: pbf_writer.hpp:1059
protozero::pbf_writer::add_bytes
void add_bytes(pbf_tag_type tag, const data_view &value)
Definition: pbf_writer.hpp:540
protozero::pbf_writer::valid
bool valid() const noexcept
Definition: pbf_writer.hpp:303
protozero::pbf_writer::add_packed_fixed32
void add_packed_fixed32(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition: pbf_writer.hpp:827
protozero::pbf_writer::add_double
void add_double(pbf_tag_type tag, double value)
Definition: pbf_writer.hpp:514
protozero::packed_field_sint32
detail::packed_field_svarint< int32_t > packed_field_sint32
Class for generating packed repeated sint32 fields.
Definition: pbf_writer.hpp:1044
protozero::pbf_writer::add_bytes
void add_bytes(pbf_tag_type tag, const char *value)
Definition: pbf_writer.hpp:561
protozero::pbf_writer::add_bytes
void add_bytes(pbf_tag_type tag, const char *value, std::size_t size)
Definition: pbf_writer.hpp:526
protozero
All parts of the protozero header-only library are in this namespace.
Definition: byteswap.hpp:23
protozero::swap
void swap(data_view &lhs, data_view &rhs) noexcept
Definition: data_view.hpp:165