value.hpp

// Copyright 2014 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 <cstddef>
#include <cstdint>
#include <type_traits>
 
#include <bsoncxx/types.hpp>
 
#include <bsoncxx/config/prelude.hpp>
 
namespace bsoncxx {
BSONCXX_INLINE_NAMESPACE_BEGIN
 
namespace types {
 
class BSONCXX_API value {
   public:
    explicit value(b_double) noexcept;
 
    explicit value(b_utf8) noexcept;
 
    explicit value(b_document) noexcept;
 
    explicit value(b_array) noexcept;
 
    explicit value(b_binary) noexcept;
 
    explicit value(b_undefined) noexcept;
 
    explicit value(b_oid) noexcept;
 
    explicit value(b_bool) noexcept;
 
    explicit value(b_date) noexcept;
 
    explicit value(b_null) noexcept;
 
    explicit value(b_regex) noexcept;
 
    explicit value(b_dbpointer) noexcept;
 
    explicit value(b_code) noexcept;
 
    explicit value(b_symbol) noexcept;
 
    explicit value(b_codewscope) noexcept;
 
    explicit value(b_int32) noexcept;
 
    explicit value(b_timestamp) noexcept;
 
    explicit value(b_int64) noexcept;
 
    explicit value(b_minkey) noexcept;
 
    explicit value(b_maxkey) noexcept;
 
    value(const value&) noexcept;
    value& operator=(const value&) noexcept;
 
    ~value();
 
    friend BSONCXX_API bool BSONCXX_CALL operator==(const value&, const value&);
    friend BSONCXX_API bool BSONCXX_CALL operator!=(const value&, const value&);
 
    bsoncxx::type type() const;
 
    const b_double& get_double() const;
 
    const b_utf8& get_utf8() const;
 
    const b_document& get_document() const;
 
    const b_array& get_array() const;
 
    const b_binary& get_binary() const;
 
    const b_undefined& get_undefined() const;
 
    const b_oid& get_oid() const;
 
    const b_bool& get_bool() const;
 
    const b_date& get_date() const;
 
    const b_null& get_null() const;
 
    const b_regex& get_regex() const;
 
    const b_dbpointer& get_dbpointer() const;
 
    const b_code& get_code() const;
 
    const b_symbol& get_symbol() const;
 
    const b_codewscope& get_codewscope() const;
 
    const b_int32& get_int32() const;
 
    const b_timestamp& get_timestamp() const;
 
    const b_int64& get_int64() const;
 
    const b_minkey& get_minkey() const;
 
    const b_maxkey& get_maxkey() const;
 
   private:
    void BSONCXX_PRIVATE destroy() noexcept;
 
    bsoncxx::type _type;
    union {
        struct b_double _b_double;
        struct b_utf8 _b_utf8;
        struct b_document _b_document;
        struct b_array _b_array;
        struct b_binary _b_binary;
        struct b_undefined _b_undefined;
        struct b_oid _b_oid;
        struct b_bool _b_bool;
        struct b_date _b_date;
        struct b_null _b_null;
        struct b_regex _b_regex;
        struct b_dbpointer _b_dbpointer;
        struct b_code _b_code;
        struct b_symbol _b_symbol;
        struct b_codewscope _b_codewscope;
        struct b_int32 _b_int32;
        struct b_timestamp _b_timestamp;
        struct b_int64 _b_int64;
        struct b_minkey _b_minkey;
        struct b_maxkey _b_maxkey;
    };
};
 
// sfinae in the bool return to avoid competing with the value == value
// operators
template <typename T>
using not_value =
    typename std::enable_if<!std::is_same<typename std::remove_reference<T>::type, value>::value,
                            bool>::type;
 
// these all return bool
template <typename T>
BSONCXX_INLINE not_value<T> operator==(const value& lhs, T&& rhs) {
    return lhs == value{std::forward<T>(rhs)};
}
 
template <typename T>
BSONCXX_INLINE not_value<T> operator==(T&& lhs, const value& rhs) {
    return value{std::forward<T>(lhs)} == rhs;
}
 
template <typename T>
BSONCXX_INLINE not_value<T> operator!=(const value& lhs, T&& rhs) {
    return lhs != value{std::forward<T>(rhs)};
}
 
template <typename T>
BSONCXX_INLINE not_value<T> operator!=(T&& lhs, const value& rhs) {
    return value{std::forward<T>(lhs)} != rhs;
}
 
}  // namespace types
 
BSONCXX_INLINE_NAMESPACE_END
}  // namespace bsoncxx
 
#include <bsoncxx/config/postlude.hpp>