types.hpp

Go to the documentation of this file.

#ifndef PROTOZERO_TYPES_HPP
#define PROTOZERO_TYPES_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 <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <string>
#include <utility>

#include <protozero/config.hpp>

namespace protozero {

using pbf_tag_type = uint32_t;

enum class pbf_wire_type : uint32_t {
    varint           = 0, // int32/64, uint32/64, sint32/64, bool, enum
    fixed64          = 1, // fixed64, sfixed64, double
    length_delimited = 2, // string, bytes, embedded messages,
                            // packed repeated fields
    fixed32          = 5, // fixed32, sfixed32, float
    unknown          = 99 // used for default setting in this library
};

template <typename T>
constexpr inline uint32_t tag_and_type(T tag, pbf_wire_type wire_type) noexcept {
    return (static_cast<uint32_t>(static_cast<pbf_tag_type>(tag)) << 3) | static_cast<uint32_t>(wire_type);
}

using pbf_length_type = uint32_t;

#ifdef PROTOZERO_USE_VIEW
using data_view = PROTOZERO_USE_VIEW;
#else

class data_view {

    const char* m_data = nullptr;
    std::size_t m_size = 0;

public:

    constexpr data_view() noexcept = default;

    constexpr data_view(const char* ptr, std::size_t length) noexcept
        : m_data(ptr),
          m_size(length) {
    }

    data_view(const std::string& str) noexcept // NOLINT clang-tidy: google-explicit-constructor
        : m_data(str.data()),
          m_size(str.size()) {
    }

    data_view(const char* ptr) noexcept // NOLINT clang-tidy: google-explicit-constructor
        : m_data(ptr),
          m_size(std::strlen(ptr)) {
    }

    void swap(data_view& other) noexcept {
        using std::swap;
        swap(m_data, other.m_data);
        swap(m_size, other.m_size);
    }

    constexpr const char* data() const noexcept {
        return m_data;
    }

    constexpr std::size_t size() const noexcept {
        return m_size;
    }

    constexpr bool empty() const noexcept {
        return m_size == 0;
    }

    std::string to_string() const {
        protozero_assert(m_data);
        return {m_data, m_size};
    }

    explicit operator std::string() const {
        protozero_assert(m_data);
        return {m_data, m_size};
    }

}; // class data_view

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

inline bool operator==(const data_view& lhs, const data_view& rhs) noexcept {
    return lhs.size() == rhs.size() && std::equal(lhs.data(), lhs.data() + lhs.size(), rhs.data());
}

inline bool operator!=(const data_view& lhs, const data_view& rhs) noexcept {
    return !(lhs == rhs);
}

#endif


} // end namespace protozero

#endif // PROTOZERO_TYPES_HPP