accessor.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/accessor-fwd.hpp>
 
//
 
#include <type_traits>
 
#include <bsoncxx/builder/basic/sub_binary-fwd.hpp>
 
#include <bsoncxx/exception/error_code.hpp>
#include <bsoncxx/exception/exception.hpp>
#include <bsoncxx/vector/detail.hpp>
#include <bsoncxx/vector/formats.hpp>
 
#include <bsoncxx/config/prelude.hpp>
 
namespace bsoncxx {
namespace v_noabi {
namespace vector {

template <typename Format>
class accessor {
    using format_traits = typename detail::format_traits<typename std::remove_cv<Format>::type>;
 
   public:
    using format = Format;

    using const_value_type = typename format_traits::value_type const;

    using value_type = typename std::conditional<
        std::is_const<Format>::value,
        typename format_traits::value_type const,
        typename format_traits::value_type>::type;

    using const_reference = typename format_traits::const_reference;

    using reference = typename std::conditional<
        std::is_const<Format>::value,
        typename format_traits::const_reference,
        typename format_traits::reference>::type;

    using const_iterator = typename format_traits::const_iterator;

    using iterator = typename std::conditional<
        std::is_const<Format>::value,
        typename format_traits::const_iterator,
        typename format_traits::iterator>::type;

    using byte_type = typename detail::accessor_data<format>::byte_type;

    using byte_count_type = typename detail::accessor_data<format>::byte_count_type;

    using element_count_type = typename format_traits::element_count_type;

    using byte_difference_type = typename format_traits::byte_difference_type;

    using element_difference_type = typename format_traits::element_difference_type;

    using const_byte_reference = typename format_traits::const_byte_reference;

    using byte_reference = typename std::conditional<
        std::is_const<Format>::value,
        typename format_traits::const_byte_reference,
        typename format_traits::byte_reference>::type;

    using const_byte_iterator = typename format_traits::const_byte_iterator;

    using byte_iterator = typename std::conditional<
        std::is_const<Format>::value,
        typename format_traits::const_byte_iterator,
        typename format_traits::byte_iterator>::type;

    accessor(types::b_binary const& binary) : _data{(format::validate(binary), binary)} {}

    constexpr accessor<format const> as_const() const noexcept {
        // Erase the template parameter from accessor_data to allow conversion from possibly-not-const to const.
        return {{_data.bytes, _data.size, _data.header_copy}};
    }
    constexpr accessor<format const> as_const() const noexcept {…}

    constexpr byte_count_type byte_size() const noexcept {
        return _data.size - byte_count_type(detail::header_size);
    }
    constexpr byte_count_type byte_size() const noexcept {…}

    constexpr element_count_type size() const noexcept {
        return format_traits::element_count(_data.size, _data.header_copy);
    }
    constexpr element_count_type size() const noexcept {…}

    constexpr iterator begin() const noexcept {
        return iterator(_data.bytes + detail::header_size);
    }
    constexpr iterator begin() const noexcept {…}

    constexpr iterator end() const noexcept {
        return begin() + element_difference_type(size());
    }
    constexpr iterator end() const noexcept {…}

    constexpr const_iterator cbegin() const noexcept {
        return const_iterator(_data.bytes + detail::header_size);
    }
    constexpr const_iterator cbegin() const noexcept {…}

    constexpr const_iterator cend() const noexcept {
        return cbegin() + element_difference_type(size());
    }
    constexpr const_iterator cend() const noexcept {…}

    reference front() noexcept {
        return *begin();
    }
    reference front() noexcept {…}

    constexpr const_reference front() const noexcept {
        return *begin();
    }
    constexpr const_reference front() const noexcept {…}

    reference back() noexcept {
        return *(begin() + element_difference_type(size() - 1u));
    }
    reference back() noexcept {…}

    constexpr const_reference back() const noexcept {
        return *(begin() + element_difference_type(size() - 1u));
    }
    constexpr const_reference back() const noexcept {…}

    constexpr byte_iterator byte_begin() const noexcept {
        return format_traits::make_byte_iterator(begin(), end());
    }
    constexpr byte_iterator byte_begin() const noexcept {…}

    constexpr byte_iterator byte_end() const noexcept {
        return byte_begin() + byte_difference_type(byte_size());
    }
    constexpr byte_iterator byte_end() const noexcept {…}

    constexpr const_byte_iterator byte_cbegin() const noexcept {
        return format_traits::make_byte_iterator(cbegin(), cend());
    }
    constexpr const_byte_iterator byte_cbegin() const noexcept {…}

    constexpr const_byte_iterator byte_cend() const noexcept {
        return byte_cbegin() + byte_difference_type(byte_size());
    }
    constexpr const_byte_iterator byte_cend() const noexcept {…}

    byte_reference byte_front() noexcept {
        return *byte_begin();
    }
    byte_reference byte_front() noexcept {…}

    constexpr const_byte_reference byte_front() const noexcept {
        return *byte_begin();
    }
    constexpr const_byte_reference byte_front() const noexcept {…}

    byte_reference byte_back() noexcept {
        return *(byte_begin() + byte_difference_type(byte_size() - 1u));
    }
    byte_reference byte_back() noexcept {…}

    constexpr const_byte_reference byte_back() const noexcept {
        return *(byte_begin() + byte_difference_type(byte_size() - 1u));
    }
    constexpr const_byte_reference byte_back() const noexcept {…}

    byte_reference byte_at(byte_count_type index) {
        if (index >= byte_size()) {
            throw bsoncxx::v_noabi::exception{error_code::k_vector_out_of_range};
        }
        return *(byte_begin() + byte_difference_type(index));
    }
    byte_reference byte_at(byte_count_type index) {…}

    const_byte_reference byte_at(byte_count_type index) const {
        if (index >= byte_size()) {
            throw bsoncxx::v_noabi::exception{error_code::k_vector_out_of_range};
        }
        return *(byte_begin() + byte_difference_type(index));
    }
    const_byte_reference byte_at(byte_count_type index) const  {…}

    reference at(element_count_type index) {
        if (index >= size()) {
            throw bsoncxx::v_noabi::exception{error_code::k_vector_out_of_range};
        }
        return *(begin() + element_difference_type(index));
    }
    reference at(element_count_type index) {…}

    const_reference at(element_count_type index) const {
        if (index >= size()) {
            throw bsoncxx::v_noabi::exception{error_code::k_vector_out_of_range};
        }
        return *(begin() + element_difference_type(index));
    }
    const_reference at(element_count_type index) const  {…}

    reference operator[](element_count_type index) noexcept {
        return *(begin() + element_difference_type(index));
    }
    reference operator[](element_count_type index) noexcept {…}

    constexpr const_reference operator[](element_count_type index) const noexcept {
        return *(begin() + element_difference_type(index));
    }
    constexpr const_reference operator[](element_count_type index) const noexcept {…}

    constexpr bool empty() const noexcept {
        return size() == 0u;
    }
    constexpr bool empty() const noexcept {…}
 
   private:
    friend class bsoncxx::v_noabi::builder::basic::sub_binary;
    friend class accessor<typename std::remove_const<format>::type>;
 
    accessor(detail::accessor_data<format> data) noexcept : _data{data} {}
 
    detail::accessor_data<format> _data;
};
class accessor {…};
 
} // namespace vector
} // namespace v_noabi
} // namespace bsoncxx
 
#include <bsoncxx/config/postlude.hpp>