1#ifndef PROTOZERO_ITERATORS_HPP 
    2#define PROTOZERO_ITERATORS_HPP 
   22#if PROTOZERO_BYTE_ORDER != PROTOZERO_LITTLE_ENDIAN 
   38template <
typename T, 
typename P = std::pair<T, T>>
 
   40#ifdef PROTOZERO_STRICT_API 
   53    using value_type = 
typename std::iterator_traits<T>::value_type;
 
   69        P{std::forward<
iterator>(first_iterator),
 
   70          std::forward<
iterator>(last_iterator)} {
 
 
   98    constexpr bool empty() const noexcept {
 
 
  107    std::size_t 
size() const noexcept {
 
  108        return static_cast<size_t>(std::distance(
begin(), 
end()));
 
 
  117        protozero_assert(!
empty());
 
  118        return *(this->first);
 
 
  127        protozero_assert(!
empty());
 
 
  138        swap(this->first, other.first);
 
  139        swap(this->second, other.second);
 
 
 
  163    const char* m_data = 
nullptr;
 
  169    using iterator_category = std::random_access_iterator_tag;
 
  170    using value_type        = T;
 
  171    using difference_type   = std::ptrdiff_t;
 
  172    using pointer           = value_type*;
 
  173    using reference         = value_type&;
 
  189    value_type operator*() 
const noexcept {
 
  191        std::memcpy(&result, m_data, 
sizeof(value_type));
 
  192#if PROTOZERO_BYTE_ORDER != PROTOZERO_LITTLE_ENDIAN 
  199        m_data += 
sizeof(value_type);
 
  210        m_data -= 
sizeof(value_type);
 
  221        return lhs.m_data == rhs.m_data;
 
  225        return !(lhs == rhs);
 
  229        return lhs.m_data < rhs.m_data;
 
  245        m_data += (
sizeof(value_type) * val);
 
  251        tmp.m_data += (
sizeof(value_type) * rhs);
 
  257        tmp.m_data += (
sizeof(value_type) * lhs);
 
  262        m_data -= (
sizeof(value_type) * val);
 
  268        tmp.m_data -= (
sizeof(value_type) * rhs);
 
  273        return static_cast<difference_type
>(lhs.m_data - rhs.m_data) / 
static_cast<difference_type
>(
sizeof(T));
 
  276    value_type operator[](difference_type n) 
const noexcept {
 
 
  303    using iterator_category = std::forward_iterator_tag;
 
  304    using value_type        = T;
 
  305    using difference_type   = std::ptrdiff_t;
 
  306    using pointer           = value_type*;
 
  307    using reference         = value_type&;
 
  318        return std::count_if(begin.m_data, end.m_data, [](
char c) 
noexcept {
 
  319            return (static_cast<unsigned char>(c) & 0x80U) == 0;
 
  330    const_varint_iterator(
const const_varint_iterator&) 
noexcept = 
default;
 
  331    const_varint_iterator(const_varint_iterator&&) noexcept = default;
 
  333    const_varint_iterator& operator=(const const_varint_iterator&) noexcept = default;
 
  334    const_varint_iterator& operator=(const_varint_iterator&&) noexcept = default;
 
  336    ~const_varint_iterator() noexcept = default;
 
  338    value_type operator*()
 const {
 
  344    const_varint_iterator& operator++() {
 
  350    const_varint_iterator operator++(
int) {
 
  352        const const_varint_iterator tmp{*
this};
 
  357    bool operator==(
const const_varint_iterator& rhs) 
const noexcept {
 
  361    bool operator!=(
const const_varint_iterator& rhs) 
const noexcept {
 
  362        return !(*
this == rhs);
 
 
  380    using iterator_category = std::forward_iterator_tag;
 
  381    using value_type        = T;
 
  382    using difference_type   = std::ptrdiff_t;
 
  383    using pointer           = value_type*;
 
  384    using reference         = value_type&;
 
  402    value_type operator*()
 const {
 
  403        protozero_assert(this->
m_data);
 
  404        const char* d = this->
m_data; 
 
  409        protozero_assert(this->
m_data);
 
  415        protozero_assert(this->
m_data);
 
 
  443    inline typename protozero::const_varint_iterator<int64_t>::difference_type
 
  444    distance<protozero::const_varint_iterator<int64_t>>(protozero::const_varint_iterator<int64_t> first, 
 
  445                                                        protozero::const_varint_iterator<int64_t> last) {
 
  446        return protozero::const_varint_iterator<int64_t>::distance(first, last);
 
  450    inline typename protozero::const_varint_iterator<uint32_t>::difference_type
 
  451    distance<protozero::const_varint_iterator<uint32_t>>(protozero::const_varint_iterator<uint32_t> first, 
 
  452                                                         protozero::const_varint_iterator<uint32_t> last) {
 
  453        return protozero::const_varint_iterator<uint32_t>::distance(first, last);
 
  457    inline typename protozero::const_varint_iterator<uint64_t>::difference_type
 
  458    distance<protozero::const_varint_iterator<uint64_t>>(protozero::const_varint_iterator<uint64_t> first, 
 
  459                                                         protozero::const_varint_iterator<uint64_t> last) {
 
  460        return protozero::const_varint_iterator<uint64_t>::distance(first, last);
 
  464    inline typename protozero::const_svarint_iterator<int32_t>::difference_type
 
  465    distance<protozero::const_svarint_iterator<int32_t>>(protozero::const_svarint_iterator<int32_t> first, 
 
  466                                                         protozero::const_svarint_iterator<int32_t> last) {
 
  467        return protozero::const_svarint_iterator<int32_t>::distance(first, last);
 
  471    inline typename protozero::const_svarint_iterator<int64_t>::difference_type
 
  472    distance<protozero::const_svarint_iterator<int64_t>>(protozero::const_svarint_iterator<int64_t> first, 
 
  473                                                         protozero::const_svarint_iterator<int64_t> last) {
 
  474        return protozero::const_svarint_iterator<int64_t>::distance(first, last);
 
Contains functions to swap bytes in values (for different endianness).
Definition iterators.hpp:160
Definition iterators.hpp:374
Definition iterators.hpp:289
const char * m_end
Definition iterators.hpp:297
const char * m_data
Definition iterators.hpp:294
Definition iterators.hpp:45
constexpr iterator cend() const noexcept
Return iterator to end of range.
Definition iterators.hpp:89
typename std::iterator_traits< T >::value_type value_type
The value type of the underlying iterator.
Definition iterators.hpp:53
constexpr iterator_range()
Definition iterators.hpp:58
constexpr iterator cbegin() const noexcept
Return iterator to beginning of range.
Definition iterators.hpp:84
constexpr bool empty() const noexcept
Definition iterators.hpp:98
value_type front() const
Definition iterators.hpp:116
std::size_t size() const noexcept
Definition iterators.hpp:107
constexpr iterator_range(iterator &&first_iterator, iterator &&last_iterator)
Definition iterators.hpp:68
constexpr iterator begin() const noexcept
Return iterator to beginning of range.
Definition iterators.hpp:74
constexpr iterator end() const noexcept
Return iterator to end of range.
Definition iterators.hpp:79
void drop_front()
Definition iterators.hpp:126
void swap(iterator_range &other) noexcept
Definition iterators.hpp:136
T iterator
The type of the iterators in this range.
Definition iterators.hpp:50
Contains macro checks for different configurations.
All parts of the protozero header-only library are in this namespace.
Definition basic_pbf_builder.hpp:24
bool operator<(const data_view lhs, const data_view rhs) noexcept
Definition data_view.hpp:198
void swap(basic_pbf_writer< TBuffer > &lhs, basic_pbf_writer< TBuffer > &rhs) noexcept
Definition basic_pbf_writer.hpp:936
constexpr bool operator!=(const data_view lhs, const data_view rhs) noexcept
Definition data_view.hpp:188
constexpr int64_t decode_zigzag64(uint64_t value) noexcept
Definition varint.hpp:238
constexpr bool operator==(const data_view lhs, const data_view rhs) noexcept
Definition data_view.hpp:176
void skip_varint(const char **data, const char *end)
Definition varint.hpp:113
bool operator>=(const data_view lhs, const data_view rhs) noexcept
Definition data_view.hpp:228
uint64_t decode_varint(const char **data, const char *end)
Definition varint.hpp:90
bool operator<=(const data_view lhs, const data_view rhs) noexcept
Definition data_view.hpp:208
void byteswap_inplace(uint32_t *ptr) noexcept
byteswap the data pointed to by ptr in-place.
Definition byteswap.hpp:56
bool operator>(const data_view lhs, const data_view rhs) noexcept
Definition data_view.hpp:218
Contains low-level varint and zigzag encoding and decoding functions.