value.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/types/bson_value/value-fwd.hpp> // IWYU pragma: export
 
//
 
#include <bsoncxx/v1/detail/type_traits.hpp>
#include <bsoncxx/v1/types/value.hpp> // IWYU pragma: export
 
#include <iostream> // IWYU pragma: keep: backward compatibility, to be removed.
#include <memory>   // IWYU pragma: keep: backward compatibility, to be removed.
#include <string>
#include <utility>
#include <vector>
 
#include <bsoncxx/document/element-fwd.hpp> // IWYU pragma: keep: backward compatibility, to be removed.
 
#include <bsoncxx/array/view_or_value.hpp> // IWYU pragma: keep: backward compatibility, to be removed.
#include <bsoncxx/document/view_or_value.hpp>
#include <bsoncxx/types/bson_value/view.hpp>
 
#include <bsoncxx/config/prelude.hpp>
 
namespace bsoncxx {
namespace v_noabi {
namespace types {
namespace bson_value {

class value {
   private:
    v1::types::value _value;
 
    template <typename T>
    using is_value = detail::is_alike<T, value>;
 
    template <typename T>
    using from_v1_expr = decltype(from_v1(std::declval<T>()));
 
    template <typename T>
    struct has_from_v1 : detail::conjunction<detail::negation<is_value<T>>, detail::is_detected<from_v1_expr, T>> {};
 
   public:
    value() = default;

    /* explicit(false) */ value(v1::types::value v) : _value{std::move(v)} {}

    template <typename T, detail::enable_if_t<has_from_v1<T>::value>* = nullptr>
    /* explicit(false) */ value(T v) : value{from_v1(v)} {}
 
#pragma push_macro("X")
#undef X
#define X(_name, _unused) \
    /* explicit(false) */ value(v_noabi::types::b_##_name v) : _value{to_v1(v)} {}

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

    /* explicit(false) */ value(char const* v) : _value{v} {}

    /* explicit(false) */ value(std::string v) : _value{std::move(v)} {}

    /* explicit(false) */ value(v1::stdx::string_view v) : _value{v} {}

    /* explicit(false) */ value(std::int32_t v) : _value{v} {}

    /* explicit(false) */ value(std::int64_t v) : _value{v} {}

    /* explicit(false) */ value(double v) : _value{v} {}

    /* explicit(false) */ value(bool v) : _value{v} {}

    /* explicit(false) */ value(v_noabi::oid v) : _value{to_v1(v)} {}

    /* explicit(false) */ value(v_noabi::decimal128 v) : _value{to_v1(v)} {}

    /* explicit(false) */ value(std::chrono::milliseconds v) : _value{v} {}

    /* explicit(false) */ value(std::nullptr_t) : _value{nullptr} {}

    /* explicit(false) */ value(v_noabi::document::view v) : _value{to_v1(v)} {}

    /* explicit(false) */ value(v_noabi::array::view v) : _value{to_v1(v)} {}

    /* explicit(false) */
    value(std::vector<unsigned char> v, v_noabi::binary_sub_type const sub_type = {})
        : _value{reinterpret_cast<std::uint8_t const*>(v.data()), v.size(), to_v1(sub_type)} {}

    /* explicit(false) */
    value(std::uint8_t const* data, std::size_t size, v_noabi::binary_sub_type const sub_type = {})
        : _value{data, size, to_v1(sub_type)} {}

    /* explicit(false) */ value(v1::stdx::string_view collection, v_noabi::oid value)
        : _value{collection, to_v1(value)} {}

    /* explicit(false) */ value(v1::stdx::string_view code, v_noabi::document::view_or_value scope)
        : _value{code, to_v1(scope.view())} {}

    /* explicit(false) */ value(v1::stdx::string_view regex, v1::stdx::string_view options)
        : _value{v1::types::b_regex{regex, options}} {}

    /* explicit(false) */ BSONCXX_ABI_EXPORT_CDECL_UNSTABLE() value(v_noabi::type const id, v1::stdx::string_view v);

    /* explicit(false) */ BSONCXX_ABI_EXPORT_CDECL_UNSTABLE() value(v_noabi::type const id);

    BSONCXX_ABI_EXPORT_CDECL_UNSTABLE() value(v_noabi::type const id, std::uint64_t a, std::uint64_t b);

    explicit value(v_noabi::types::bson_value::view const& v) : _value{to_v1(v)} {}

    explicit operator v1::types::value() && {
        return std::move(_value);
    }

    explicit operator v1::types::value() const& {
        return _value;
    }

    v_noabi::type type() const {
        return this->view().type();
    }

    v_noabi::type type_id() const {
        return this->view().type_id();
    }

    v_noabi::types::bson_value::view view() const noexcept {
        return _value.view();
    }

    /* explicit(false) */ operator v_noabi::types::bson_value::view() const noexcept {
        return _value.view();
    }
 
#pragma push_macro("X")
#undef X
#define X(_name, _value)                                   \
    v_noabi::types::b_##_name const& get_##_name() const { \
        return this->view().get_##_name();                 \
    }

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


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

inline bool operator!=(value const& lhs, value const& rhs) {
    return !(lhs == rhs);
}



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

inline bool operator==(view const& lhs, value const& rhs) {
    return (rhs == lhs);
}

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

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

 
} // namespace bson_value
} // namespace types
} // namespace v_noabi
} // namespace bsoncxx
 
namespace bsoncxx {
namespace v_noabi {

inline v_noabi::types::bson_value::value from_v1(v1::types::value v) {
    return {std::move(v)};
}

inline v1::types::value to_v1(v_noabi::types::bson_value::value v) {
    return v1::types::value{std::move(v)};
}
 
} // namespace v_noabi
} // namespace bsoncxx
 
namespace bsoncxx {
namespace types {
namespace bson_value {
 
using v_noabi::types::bson_value::operator==;
using v_noabi::types::bson_value::operator!=;
 
} // namespace bson_value
} // namespace types
} // namespace bsoncxx
 
#include <bsoncxx/config/postlude.hpp>