Loading...
Searching...
No Matches
basic_pbf_writer.hpp
Go to the documentation of this file.
#ifndef PROTOZERO_BASIC_PBF_WRITER_HPP
#define PROTOZERO_BASIC_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 "buffer_tmpl.hpp"
#include "config.hpp"
#include "data_view.hpp"
#include "types.hpp"
#include "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 B, typename T> class packed_field_varint;
template <typename B, typename T> class packed_field_svarint;
template <typename B, typename T> class packed_field_fixed;
} // end namespace detail
template <typename TBuffer>
class basic_pbf_writer {
// A pointer to a 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.
TBuffer* 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.
basic_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 basic_pbf_writer if there is an existing basic_pbf_writer for a submessage");
protozero_assert(m_data);
add_varint_to_buffer(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) | static_cast<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 basic_pbf_writer if there is an existing basic_pbf_writer for a submessage");
protozero_assert(m_data);
#if PROTOZERO_BYTE_ORDER != PROTOZERO_LITTLE_ENDIAN
byteswap_inplace(&value);
#endif
buffer_customization<TBuffer>::append(m_data, 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*/) { // NOLINT(performance-unnecessary-value-param)
if (first == last) {
return;
}
basic_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*/) { // NOLINT(performance-unnecessary-value-param)
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) { // NOLINT(performance-unnecessary-value-param)
if (first == last) {
return;
}
basic_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) { // NOLINT(performance-unnecessary-value-param)
if (first == last) {
return;
}
basic_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 : 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 : 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 = buffer_customization<TBuffer>::size(m_data);
add_field(tag, pbf_wire_type::length_delimited);
buffer_customization<TBuffer>::append_zeros(m_data, std::size_t(reserve_bytes));
} else {
m_rollback_pos = size_is_known;
add_length_varint(tag, static_cast<pbf_length_type>(size));
reserve(size);
}
m_pos = buffer_customization<TBuffer>::size(m_data);
}
void rollback_submessage() {
protozero_assert(m_pos != 0);
protozero_assert(m_rollback_pos != size_is_known);
protozero_assert(m_data);
buffer_customization<TBuffer>::resize(m_data, 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(buffer_customization<TBuffer>::size(m_data) - m_pos);
protozero_assert(buffer_customization<TBuffer>::size(m_data) >= m_pos - reserve_bytes);
const auto n = add_varint_to_buffer(buffer_customization<TBuffer>::at_pos(m_data, m_pos - reserve_bytes), length);
buffer_customization<TBuffer>::erase_range(m_data, m_pos - reserve_bytes + n, m_pos);
m_pos = 0;
}
void close_submessage() {
protozero_assert(m_data);
if (m_pos == 0 || m_rollback_pos == size_is_known) {
return;
}
if (buffer_customization<TBuffer>::size(m_data) - 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 basic_pbf_writer(TBuffer& buffer) noexcept :
m_data{&buffer} {
}
basic_pbf_writer() noexcept = default;
basic_pbf_writer(basic_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);
}
basic_pbf_writer(const basic_pbf_writer&) = delete;
basic_pbf_writer& operator=(const basic_pbf_writer&) = delete;
basic_pbf_writer(basic_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;
}
basic_pbf_writer& operator=(basic_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;
}
~basic_pbf_writer() noexcept {
try {
if (m_parent_writer != nullptr) {
m_parent_writer->close_submessage();
}
} catch (...) {
// This try/catch is used to make the destructor formally noexcept.
// close_submessage() is not noexcept, but will not throw the way
// it is called here, so we are good. But to be paranoid, call...
std::terminate();
}
}
bool valid() const noexcept {
return m_data != nullptr;
}
void swap(basic_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);
buffer_customization<TBuffer>::reserve_additional(m_data, size);
}
void commit() {
protozero_assert(m_parent_writer && "you can't call commit() on a basic_pbf_writer without a parent");
protozero_assert(m_pos == 0 && "you can't call commit() on a basic_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 basic_pbf_writer without a parent");
protozero_assert(m_pos == 0 && "you can't call rollback() on a basic_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 basic_pbf_writer if there is an existing basic_pbf_writer for a submessage");
protozero_assert(m_data);
m_data->push_back(static_cast<char>(value));
}
void add_enum(pbf_tag_type tag, int32_t value) {
add_tagged_varint(tag, static_cast<uint64_t>(value));
}
void add_int32(pbf_tag_type tag, int32_t value) {
add_tagged_varint(tag, static_cast<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, static_cast<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 basic_pbf_writer if there is an existing basic_pbf_writer for a submessage");
protozero_assert(m_data);
protozero_assert(size <= std::numeric_limits<pbf_length_type>::max());
add_length_varint(tag, static_cast<pbf_length_type>(size));
buffer_customization<TBuffer>::append(m_data, 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 basic_pbf_writer if there is an existing basic_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, static_cast<pbf_length_type>(sum_size));
buffer_customization<TBuffer>::reserve_additional(m_data, sum_size);
(void)std::initializer_list<int>{(buffer_customization<TBuffer>::append(m_data, 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) { // NOLINT(performance-unnecessary-value-param)
add_packed_varint(tag, first, last);
}
template <typename InputIterator>
void add_packed_enum(pbf_tag_type tag, InputIterator first, InputIterator last) { // NOLINT(performance-unnecessary-value-param)
add_packed_varint(tag, first, last);
}
template <typename InputIterator>
void add_packed_int32(pbf_tag_type tag, InputIterator first, InputIterator last) { // NOLINT(performance-unnecessary-value-param)
add_packed_varint(tag, first, last);
}
template <typename InputIterator>
void add_packed_sint32(pbf_tag_type tag, InputIterator first, InputIterator last) { // NOLINT(performance-unnecessary-value-param)
add_packed_svarint(tag, first, last);
}
template <typename InputIterator>
void add_packed_uint32(pbf_tag_type tag, InputIterator first, InputIterator last) { // NOLINT(performance-unnecessary-value-param)
add_packed_varint(tag, first, last);
}
template <typename InputIterator>
void add_packed_int64(pbf_tag_type tag, InputIterator first, InputIterator last) { // NOLINT(performance-unnecessary-value-param)
add_packed_varint(tag, first, last);
}
template <typename InputIterator>
void add_packed_sint64(pbf_tag_type tag, InputIterator first, InputIterator last) { // NOLINT(performance-unnecessary-value-param)
add_packed_svarint(tag, first, last);
}
template <typename InputIterator>
void add_packed_uint64(pbf_tag_type tag, InputIterator first, InputIterator last) { // NOLINT(performance-unnecessary-value-param)
add_packed_varint(tag, first, last);
}
template <typename ValueType, typename InputIterator>
void add_packed_fixed(pbf_tag_type tag, InputIterator first, InputIterator last) { // NOLINT(performance-unnecessary-value-param)
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) { // NOLINT(performance-unnecessary-value-param)
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) { // NOLINT(performance-unnecessary-value-param)
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) { // NOLINT(performance-unnecessary-value-param)
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) { // NOLINT(performance-unnecessary-value-param)
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) { // NOLINT(performance-unnecessary-value-param)
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) { // NOLINT(performance-unnecessary-value-param)
add_packed_fixed<double, InputIterator>(tag, first, last,
typename std::iterator_traits<InputIterator>::iterator_category{});
}
template <typename B, typename T> friend class detail::packed_field_varint;
template <typename B, typename T> friend class detail::packed_field_svarint;
template <typename B, typename T> friend class detail::packed_field_fixed;
}; // class basic_pbf_writer
template <typename TBuffer>
inline void swap(basic_pbf_writer<TBuffer>& lhs, basic_pbf_writer<TBuffer>& rhs) noexcept {
lhs.swap(rhs);
}
namespace detail {
template <typename TBuffer>
class packed_field {
basic_pbf_writer<TBuffer> 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(basic_pbf_writer<TBuffer>& parent_writer, pbf_tag_type tag) :
m_writer{parent_writer, tag} {
}
packed_field(basic_pbf_writer<TBuffer>& 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();
}
basic_pbf_writer<TBuffer>& writer() noexcept {
return m_writer;
}
}; // class packed_field
template <typename TBuffer, typename T>
class packed_field_fixed : public packed_field<TBuffer> {
public:
packed_field_fixed() :
packed_field<TBuffer>{} {
}
template <typename P>
packed_field_fixed(basic_pbf_writer<TBuffer>& parent_writer, P tag) :
packed_field<TBuffer>{parent_writer, static_cast<pbf_tag_type>(tag)} {
}
template <typename P>
packed_field_fixed(basic_pbf_writer<TBuffer>& parent_writer, P tag, std::size_t size) :
packed_field<TBuffer>{parent_writer, static_cast<pbf_tag_type>(tag), size * sizeof(T)} {
}
void add_element(T value) {
this->writer().template add_fixed<T>(value);
}
}; // class packed_field_fixed
template <typename TBuffer, typename T>
class packed_field_varint : public packed_field<TBuffer> {
public:
packed_field_varint() :
packed_field<TBuffer>{} {
}
template <typename P>
packed_field_varint(basic_pbf_writer<TBuffer>& parent_writer, P tag) :
packed_field<TBuffer>{parent_writer, static_cast<pbf_tag_type>(tag)} {
}
void add_element(T value) {
this->writer().add_varint(uint64_t(value));
}
}; // class packed_field_varint
template <typename TBuffer, typename T>
class packed_field_svarint : public packed_field<TBuffer> {
public:
packed_field_svarint() :
packed_field<TBuffer>{} {
}
template <typename P>
packed_field_svarint(basic_pbf_writer<TBuffer>& parent_writer, P tag) :
packed_field<TBuffer>{parent_writer, static_cast<pbf_tag_type>(tag)} {
}
void add_element(T value) {
this->writer().add_varint(encode_zigzag64(value));
}
}; // class packed_field_svarint
} // end namespace detail
} // end namespace protozero
#endif // PROTOZERO_BASIC_PBF_WRITER_HPP
buffer_tmpl.hpp
Contains the customization points for buffer implementations.
byteswap.hpp
Contains functions to swap bytes in values (for different endianness).
protozero::basic_pbf_writer
Definition basic_pbf_writer.hpp:59
protozero::basic_pbf_writer::rollback
void rollback()
Definition basic_pbf_writer.hpp:371
protozero::basic_pbf_writer::add_string
void add_string(pbf_tag_type tag, const char *value, std::size_t size)
Definition basic_pbf_writer.hpp:617
protozero::basic_pbf_writer::add_packed_sfixed64
void add_packed_sfixed64(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:886
protozero::basic_pbf_writer::add_bytes
void add_bytes(pbf_tag_type tag, const char *value, std::size_t size)
Definition basic_pbf_writer.hpp:540
protozero::basic_pbf_writer::add_enum
void add_enum(pbf_tag_type tag, int32_t value)
Definition basic_pbf_writer.hpp:403
protozero::basic_pbf_writer::add_packed_fixed
void add_packed_fixed(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:820
protozero::basic_pbf_writer::add_uint32
void add_uint32(pbf_tag_type tag, uint32_t value)
Definition basic_pbf_writer.hpp:433
protozero::basic_pbf_writer::add_float
void add_float(pbf_tag_type tag, float value)
Definition basic_pbf_writer.hpp:517
protozero::basic_pbf_writer::add_packed_sint32
void add_packed_sint32(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:742
protozero::basic_pbf_writer::basic_pbf_writer
basic_pbf_writer(basic_pbf_writer &&other) noexcept
Definition basic_pbf_writer.hpp:272
protozero::basic_pbf_writer::add_packed_float
void add_packed_float(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:901
protozero::basic_pbf_writer::add_packed_sfixed32
void add_packed_sfixed32(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:856
protozero::basic_pbf_writer::add_fixed32
void add_fixed32(pbf_tag_type tag, uint32_t value)
Definition basic_pbf_writer.hpp:473
protozero::basic_pbf_writer::add_bytes_vectored
void add_bytes_vectored(pbf_tag_type tag, Ts &&... values)
Definition basic_pbf_writer.hpp:599
protozero::basic_pbf_writer::add_fixed64
void add_fixed64(pbf_tag_type tag, uint64_t value)
Definition basic_pbf_writer.hpp:495
protozero::basic_pbf_writer::basic_pbf_writer
basic_pbf_writer(TBuffer &buffer) noexcept
Definition basic_pbf_writer.hpp:236
protozero::basic_pbf_writer::commit
void commit()
Definition basic_pbf_writer.hpp:355
protozero::basic_pbf_writer::add_packed_int64
void add_packed_int64(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:770
protozero::basic_pbf_writer::add_message
void add_message(pbf_tag_type tag, const data_view &value)
Definition basic_pbf_writer.hpp:669
protozero::basic_pbf_writer::reserve
void reserve(std::size_t size)
Definition basic_pbf_writer.hpp:342
protozero::basic_pbf_writer::add_sfixed32
void add_sfixed32(pbf_tag_type tag, int32_t value)
Definition basic_pbf_writer.hpp:484
protozero::basic_pbf_writer::add_string
void add_string(pbf_tag_type tag, const std::string &value)
Definition basic_pbf_writer.hpp:637
protozero::basic_pbf_writer::add_packed_enum
void add_packed_enum(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:714
protozero::basic_pbf_writer::operator=
basic_pbf_writer & operator=(const basic_pbf_writer &)=delete
A basic_pbf_writer object can not be copied.
protozero::basic_pbf_writer::add_packed_uint64
void add_packed_uint64(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:798
protozero::basic_pbf_writer::add_bool
void add_bool(pbf_tag_type tag, bool value)
Definition basic_pbf_writer.hpp:390
protozero::basic_pbf_writer::operator=
basic_pbf_writer & operator=(basic_pbf_writer &&other) noexcept
Definition basic_pbf_writer.hpp:287
protozero::basic_pbf_writer::add_packed_double
void add_packed_double(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:916
protozero::basic_pbf_writer::add_message
void add_message(pbf_tag_type tag, const std::string &value)
Definition basic_pbf_writer.hpp:679
protozero::basic_pbf_writer::add_bytes
void add_bytes(pbf_tag_type tag, const data_view &value)
Definition basic_pbf_writer.hpp:554
protozero::basic_pbf_writer::basic_pbf_writer
basic_pbf_writer(const basic_pbf_writer &)=delete
A basic_pbf_writer object can not be copied.
protozero::basic_pbf_writer::add_bytes
void add_bytes(pbf_tag_type tag, const std::string &value)
Definition basic_pbf_writer.hpp:564
protozero::basic_pbf_writer::add_uint64
void add_uint64(pbf_tag_type tag, uint64_t value)
Definition basic_pbf_writer.hpp:463
protozero::basic_pbf_writer::add_packed_fixed32
void add_packed_fixed32(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:841
protozero::basic_pbf_writer::basic_pbf_writer
basic_pbf_writer() noexcept=default
protozero::basic_pbf_writer::add_bytes
void add_bytes(pbf_tag_type tag, const char *value)
Definition basic_pbf_writer.hpp:575
protozero::basic_pbf_writer::add_string
void add_string(pbf_tag_type tag, const data_view &value)
Definition basic_pbf_writer.hpp:627
protozero::basic_pbf_writer::add_sint32
void add_sint32(pbf_tag_type tag, int32_t value)
Definition basic_pbf_writer.hpp:423
protozero::basic_pbf_writer::add_int64
void add_int64(pbf_tag_type tag, int64_t value)
Definition basic_pbf_writer.hpp:443
protozero::basic_pbf_writer::add_packed_uint32
void add_packed_uint32(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:756
protozero::basic_pbf_writer::add_int32
void add_int32(pbf_tag_type tag, int32_t value)
Definition basic_pbf_writer.hpp:413
protozero::basic_pbf_writer::add_sfixed64
void add_sfixed64(pbf_tag_type tag, int64_t value)
Definition basic_pbf_writer.hpp:506
protozero::basic_pbf_writer::swap
void swap(basic_pbf_writer &other) noexcept
Definition basic_pbf_writer.hpp:326
protozero::basic_pbf_writer::add_string
void add_string(pbf_tag_type tag, const char *value)
Definition basic_pbf_writer.hpp:648
protozero::basic_pbf_writer::valid
bool valid() const noexcept
Definition basic_pbf_writer.hpp:317
protozero::basic_pbf_writer::add_double
void add_double(pbf_tag_type tag, double value)
Definition basic_pbf_writer.hpp:528
protozero::basic_pbf_writer::add_packed_fixed64
void add_packed_fixed64(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:871
protozero::basic_pbf_writer::add_sint64
void add_sint64(pbf_tag_type tag, int64_t value)
Definition basic_pbf_writer.hpp:453
protozero::basic_pbf_writer::add_packed_int32
void add_packed_int32(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:728
protozero::basic_pbf_writer::add_packed_bool
void add_packed_bool(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:700
protozero::basic_pbf_writer::add_message
void add_message(pbf_tag_type tag, const char *value, std::size_t size)
Definition basic_pbf_writer.hpp:659
protozero::basic_pbf_writer::add_packed_sint64
void add_packed_sint64(pbf_tag_type tag, InputIterator first, InputIterator last)
Definition basic_pbf_writer.hpp:784
protozero::data_view
Definition data_view.hpp:39
protozero::data_view::size
constexpr std::size_t size() const noexcept
Return length of data in bytes.
Definition data_view.hpp:99
protozero::data_view::data
constexpr const char * data() const noexcept
Return pointer to data.
Definition data_view.hpp:94
config.hpp
Contains macro checks for different configurations.
data_view.hpp
Contains the implementation of the data_view class.
protozero
All parts of the protozero header-only library are in this namespace.
Definition basic_pbf_builder.hpp:24
protozero::pbf_tag_type
uint32_t pbf_tag_type
Definition types.hpp:33
protozero::pbf_length_type
uint32_t pbf_length_type
Definition types.hpp:62
protozero::swap
void swap(basic_pbf_writer< TBuffer > &lhs, basic_pbf_writer< TBuffer > &rhs) noexcept
Definition basic_pbf_writer.hpp:936
protozero::add_varint_to_buffer
void add_varint_to_buffer(TBuffer *buffer, uint64_t value)
Definition varint.hpp:169
protozero::pbf_wire_type
pbf_wire_type
Definition types.hpp:40
protozero::encode_zigzag32
constexpr uint32_t encode_zigzag32(int32_t value) noexcept
Definition varint.hpp:217
protozero::encode_zigzag64
constexpr uint64_t encode_zigzag64(int64_t value) noexcept
Definition varint.hpp:224
protozero::byteswap_inplace
void byteswap_inplace(uint32_t *ptr) noexcept
byteswap the data pointed to by ptr in-place.
Definition byteswap.hpp:56
types.hpp
Contains the declaration of low-level types used in the pbf format.
varint.hpp
Contains low-level varint and zigzag encoding and decoding functions.