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/types/view-fwd.hpp> // IWYU pragma: export
 
//
 
#include <bsoncxx/v1/detail/prelude.hpp>
 
#include <bsoncxx/v1/array/view.hpp> // IWYU pragma: export
#include <bsoncxx/v1/config/export.hpp>
#include <bsoncxx/v1/decimal128.hpp> // IWYU pragma: export
#include <bsoncxx/v1/detail/macros.hpp>
#include <bsoncxx/v1/detail/type_traits.hpp>
#include <bsoncxx/v1/document/view.hpp> // IWYU pragma: export
#include <bsoncxx/v1/oid.hpp>           // IWYU pragma: export
#include <bsoncxx/v1/stdx/string_view.hpp>
#include <bsoncxx/v1/types/id.hpp> // IWYU pragma: export
 
#include <chrono>
#include <cstdint>
#include <cstring>
#include <system_error>
#include <type_traits>
 
namespace bsoncxx {
namespace v1 {
namespace types {
 
// BSONCXX_V1_TYPES_XMACRO: update below.

struct b_double {
    static constexpr id type_id = id::k_double;

    double value = {};

    b_double() = default;

    explicit b_double(double value) : value{value} {}

    /* explicit(false) */ operator double() const {
        return value;
    }

    friend bool operator==(b_double const& lhs, b_double const& rhs) {
        BSONCXX_PRIVATE_WARNINGS_PUSH();
        BSONCXX_PRIVATE_WARNINGS_DISABLE(GNU("-Wfloat-equal"));
        return lhs.value == rhs.value;
        BSONCXX_PRIVATE_WARNINGS_POP();
    }

    friend bool operator!=(b_double const& lhs, b_double const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_string {
    static constexpr id type_id = id::k_string;

    v1::stdx::string_view value;

    b_string() = default;

    explicit b_string(v1::stdx::string_view value) : value{value} {}

    /* explicit(false) */ operator v1::stdx::string_view() const {
        return value;
    }

    friend bool operator==(b_string const& lhs, b_string const& rhs) {
        return lhs.value == rhs.value;
    }

    friend bool operator!=(b_string const& lhs, b_string const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_document {
    static constexpr id type_id = id::k_document;

    v1::document::view value;

    b_document() = default;

    explicit b_document(v1::document::view value) : value{value} {}

    /* explicit(false) */ operator v1::document::view() const {
        return value;
    }
 
    v1::document::view view() {
        return value;
    }

    friend bool operator==(b_document const& lhs, b_document const& rhs) {
        return lhs.value == rhs.value;
    }

    friend bool operator!=(b_document const& lhs, b_document const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_array {
    static constexpr id type_id = id::k_array;

    v1::array::view value;

    b_array() = default;

    explicit b_array(v1::array::view value) : value{value} {}

    /* explicit(false) */ operator v1::array::view() const {
        return value;
    }

    friend bool operator==(b_array const& lhs, b_array const& rhs) {
        return lhs.value == rhs.value;
    }

    friend bool operator!=(b_array const& lhs, b_array const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_binary {
    static constexpr id type_id = id::k_binary;

    binary_subtype subtype = {};

    std::uint32_t size = {};

    std::uint8_t const* bytes = {};

    b_binary() = default;

    b_binary(binary_subtype subtype, std::uint32_t size, std::uint8_t const* bytes)
        : subtype{subtype}, size{size}, bytes{bytes} {}

    friend bool operator==(b_binary const& lhs, b_binary const& rhs) {
        if (lhs.size != rhs.size) {
            return false;
        }
 
        if (!lhs.bytes != !rhs.bytes) {
            return false;
        }
 
        if (!lhs.bytes || lhs.size == 0u) {
            return true; // Empty.
        }
 
        return lhs.subtype == rhs.subtype && (std::memcmp(lhs.bytes, rhs.bytes, lhs.size) == 0);
    }
 
    friend bool operator!=(b_binary const& lhs, b_binary const& rhs) {
        return !(lhs == rhs);
    }

};

struct b_undefined {
    static constexpr id type_id = id::k_undefined;

    friend bool operator==(b_undefined const&, b_undefined const&) {
        return true;
    }

    friend bool operator!=(b_undefined const& lhs, b_undefined const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_oid {
    static constexpr id type_id = id::k_oid;

    v1::oid value;

    b_oid() = default;

    explicit b_oid(v1::oid const& value) : value{value} {}

    /* explicit(false) */ operator v1::oid() const {
        return value;
    }

    friend bool operator==(b_oid const& lhs, b_oid const& rhs) {
        return lhs.value == rhs.value;
    }

    friend bool operator!=(b_oid const& lhs, b_oid const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_bool {
    static constexpr id type_id = id::k_bool;

    bool value = false;

    b_bool() = default;

    explicit b_bool(bool value) : value{value} {}

    /* explicit(false) */ operator bool() const {
        return value;
    }

    friend bool operator==(b_bool const& lhs, b_bool const& rhs) {
        return lhs.value == rhs.value;
    }

    friend bool operator!=(b_bool const& lhs, b_bool const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_date {
    static constexpr id type_id = id::k_date;

    std::chrono::milliseconds value = {};

    b_date() = default;

    explicit b_date(std::chrono::milliseconds value) : value{value} {}

    explicit b_date(std::chrono::system_clock::time_point tp)
        : value{std::chrono::duration_cast<std::chrono::milliseconds>(tp.time_since_epoch())} {}

    /* explicit(false) */ operator std::chrono::milliseconds() const {
        return value;
    }
 
    explicit operator std::chrono::system_clock::time_point() const {
        return std::chrono::system_clock::time_point(
            std::chrono::duration_cast<std::chrono::system_clock::duration>(value));
    }

    friend bool operator==(b_date const& lhs, b_date const& rhs) {
        return lhs.value == rhs.value;
    }

    friend bool operator!=(b_date const& lhs, b_date const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_null {
    static constexpr id type_id = id::k_null;

    friend bool operator==(b_null const& /* lhs */, b_null const& /* rhs */) {
        return true;
    }

    friend bool operator!=(b_null const& lhs, b_null const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_regex {
    static constexpr id type_id = id::k_regex;

    v1::stdx::string_view regex;

    v1::stdx::string_view options;

    b_regex() = default;

    explicit b_regex(v1::stdx::string_view regex) : regex{regex}, options{} {}

    b_regex(v1::stdx::string_view regex, v1::stdx::string_view options) : regex{regex}, options{options} {}

    friend bool operator==(b_regex const& lhs, b_regex const& rhs) {
        return lhs.regex == rhs.regex && lhs.options == rhs.options;
    }

    friend bool operator!=(b_regex const& lhs, b_regex const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_dbpointer {
    static constexpr id type_id = id::k_dbpointer;

    v1::stdx::string_view collection;

    v1::oid value;

    b_dbpointer() = default;

    b_dbpointer(v1::stdx::string_view collection, v1::oid value) : collection{collection}, value{value} {}

    friend bool operator==(b_dbpointer const& lhs, b_dbpointer const& rhs) {
        return lhs.collection == rhs.collection && lhs.value == rhs.value;
    }

    friend bool operator!=(b_dbpointer const& lhs, b_dbpointer const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_code {
    static constexpr id type_id = id::k_code;

    v1::stdx::string_view code;

    b_code() = default;

    explicit b_code(v1::stdx::string_view code) : code{code} {}

    /* explicit(false) */ operator v1::stdx::string_view() const {
        return code;
    }

    friend bool operator==(b_code const& lhs, b_code const& rhs) {
        return lhs.code == rhs.code;
    }

    friend bool operator!=(b_code const& lhs, b_code const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_symbol {
    static constexpr id type_id = id::k_symbol;

    v1::stdx::string_view symbol;

    b_symbol() = default;

    explicit b_symbol(v1::stdx::string_view symbol) : symbol{symbol} {}

    /* explicit(false) */ operator v1::stdx::string_view() const {
        return symbol;
    }

    friend bool operator==(b_symbol const& lhs, b_symbol const& rhs) {
        return lhs.symbol == rhs.symbol;
    }

    friend bool operator!=(b_symbol const& lhs, b_symbol const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_codewscope {
    static constexpr id type_id = id::k_codewscope;

    v1::stdx::string_view code;

    v1::document::view scope;

    b_codewscope() = default;

    b_codewscope(v1::stdx::string_view code, v1::document::view scope) : code{code}, scope{scope} {}

    friend bool operator==(b_codewscope const& lhs, b_codewscope const& rhs) {
        return lhs.code == rhs.code && lhs.scope == rhs.scope;
    }

    friend bool operator!=(b_codewscope const& lhs, b_codewscope const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_int32 {
    static constexpr id type_id = id::k_int32;

    std::int32_t value = {};

    b_int32() = default;

    explicit b_int32(std::int32_t value) : value{value} {}

    /* explicit(false) */ operator std::int32_t() const {
        return value;
    }

    friend bool operator==(b_int32 const& lhs, b_int32 const& rhs) {
        return lhs.value == rhs.value;
    }

    friend bool operator!=(b_int32 const& lhs, b_int32 const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_timestamp {
    static constexpr id type_id = id::k_timestamp;

    std::uint32_t increment = {};

    std::uint32_t timestamp = {};

    b_timestamp() = default;

    b_timestamp(std::uint32_t increment, std::uint32_t timestamp) : increment{increment}, timestamp{timestamp} {}

    friend bool operator==(b_timestamp const& lhs, b_timestamp const& rhs) {
        return lhs.timestamp == rhs.timestamp;
    }

    friend bool operator!=(b_timestamp const& lhs, b_timestamp const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_int64 {
    static constexpr id type_id = id::k_int64;

    std::int64_t value = {};

    b_int64() = default;

    explicit b_int64(std::int64_t value) : value{value} {}

    /* explicit(false) */ operator std::int64_t() const {
        return value;
    }

    friend bool operator==(b_int64 const& lhs, b_int64 const& rhs) {
        return lhs.value == rhs.value;
    }

    friend bool operator!=(b_int64 const& lhs, b_int64 const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_decimal128 {
    static constexpr id type_id = id::k_decimal128;

    v1::decimal128 value;

    b_decimal128() = default;

    explicit b_decimal128(v1::decimal128 value) : value{value} {}

    /* explicit(false) */ operator v1::decimal128() const {
        return value;
    }

    friend bool operator==(b_decimal128 const& lhs, b_decimal128 const& rhs) {
        return lhs.value == rhs.value;
    }

    friend bool operator!=(b_decimal128 const& lhs, b_decimal128 const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_maxkey {
    static constexpr id type_id = id::k_maxkey;

    friend bool operator==(b_maxkey const&, b_maxkey const&) {
        return true;
    }

    friend bool operator!=(b_maxkey const& lhs, b_maxkey const& rhs) {
        return !(lhs == rhs);
    }
};

struct b_minkey {
    static constexpr id type_id = id::k_minkey;

    friend bool operator==(b_minkey const&, b_minkey const&) {
        return true;
    }

    friend bool operator!=(b_minkey const& lhs, b_minkey const& rhs) {
        return !(lhs == rhs);
    }
};
 
// BSONCXX_V1_TYPES_XMACRO: update above.
 
#pragma push_macro("X")
#undef X
#define X(_name, _val) BSONCXX_PRIVATE_INLINE_CXX17 constexpr id b_##_name::type_id;
BSONCXX_V1_TYPES_XMACRO(X)
#pragma pop_macro("X")

class view {
   private:
    id _id;
 
#pragma push_macro("X")
#undef X
#define X(_name, _value) b_##_name _b_##_name;
 
    union {
        BSONCXX_V1_TYPES_XMACRO(X)
    };
#pragma pop_macro("X")
 
    template <typename T>
    using is_view = detail::is_alike<T, view>;
 
    template <typename T>
    struct is_equality_comparable_with
        : detail::conjunction<detail::negation<is_view<T>>, std::is_constructible<view, T>> {};
 
   public:
    view() : _id{id::k_null}, _b_null{} {}
 
#pragma push_macro("X")
#undef X
#define X(_name, _value) \
    /* explicit(false) */ view(b_##_name v) : _id{v.type_id}, _b_##_name{v} {}

    BSONCXX_V1_TYPES_XMACRO(X)
#pragma pop_macro("X")

    id type_id() const {
        return _id;
    }
 
#pragma push_macro("X")
#undef X
#define X(_name, _value) BSONCXX_ABI_EXPORT_CDECL(b_##_name) get_##_name() const;

    BSONCXX_V1_TYPES_XMACRO(X)
#pragma pop_macro("X")

    friend bool operator==(view const& lhs, view const& rhs) {
        if (lhs.type_id() != rhs.type_id()) {
            return false;
        }
 
#pragma push_macro("X")
#undef X
#define X(_name, _value)           \
    case v1::types::id::k_##_name: \
        return lhs.get_##_name() == rhs.get_##_name();
 
        switch (lhs.type_id()) {
            BSONCXX_V1_TYPES_XMACRO(X)
 
            default:
                return true;
        }
#pragma pop_macro("X")
    }

    friend bool operator!=(view const& lhs, view const& rhs) {
        return !(lhs == rhs);
    }

    friend bool operator==(view const& v, v1::element::view const& e) {
        return v == e.type_view();
    }
 
    friend bool operator==(v1::element::view const& e, view const& v) {
        return v == e.type_view();
    }


    friend bool operator!=(view const& v, v1::element::view const& e) {
        return !(v == e);
    }
 
    friend bool operator!=(v1::element::view const& e, view const& v) {
        return !(v == e);
    }


    template <typename T, detail::enable_if_t<is_equality_comparable_with<T>::value>* = nullptr>
    friend bool operator==(view const& v, T const& value) {
        return v == view{value};
    }
 
    template <typename T, detail::enable_if_t<is_equality_comparable_with<T>::value>* = nullptr>
    friend bool operator==(T const& value, view const& v) {
        return v == view{value};
    }


    template <typename T, detail::enable_if_t<is_equality_comparable_with<T>::value>* = nullptr>
    friend bool operator!=(view const& v, T const& value) {
        return !(v == value);
    }
 
    template <typename T, detail::enable_if_t<is_equality_comparable_with<T>::value>* = nullptr>
    friend bool operator!=(T const& value, view const& v) {
        return !(v == value);
    }


    enum class errc {
        zero,          
        type_mismatch, 
    };

    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()};
    }
 
    class internal;
};
 
} // namespace types
} // namespace v1
} // namespace bsoncxx
 
template <>
struct std::is_error_code_enum<bsoncxx::v1::types::view::errc> : true_type {};
 
#include <bsoncxx/v1/detail/postlude.hpp>