1#ifndef PROTOZERO_PBF_READER_HPP 
    2#define PROTOZERO_PBF_READER_HPP 
   26#if PROTOZERO_BYTE_ORDER != PROTOZERO_LITTLE_ENDIAN 
   65    const char* m_data = 
nullptr;
 
   68    const char* m_end = 
nullptr;
 
   79        const char* tmp_data = m_data;
 
   80        skip_bytes(
sizeof(T));
 
   81        std::memcpy(&result, tmp_data, 
sizeof(T));
 
   82#if PROTOZERO_BYTE_ORDER != PROTOZERO_LITTLE_ENDIAN 
   90        protozero_assert(
tag() != 0 && 
"call next() before accessing field value");
 
   91        const auto len = get_len_and_skip();
 
   92        if (len % 
sizeof(T) != 0) {
 
  101        const auto val = 
static_cast<T
>(
decode_varint(&m_data, m_end));
 
  105    template <
typename T>
 
  112        return get_varint<pbf_length_type>();
 
  116        if (m_end - m_data < 
static_cast<ptrdiff_t
>(len)) {
 
  129        const auto len = get_length();
 
  134    template <
typename T>
 
  136        protozero_assert(
tag() != 0 && 
"call next() before accessing field value");
 
  137        const auto len = get_len_and_skip();
 
  138        return {T{m_data - len, m_data},
 
  155        : m_data{view.data()},
 
  156          m_end{view.data() + view.size()} {
 
 
  174#ifndef PROTOZERO_STRICT_API 
  187        : m_data{
data.first},
 
 
  203        : m_data{
data.data()},
 
 
  234        swap(m_data, other.m_data);
 
  235        swap(m_end, other.m_end);
 
  236        swap(m_wire_type, other.m_wire_type);
 
  237        swap(m_tag, other.m_tag);
 
 
  245    operator bool() const noexcept { 
 
  246        return m_data != m_end;
 
 
  253        return {m_data, 
static_cast<std::size_t
>(m_end - m_data)};
 
 
  266        return static_cast<std::size_t
>(m_end - m_data);
 
 
  285        if (m_data == m_end) {
 
  289        const auto value = get_varint<uint32_t>();
 
  294        if (m_tag == 0 || (m_tag >= 19000 && m_tag <= 19999)) {
 
  299        switch (m_wire_type) {
 
  300            case pbf_wire_type::varint:
 
  301            case pbf_wire_type::fixed64:
 
  302            case pbf_wire_type::length_delimited:
 
  303            case pbf_wire_type::fixed32:
 
 
  342            if (m_tag == next_tag) {
 
 
  380            if (m_tag == next_tag && m_wire_type == type) {
 
 
  463        protozero_assert(
tag() != 0 && 
"call next() before calling skip()");
 
  465            case pbf_wire_type::varint:
 
  468            case pbf_wire_type::fixed64:
 
  471            case pbf_wire_type::length_delimited:
 
  472                skip_bytes(get_length());
 
  474            case pbf_wire_type::fixed32:
 
 
  495        protozero_assert(
tag() != 0 && 
"call next() before accessing field value");
 
  496        protozero_assert(
has_wire_type(pbf_wire_type::varint) && 
"not a varint");
 
  497        const bool result = m_data[0] != 0;
 
 
  510        protozero_assert(
has_wire_type(pbf_wire_type::varint) && 
"not a varint");
 
  511        return get_varint<int32_t>();
 
 
  522        protozero_assert(
has_wire_type(pbf_wire_type::varint) && 
"not a varint");
 
  523        return get_varint<int32_t>();
 
 
  534        protozero_assert(
has_wire_type(pbf_wire_type::varint) && 
"not a varint");
 
  535        return get_svarint<int32_t>();
 
 
  546        protozero_assert(
has_wire_type(pbf_wire_type::varint) && 
"not a varint");
 
  547        return get_varint<uint32_t>();
 
 
  558        protozero_assert(
has_wire_type(pbf_wire_type::varint) && 
"not a varint");
 
  559        return get_varint<int64_t>();
 
 
  570        protozero_assert(
has_wire_type(pbf_wire_type::varint) && 
"not a varint");
 
  571        return get_svarint<int64_t>();
 
 
  582        protozero_assert(
has_wire_type(pbf_wire_type::varint) && 
"not a varint");
 
  583        return get_varint<uint64_t>();
 
 
  594        protozero_assert(
tag() != 0 && 
"call next() before accessing field value");
 
  595        protozero_assert(
has_wire_type(pbf_wire_type::fixed32) && 
"not a 32-bit fixed");
 
  596        return get_fixed<uint32_t>();
 
 
  607        protozero_assert(
tag() != 0 && 
"call next() before accessing field value");
 
  608        protozero_assert(
has_wire_type(pbf_wire_type::fixed32) && 
"not a 32-bit fixed");
 
  609        return get_fixed<int32_t>();
 
 
  620        protozero_assert(
tag() != 0 && 
"call next() before accessing field value");
 
  621        protozero_assert(
has_wire_type(pbf_wire_type::fixed64) && 
"not a 64-bit fixed");
 
  622        return get_fixed<uint64_t>();
 
 
  633        protozero_assert(
tag() != 0 && 
"call next() before accessing field value");
 
  634        protozero_assert(
has_wire_type(pbf_wire_type::fixed64) && 
"not a 64-bit fixed");
 
  635        return get_fixed<int64_t>();
 
 
  646        protozero_assert(
tag() != 0 && 
"call next() before accessing field value");
 
  647        protozero_assert(
has_wire_type(pbf_wire_type::fixed32) && 
"not a 32-bit fixed");
 
  648        return get_fixed<float>();
 
 
  659        protozero_assert(
tag() != 0 && 
"call next() before accessing field value");
 
  660        protozero_assert(
has_wire_type(pbf_wire_type::fixed64) && 
"not a 64-bit fixed");
 
  661        return get_fixed<double>();
 
 
  674        protozero_assert(
tag() != 0 && 
"call next() before accessing field value");
 
  675        protozero_assert(
has_wire_type(pbf_wire_type::length_delimited) && 
"not of type string, bytes or message");
 
  676        const auto len = get_len_and_skip();
 
  677        return {m_data - len, len};
 
 
  680#ifndef PROTOZERO_STRICT_API 
  689    std::pair<const char*, pbf_length_type> 
get_data() {
 
  690        protozero_assert(
tag() != 0 && 
"call next() before accessing field value");
 
  691        protozero_assert(
has_wire_type(pbf_wire_type::length_delimited) && 
"not of type string, bytes or message");
 
  692        const auto len = get_len_and_skip();
 
  693        return {m_data - len, len};
 
 
  789        return get_packed<pbf_reader::const_bool_iterator>();
 
 
  802        return get_packed<pbf_reader::const_enum_iterator>();
 
 
  815        return get_packed<pbf_reader::const_int32_iterator>();
 
 
  828        return get_packed<pbf_reader::const_sint32_iterator>();
 
 
  841        return get_packed<pbf_reader::const_uint32_iterator>();
 
 
  854        return get_packed<pbf_reader::const_int64_iterator>();
 
 
  867        return get_packed<pbf_reader::const_sint64_iterator>();
 
 
  880        return get_packed<pbf_reader::const_uint64_iterator>();
 
 
  893        return packed_fixed<uint32_t>();
 
 
  906        return packed_fixed<int32_t>();
 
 
  919        return packed_fixed<uint64_t>();
 
 
  932        return packed_fixed<int64_t>();
 
 
  945        return packed_fixed<float>();
 
 
  958        return packed_fixed<double>();
 
 
 
Contains functions to swap bytes in values (for different endianness).
Definition iterators.hpp:160
Definition iterators.hpp:374
Definition iterators.hpp:289
Definition data_view.hpp:39
constexpr std::size_t size() const noexcept
Return length of data in bytes.
Definition data_view.hpp:99
constexpr const char * data() const noexcept
Return pointer to data.
Definition data_view.hpp:94
Definition iterators.hpp:45
Definition pbf_reader.hpp:62
bool next(pbf_tag_type next_tag, pbf_wire_type type)
Definition pbf_reader.hpp:378
iterator_range< pbf_reader::const_double_iterator > get_packed_double()
Definition pbf_reader.hpp:957
void skip()
Definition pbf_reader.hpp:462
pbf_reader(const std::pair< const char *, std::size_t > &data) noexcept
Definition pbf_reader.hpp:186
const_varint_iterator< int64_t > const_int64_iterator
Forward iterator for iterating over int64 (varint) values.
Definition pbf_reader.hpp:748
iterator_range< pbf_reader::const_bool_iterator > get_packed_bool()
Definition pbf_reader.hpp:788
double get_double()
Definition pbf_reader.hpp:658
std::string get_string()
Definition pbf_reader.hpp:715
iterator_range< pbf_reader::const_sint32_iterator > get_packed_sint32()
Definition pbf_reader.hpp:827
const_varint_iterator< uint32_t > const_uint32_iterator
Forward iterator for iterating over uint32 (varint) values.
Definition pbf_reader.hpp:745
pbf_reader(const data_view &view) noexcept
Definition pbf_reader.hpp:154
uint32_t get_uint32()
Definition pbf_reader.hpp:545
iterator_range< pbf_reader::const_fixed64_iterator > get_packed_fixed64()
Definition pbf_reader.hpp:918
iterator_range< pbf_reader::const_int64_iterator > get_packed_int64()
Definition pbf_reader.hpp:853
int32_t get_sfixed32()
Definition pbf_reader.hpp:606
int32_t get_sint32()
Definition pbf_reader.hpp:533
std::size_t length() const noexcept
Definition pbf_reader.hpp:265
iterator_range< pbf_reader::const_float_iterator > get_packed_float()
Definition pbf_reader.hpp:944
iterator_range< pbf_reader::const_uint64_iterator > get_packed_uint64()
Definition pbf_reader.hpp:879
iterator_range< pbf_reader::const_sfixed32_iterator > get_packed_sfixed32()
Definition pbf_reader.hpp:905
uint64_t get_fixed64()
Definition pbf_reader.hpp:619
const_fixed_iterator< uint64_t > const_fixed64_iterator
Forward iterator for iterating over fixed64 values.
Definition pbf_reader.hpp:763
pbf_wire_type wire_type() const noexcept
Definition pbf_reader.hpp:416
const_fixed_iterator< int64_t > const_sfixed64_iterator
Forward iterator for iterating over sfixed64 values.
Definition pbf_reader.hpp:766
iterator_range< pbf_reader::const_sint64_iterator > get_packed_sint64()
Definition pbf_reader.hpp:866
iterator_range< pbf_reader::const_uint32_iterator > get_packed_uint32()
Definition pbf_reader.hpp:840
int64_t get_sfixed64()
Definition pbf_reader.hpp:632
pbf_reader(const std::string &data) noexcept
Definition pbf_reader.hpp:202
bool next(pbf_tag_type next_tag)
Definition pbf_reader.hpp:340
iterator_range< pbf_reader::const_int32_iterator > get_packed_int32()
Definition pbf_reader.hpp:814
const_varint_iterator< uint64_t > const_uint64_iterator
Forward iterator for iterating over uint64 (varint) values.
Definition pbf_reader.hpp:754
data_view get_view()
Definition pbf_reader.hpp:673
const_svarint_iterator< int64_t > const_sint64_iterator
Forward iterator for iterating over sint64 (varint) values.
Definition pbf_reader.hpp:751
uint32_t get_fixed32()
Definition pbf_reader.hpp:593
uint64_t get_uint64()
Definition pbf_reader.hpp:581
float get_float()
Definition pbf_reader.hpp:645
const_varint_iterator< int32_t > const_int32_iterator
Forward iterator for iterating over int32 (varint) values.
Definition pbf_reader.hpp:739
bool next()
Definition pbf_reader.hpp:284
int32_t get_enum()
Definition pbf_reader.hpp:509
const_fixed_iterator< int32_t > const_sfixed32_iterator
Forward iterator for iterating over sfixed32 values.
Definition pbf_reader.hpp:760
const_fixed_iterator< double > const_double_iterator
Forward iterator for iterating over double values.
Definition pbf_reader.hpp:772
uint32_t tag_and_type() const noexcept
Definition pbf_reader.hpp:442
pbf_reader get_message()
Definition pbf_reader.hpp:726
iterator_range< pbf_reader::const_enum_iterator > get_packed_enum()
Definition pbf_reader.hpp:801
int64_t get_int64()
Definition pbf_reader.hpp:557
iterator_range< pbf_reader::const_fixed32_iterator > get_packed_fixed32()
Definition pbf_reader.hpp:892
std::string get_bytes()
Definition pbf_reader.hpp:704
iterator_range< pbf_reader::const_sfixed64_iterator > get_packed_sfixed64()
Definition pbf_reader.hpp:931
pbf_tag_type tag() const noexcept
Definition pbf_reader.hpp:397
bool get_bool()
Definition pbf_reader.hpp:494
const_varint_iterator< int32_t > const_enum_iterator
Forward iterator for iterating over enum (int32 varint) values.
Definition pbf_reader.hpp:736
int64_t get_sint64()
Definition pbf_reader.hpp:569
const_varint_iterator< int32_t > const_bool_iterator
Forward iterator for iterating over bool (int32 varint) values.
Definition pbf_reader.hpp:733
pbf_reader() noexcept=default
const_fixed_iterator< float > const_float_iterator
Forward iterator for iterating over float values.
Definition pbf_reader.hpp:769
void swap(pbf_reader &other) noexcept
Definition pbf_reader.hpp:232
int32_t get_int32()
Definition pbf_reader.hpp:521
data_view data() const noexcept
Definition pbf_reader.hpp:252
bool has_wire_type(pbf_wire_type type) const noexcept
Definition pbf_reader.hpp:452
pbf_reader(const char *data, std::size_t size) noexcept
Definition pbf_reader.hpp:169
std::pair< const char *, pbf_length_type > get_data()
Definition pbf_reader.hpp:689
const_fixed_iterator< uint32_t > const_fixed32_iterator
Forward iterator for iterating over fixed32 values.
Definition pbf_reader.hpp:757
const_svarint_iterator< int32_t > const_sint32_iterator
Forward iterator for iterating over sint32 (varint) values.
Definition pbf_reader.hpp:742
Contains macro checks for different configurations.
Contains the implementation of the data_view class.
Contains the exceptions used in the protozero library.
Contains the iterators for access to packed repeated fields.
All parts of the protozero header-only library are in this namespace.
Definition basic_pbf_builder.hpp:24
void swap(basic_pbf_writer< TBuffer > &lhs, basic_pbf_writer< TBuffer > &rhs) noexcept
Definition basic_pbf_writer.hpp:936
pbf_wire_type
Definition types.hpp:40
uint32_t pbf_length_type
Definition types.hpp:62
constexpr int64_t decode_zigzag64(uint64_t value) noexcept
Definition varint.hpp:238
void skip_varint(const char **data, const char *end)
Definition varint.hpp:113
uint32_t pbf_tag_type
Definition types.hpp:33
uint64_t decode_varint(const char **data, const char *end)
Definition varint.hpp:90
void byteswap_inplace(uint32_t *ptr) noexcept
byteswap the data pointed to by ptr in-place.
Definition byteswap.hpp:56
constexpr uint32_t tag_and_type(T tag, pbf_wire_type wire_type) noexcept
Definition types.hpp:55
Definition exception.hpp:67
Definition exception.hpp:92
Definition exception.hpp:80
Definition exception.hpp:52
Contains the declaration of low-level types used in the pbf format.
Contains low-level varint and zigzag encoding and decoding functions.