view.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/v1/document/view-fwd.hpp> // IWYU pragma: export
 
//
 
#include <bsoncxx/v1/detail/prelude.hpp>
 
#include <bsoncxx/v1/config/export.hpp>
#include <bsoncxx/v1/detail/bit.hpp>
#include <bsoncxx/v1/element/view.hpp> // IWYU pragma: export
#include <bsoncxx/v1/stdx/string_view.hpp>
 
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <iterator>
#include <system_error>
#include <type_traits>
 
namespace bsoncxx {
namespace v1 {
namespace document {

class view {
   public:
    class const_iterator;

    using iterator = const_iterator;
 
   private:
    enum : std::size_t { _empty_length = 5u };
 
    std::uint8_t const* _data;
 
    template <detail::endian e = detail::endian::native>
    std::int32_t raw_size() const;
 
   public:
    BSONCXX_ABI_EXPORT_CDECL() view();

    explicit view(std::uint8_t const* data) : _data{data} {}

    BSONCXX_ABI_EXPORT view(std::uint8_t const* data, std::size_t length);

    std::uint8_t const* data() const {
        return _data;
    }

    std::size_t size() const;

    std::size_t length() const {
        return this->size();
    }

    bool empty() const {
        return this->size() == _empty_length && _data[4] == 0u;
    }

    explicit operator bool() const {
        return this->size() >= _empty_length;
    }

    BSONCXX_ABI_EXPORT_CDECL(const_iterator) cbegin() const;

    const_iterator cend() const;

    const_iterator begin() const;

    const_iterator end() const;

    BSONCXX_ABI_EXPORT_CDECL(const_iterator) find(v1::stdx::string_view key) const;

    v1::element::view operator[](v1::stdx::string_view key) const;

    friend bool operator==(view lhs, view rhs) {
        if (!lhs != !rhs) {
            return false;
        }
 
        return !lhs || (lhs.length() == rhs.length() && std::memcmp(lhs.data(), rhs.data(), lhs.length()) == 0);
    }
 
    friend bool operator!=(view lhs, view rhs) {
        return !(lhs == rhs);
    }


    enum class errc {
        zero,           
        invalid_length, 
        invalid_data,   
    };

    static BSONCXX_ABI_EXPORT_CDECL(std::error_category const&) error_category();

    friend std::error_code make_error_code(errc v) {
        return {static_cast<int>(v), error_category()};
    }
};
 
template <>
inline std::int32_t view::raw_size<detail::endian::little>() const {
    std::int32_t res;
    std::memcpy(&res, _data, sizeof(res));
    return res;
}
 
template <>
inline std::int32_t view::raw_size<detail::endian::big>() const {
    std::int32_t res;
    auto const bytes = reinterpret_cast<unsigned char*>(&res);
    bytes[0] = _data[3];
    bytes[1] = _data[2];
    bytes[2] = _data[1];
    bytes[3] = _data[0];
    return res;
}
 
inline std::size_t view::size() const {
    return _data ? static_cast<std::uint32_t>(this->raw_size()) : 0u;
}

class view::const_iterator {
   private:
    v1::element::view _element;
 
   public:
    using iterator_category = std::input_iterator_tag;

    using value_type = v1::element::view;

    using difference_type = std::ptrdiff_t;

    using pointer = value_type const*;

    using reference = value_type;

    const_iterator() = default;

    reference operator*() const {
        return _element;
    }

    pointer operator->() const {
        return &_element;
    }

    BSONCXX_ABI_EXPORT_CDECL(const_iterator&) operator++();

    const_iterator operator++(int) {
        const_iterator tmp = *this;
        this->operator++();
        return tmp;
    }

    friend bool operator==(const_iterator const& lhs, const_iterator const& rhs) {
        if (!lhs._element != !rhs._element) {
            return false;
        }
 
        return !lhs._element ||
               (lhs._element.raw() == rhs._element.raw() && lhs._element.offset() == rhs._element.offset());
    }

    friend bool operator!=(const_iterator const& lhs, const_iterator const& rhs) {
        return !(lhs == rhs);
    }
 
    class internal;
 
   private:
    explicit BSONCXX_ABI_EXPORT_CDECL() const_iterator(v1::element::view element);
};
 
inline view::const_iterator view::cend() const {
    return {};
}
 
inline view::const_iterator view::begin() const {
    return this->cbegin();
}
 
inline view::const_iterator view::end() const {
    return this->cend();
}
 
inline v1::element::view view::operator[](v1::stdx::string_view key) const {
    return *(this->find(key));
}
 
} // namespace document
} // namespace v1
} // namespace bsoncxx
 
template <>
struct std::is_error_code_enum<bsoncxx::v1::document::view::errc> : true_type {};
 
#include <bsoncxx/v1/detail/postlude.hpp>