pbf_reader.hpp

Go to the documentation of this file.

#ifndef PROTOZERO_PBF_READER_HPP
#define PROTOZERO_PBF_READER_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 <cstddef>
#include <cstdint>
#include <cstring>
#include <string>
#include <utility>

#include <protozero/config.hpp>
#include <protozero/exception.hpp>
#include <protozero/iterators.hpp>
#include <protozero/types.hpp>
#include <protozero/varint.hpp>

#if PROTOZERO_BYTE_ORDER != PROTOZERO_LITTLE_ENDIAN
# include <protozero/byteswap.hpp>
#endif

namespace protozero {

class pbf_reader {

    // A pointer to the next unread data.
    const char* m_data = nullptr;

    // A pointer to one past the end of data.
    const char* m_end = nullptr;

    // The wire type of the current field.
    pbf_wire_type m_wire_type = pbf_wire_type::unknown;

    // The tag of the current field.
    pbf_tag_type m_tag = 0;

    template <typename T>
    T get_fixed() {
        T result;
        skip_bytes(sizeof(T));
        std::memcpy(&result, m_data - sizeof(T), sizeof(T));
#if PROTOZERO_BYTE_ORDER != PROTOZERO_LITTLE_ENDIAN
        detail::byteswap_inplace(&result);
#endif
        return result;
    }

    template <typename T>
    iterator_range<const_fixed_iterator<T>> packed_fixed() {
        protozero_assert(tag() != 0 && "call next() before accessing field value");
        const auto len = get_len_and_skip();
        protozero_assert(len % sizeof(T) == 0);
        return {const_fixed_iterator<T>(m_data - len, m_data),
                const_fixed_iterator<T>(m_data, m_data)};
    }

    template <typename T>
    T get_varint() {
        return static_cast<T>(decode_varint(&m_data, m_end));
    }

    template <typename T>
    T get_svarint() {
        protozero_assert((has_wire_type(pbf_wire_type::varint) || has_wire_type(pbf_wire_type::length_delimited)) && "not a varint");
        return static_cast<T>(decode_zigzag64(decode_varint(&m_data, m_end)));
    }

    pbf_length_type get_length() {
        return get_varint<pbf_length_type>();
    }

    void skip_bytes(pbf_length_type len) {
        if (m_data + len > m_end) {
            throw end_of_buffer_exception{};
        }
        m_data += len;

    // In debug builds reset the tag to zero so that we can detect (some)
    // wrong code.
#ifndef NDEBUG
        m_tag = 0;
#endif
    }

    pbf_length_type get_len_and_skip() {
        const auto len = get_length();
        skip_bytes(len);
        return len;
    }

    template <typename T>
    iterator_range<T> get_packed() {
        protozero_assert(tag() != 0 && "call next() before accessing field value");
        const auto len = get_len_and_skip();
        return {T{m_data - len, m_data},
                T{m_data, m_data}};
    }

public:

    explicit pbf_reader(const data_view& view) noexcept
        : m_data(view.data()),
          m_end(view.data() + view.size()) {
    }

    pbf_reader(const char* data, std::size_t size) noexcept
        : m_data(data),
          m_end(data + size) {
    }

    explicit pbf_reader(const std::pair<const char*, std::size_t>& data) noexcept
        : m_data(data.first),
          m_end(data.first + data.second) {
    }

    explicit pbf_reader(const std::string& data) noexcept
        : m_data(data.data()),
          m_end(data.data() + data.size()) {
    }

    pbf_reader() noexcept = default;

    pbf_reader(const pbf_reader&) noexcept = default;

    pbf_reader(pbf_reader&&) noexcept = default;

    pbf_reader& operator=(const pbf_reader& other) noexcept = default;

    pbf_reader& operator=(pbf_reader&& other) noexcept = default;

    ~pbf_reader() = default;

    void swap(pbf_reader& other) noexcept {
        using std::swap;
        swap(m_data, other.m_data);
        swap(m_end, other.m_end);
        swap(m_wire_type, other.m_wire_type);
        swap(m_tag, other.m_tag);
    }

    operator bool() const noexcept { // NOLINT clang-tidy: google-explicit-constructor
        return m_data < m_end;
    }

    std::size_t length() const noexcept {
        return std::size_t(m_end - m_data);
    }

    bool next() {
        if (m_data == m_end) {
            return false;
        }

        const auto value = get_varint<uint32_t>();
        m_tag = pbf_tag_type(value >> 3);

        // tags 0 and 19000 to 19999 are not allowed as per
        // https://developers.google.com/protocol-buffers/docs/proto
        protozero_assert(((m_tag >     0 && m_tag < 19000) ||
                          (m_tag > 19999 && m_tag <= ((1 << 29) - 1))) && "tag out of range");

        m_wire_type = pbf_wire_type(value & 0x07);
        switch (m_wire_type) {
            case pbf_wire_type::varint:
            case pbf_wire_type::fixed64:
            case pbf_wire_type::length_delimited:
            case pbf_wire_type::fixed32:
                break;
            default:
                throw unknown_pbf_wire_type_exception{};
        }

        return true;
    }

    bool next(pbf_tag_type next_tag) {
        while (next()) {
            if (m_tag == next_tag) {
                return true;
            }
            skip();
        }
        return false;
    }

    bool next(pbf_tag_type next_tag, pbf_wire_type type) {
        while (next()) {
            if (m_tag == next_tag && m_wire_type == type) {
                return true;
            }
            skip();
        }
        return false;
    }

    pbf_tag_type tag() const noexcept {
        return m_tag;
    }

    pbf_wire_type wire_type() const noexcept {
        return m_wire_type;
    }

    uint32_t tag_and_type() const noexcept {
        return protozero::tag_and_type(tag(), wire_type());
    }

    bool has_wire_type(pbf_wire_type type) const noexcept {
        return wire_type() == type;
    }

    void skip() {
        protozero_assert(tag() != 0 && "call next() before calling skip()");
        switch (wire_type()) {
            case pbf_wire_type::varint:
                skip_varint(&m_data, m_end);
                break;
            case pbf_wire_type::fixed64:
                skip_bytes(8);
                break;
            case pbf_wire_type::length_delimited:
                skip_bytes(get_length());
                break;
            case pbf_wire_type::fixed32:
                skip_bytes(4);
                break;
            default:
                protozero_assert(false && "can not be here because next() should have thrown already");
        }
    }


    bool get_bool() {
        protozero_assert(tag() != 0 && "call next() before accessing field value");
        protozero_assert(has_wire_type(pbf_wire_type::varint) && "not a varint");
        protozero_assert((*m_data & 0x80) == 0 && "not a 1 byte varint");
        skip_bytes(1);
        return m_data[-1] != 0; // -1 okay because we incremented m_data the line before
    }

    int32_t get_enum() {
        protozero_assert(has_wire_type(pbf_wire_type::varint) && "not a varint");
        return get_varint<int32_t>();
    }

    int32_t get_int32() {
        protozero_assert(has_wire_type(pbf_wire_type::varint) && "not a varint");
        return get_varint<int32_t>();
    }

    int32_t get_sint32() {
        protozero_assert(has_wire_type(pbf_wire_type::varint) && "not a varint");
        return get_svarint<int32_t>();
    }

    uint32_t get_uint32() {
        protozero_assert(has_wire_type(pbf_wire_type::varint) && "not a varint");
        return get_varint<uint32_t>();
    }

    int64_t get_int64() {
        protozero_assert(has_wire_type(pbf_wire_type::varint) && "not a varint");
        return get_varint<int64_t>();
    }

    int64_t get_sint64() {
        protozero_assert(has_wire_type(pbf_wire_type::varint) && "not a varint");
        return get_svarint<int64_t>();
    }

    uint64_t get_uint64() {
        protozero_assert(has_wire_type(pbf_wire_type::varint) && "not a varint");
        return get_varint<uint64_t>();
    }

    uint32_t get_fixed32() {
        protozero_assert(tag() != 0 && "call next() before accessing field value");
        protozero_assert(has_wire_type(pbf_wire_type::fixed32) && "not a 32-bit fixed");
        return get_fixed<uint32_t>();
    }

    int32_t get_sfixed32() {
        protozero_assert(tag() != 0 && "call next() before accessing field value");
        protozero_assert(has_wire_type(pbf_wire_type::fixed32) && "not a 32-bit fixed");
        return get_fixed<int32_t>();
    }

    uint64_t get_fixed64() {
        protozero_assert(tag() != 0 && "call next() before accessing field value");
        protozero_assert(has_wire_type(pbf_wire_type::fixed64) && "not a 64-bit fixed");
        return get_fixed<uint64_t>();
    }

    int64_t get_sfixed64() {
        protozero_assert(tag() != 0 && "call next() before accessing field value");
        protozero_assert(has_wire_type(pbf_wire_type::fixed64) && "not a 64-bit fixed");
        return get_fixed<int64_t>();
    }

    float get_float() {
        protozero_assert(tag() != 0 && "call next() before accessing field value");
        protozero_assert(has_wire_type(pbf_wire_type::fixed32) && "not a 32-bit fixed");
        return get_fixed<float>();
    }

    double get_double() {
        protozero_assert(tag() != 0 && "call next() before accessing field value");
        protozero_assert(has_wire_type(pbf_wire_type::fixed64) && "not a 64-bit fixed");
        return get_fixed<double>();
    }

    data_view get_view() {
        protozero_assert(tag() != 0 && "call next() before accessing field value");
        protozero_assert(has_wire_type(pbf_wire_type::length_delimited) && "not of type string, bytes or message");
        const auto len = get_len_and_skip();
        return {m_data - len, len};
    }

#ifndef PROTOZERO_STRICT_API

    std::pair<const char*, pbf_length_type> get_data() {
        protozero_assert(tag() != 0 && "call next() before accessing field value");
        protozero_assert(has_wire_type(pbf_wire_type::length_delimited) && "not of type string, bytes or message");
        const auto len = get_len_and_skip();
        return {m_data - len, len};
    }
#endif

    std::string get_bytes() {
        return std::string(get_view());
    }

    std::string get_string() {
        return std::string(get_view());
    }

    pbf_reader get_message() {
        return pbf_reader{get_view()};
    }


    using const_bool_iterator   = const_varint_iterator< int32_t>;

    using const_enum_iterator   = const_varint_iterator< int32_t>;

    using const_int32_iterator  = const_varint_iterator< int32_t>;

    using const_sint32_iterator = const_svarint_iterator<int32_t>;

    using const_uint32_iterator = const_varint_iterator<uint32_t>;

    using const_int64_iterator  = const_varint_iterator< int64_t>;

    using const_sint64_iterator = const_svarint_iterator<int64_t>;

    using const_uint64_iterator = const_varint_iterator<uint64_t>;


    iterator_range<pbf_reader::const_bool_iterator> get_packed_bool() {
        return get_packed<pbf_reader::const_bool_iterator>();
    }

    iterator_range<pbf_reader::const_enum_iterator> get_packed_enum() {
        return get_packed<pbf_reader::const_enum_iterator>();
    }

    iterator_range<pbf_reader::const_int32_iterator> get_packed_int32() {
        return get_packed<pbf_reader::const_int32_iterator>();
    }

    iterator_range<pbf_reader::const_sint32_iterator> get_packed_sint32() {
        return get_packed<pbf_reader::const_sint32_iterator>();
    }

    iterator_range<pbf_reader::const_uint32_iterator> get_packed_uint32() {
        return get_packed<pbf_reader::const_uint32_iterator>();
    }

    iterator_range<pbf_reader::const_int64_iterator> get_packed_int64() {
        return get_packed<pbf_reader::const_int64_iterator>();
    }

    iterator_range<pbf_reader::const_sint64_iterator> get_packed_sint64() {
        return get_packed<pbf_reader::const_sint64_iterator>();
    }

    iterator_range<pbf_reader::const_uint64_iterator> get_packed_uint64() {
        return get_packed<pbf_reader::const_uint64_iterator>();
    }

    auto get_packed_fixed32() -> decltype(packed_fixed<uint32_t>()) {
        return packed_fixed<uint32_t>();
    }

    auto get_packed_sfixed32() -> decltype(packed_fixed<int32_t>()) {
        return packed_fixed<int32_t>();
    }

    auto get_packed_fixed64() -> decltype(packed_fixed<uint64_t>()) {
        return packed_fixed<uint64_t>();
    }

    auto get_packed_sfixed64() -> decltype(packed_fixed<int64_t>()) {
        return packed_fixed<int64_t>();
    }

    auto get_packed_float() -> decltype(packed_fixed<float>()) {
        return packed_fixed<float>();
    }

    auto get_packed_double() -> decltype(packed_fixed<double>()) {
        return packed_fixed<double>();
    }


}; // class pbf_reader

inline void swap(pbf_reader& lhs, pbf_reader& rhs) noexcept {
    lhs.swap(rhs);
}

} // end namespace protozero

#endif // PROTOZERO_PBF_READER_HPP