iterators.hpp

Go to the documentation of this file.

// Copyright 2009-present MongoDB, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <bsoncxx/vector/iterators-fwd.hpp>
 
//
 
#include <cstdint>
#include <iterator>
 
#include <bsoncxx/vector/accessor-fwd.hpp>
#include <bsoncxx/vector/detail-fwd.hpp>
 
#include <bsoncxx/vector/elements.hpp>
#include <bsoncxx/vector/formats.hpp>
 
#include <bsoncxx/config/prelude.hpp>
 
namespace bsoncxx {
namespace v_noabi {
namespace vector {
namespace iterators {

template <typename Iterator>
class packed_bit_element {
   public:
    using value_type = bool;

    using reference = elements::packed_bit_element<Iterator> const;

    using pointer = elements::packed_bit_element<Iterator> const*;

    using iterator_category = std::random_access_iterator_tag;

    using difference_type = std::ptrdiff_t;

    constexpr reference operator*() const noexcept {
        return {byte, bit};
    }

    constexpr bool operator==(packed_bit_element const& other) const noexcept {
        return byte == other.byte && bit == other.bit;
    }

    constexpr bool operator!=(packed_bit_element const& other) const noexcept {
        return byte != other.byte || bit != other.bit;
    }

    constexpr bool operator<(packed_bit_element const& other) const noexcept {
        return byte < other.byte || (byte == other.byte && bit < other.bit);
    }

    constexpr bool operator<=(packed_bit_element const& other) const noexcept {
        return byte < other.byte || (byte == other.byte && bit <= other.bit);
    }

    constexpr bool operator>(packed_bit_element const& other) const noexcept {
        return byte > other.byte || (byte == other.byte && bit > other.bit);
    }

    constexpr bool operator>=(packed_bit_element const& other) const noexcept {
        return byte > other.byte || (byte == other.byte && bit >= other.bit);
    }

    constexpr packed_bit_element operator+(difference_type const& other) const noexcept {
        return {
            byte + ((difference_type{bit} + other - ((difference_type{bit} + other) & 7)) / 8),
            std::uint8_t((difference_type{bit} + other) & 7)};
    }

    constexpr packed_bit_element operator-(difference_type const& other) const noexcept {
        return *this + (-other);
    }

    constexpr difference_type operator-(packed_bit_element const& other) const noexcept {
        return {(byte - other.byte) * 8 + (difference_type{bit} - difference_type{other.bit})};
    }

    packed_bit_element& operator+=(difference_type const& other) noexcept {
        return *this = *this + other;
    }

    packed_bit_element& operator-=(difference_type const& other) noexcept {
        return *this = *this - other;
    }

    packed_bit_element& operator++() noexcept {
        return *this += difference_type{1};
    }

    packed_bit_element& operator--() noexcept {
        return *this -= difference_type{1};
    }

    packed_bit_element operator++(int) noexcept {
        packed_bit_element prev = *this;
        ++*this;
        return prev;
    }

    packed_bit_element operator--(int) noexcept {
        packed_bit_element prev = *this;
        --*this;
        return prev;
    }
 
   private:
    friend class packed_bit_byte<Iterator>;
    friend class accessor<formats::f_packed_bit>;
    friend class accessor<formats::f_packed_bit const>;
 
    constexpr packed_bit_element(Iterator byte_iter, std::uint8_t bit_index = 0) noexcept
        : byte{byte_iter}, bit{bit_index} {}
 
    Iterator byte;
    std::uint8_t bit;
};

template <typename Iterator>
class packed_bit_byte {
   public:
    using value_type = std::uint8_t;

    using reference = elements::packed_bit_byte<Iterator> const;

    using pointer = elements::packed_bit_byte<Iterator> const*;

    using iterator_category = std::random_access_iterator_tag;

    using difference_type = std::ptrdiff_t;

    constexpr reference operator*() const noexcept {
        return {byte, (byte + 1) == byte_end ? last_byte_mask : value_type{0xFFu}};
    }

    constexpr bool operator==(packed_bit_byte const& other) const noexcept {
        return byte == other.byte;
    }

    constexpr bool operator!=(packed_bit_byte const& other) const noexcept {
        return byte != other.byte;
    }

    constexpr bool operator<(packed_bit_byte const& other) const noexcept {
        return byte < other.byte;
    }

    constexpr bool operator<=(packed_bit_byte const& other) const noexcept {
        return byte <= other.byte;
    }

    constexpr bool operator>(packed_bit_byte const& other) const noexcept {
        return byte > other.byte;
    }

    constexpr bool operator>=(packed_bit_byte const& other) const noexcept {
        return byte >= other.byte;
    }

    constexpr packed_bit_byte operator+(difference_type const& other) const noexcept {
        return {byte + other, byte_end, last_byte_mask};
    }

    constexpr packed_bit_byte operator-(difference_type const& other) const noexcept {
        return *this + (-other);
    }

    constexpr difference_type operator-(packed_bit_byte const& other) const noexcept {
        return {byte - other.byte};
    }

    packed_bit_byte& operator+=(difference_type const& other) noexcept {
        return *this = *this + other;
    }

    packed_bit_byte& operator-=(difference_type const& other) noexcept {
        return *this = *this - other;
    }

    packed_bit_byte& operator++() noexcept {
        return *this += difference_type{1};
    }

    packed_bit_byte& operator--() noexcept {
        return *this -= difference_type{1};
    }

    packed_bit_byte operator++(int) noexcept {
        packed_bit_byte prev = *this;
        ++*this;
        return prev;
    }

    packed_bit_byte operator--(int) noexcept {
        packed_bit_byte prev = *this;
        --*this;
        return prev;
    }
 
   private:
    friend struct detail::format_traits<formats::f_packed_bit>;
    friend struct detail::format_traits<formats::f_packed_bit const>;
 
    constexpr packed_bit_byte(packed_bit_element<Iterator> element, packed_bit_element<Iterator> element_end)
        : byte{element.byte},
          byte_end{(element_end + 7u).byte},
          last_byte_mask{value_type(0xFFu << (-element_end.bit & 7u))} {}
 
    constexpr packed_bit_byte(Iterator byte, Iterator byte_end, value_type last_byte_mask)
        : byte{byte}, byte_end{byte_end}, last_byte_mask{last_byte_mask} {}
 
    Iterator byte;
    Iterator byte_end;
    value_type last_byte_mask;
};
 
} // namespace iterators
} // namespace vector
} // namespace v_noabi
} // namespace bsoncxx
 
#include <bsoncxx/config/postlude.hpp>