compressed_pair.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_UTILITY_COMPRESSED_PAIR_HPP__
#define NEFORCE_CORE_UTILITY_COMPRESSED_PAIR_HPP__

 
#include "NeForce/core/interface/icommon.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename IfEmpty, typename T, bool Compressed = is_empty_v<IfEmpty> && !is_final_v<IfEmpty>>
struct compressed_pair final : IfEmpty, icommon<compressed_pair<IfEmpty, T, Compressed>> {
    using base_type = IfEmpty; 
 
    T value; 

    constexpr compressed_pair() noexcept(is_nothrow_default_constructible_v<T>) :
    IfEmpty(),
    value() {}

    constexpr compressed_pair(const compressed_pair& p) noexcept(is_nothrow_copy_constructible_v<T>) :
    IfEmpty(p.get_base()),
    value(p.value) {}

    constexpr compressed_pair& operator=(const compressed_pair& pir) noexcept(is_nothrow_copy_assignable_v<T>) {
        value = _NEFORCE move(pir.value);
        return *this;
    }

    constexpr compressed_pair(compressed_pair&& p) noexcept(is_nothrow_move_constructible_v<T>) :
    IfEmpty(p.get_base()),
    value(_NEFORCE move(p.value)) {}

    constexpr compressed_pair& operator=(compressed_pair&& pir) noexcept(is_nothrow_move_assignable_v<T>) {
        value = _NEFORCE move(pir.value);
        return *this;
    }

    template <typename... Args, enable_if_t<is_constructible_v<T, Args...>, int> = 0>
    constexpr explicit compressed_pair(default_construct_tag /*unused*/, Args&&... args) noexcept(
            conjunction_v<is_nothrow_default_constructible<IfEmpty>, is_nothrow_constructible<T, Args...>>) :
    IfEmpty(),
    value(_NEFORCE forward<Args>(args)...) {}

    template <typename ToEmpty, typename... Args,
              enable_if_t<conjunction_v<is_constructible<IfEmpty, ToEmpty>, is_constructible<T, Args...>>, int> = 0>
    constexpr explicit compressed_pair(exact_arg_construct_tag /*unused*/, ToEmpty&& first, Args&&... args) noexcept(
            conjunction_v<is_nothrow_constructible<IfEmpty, ToEmpty>, is_nothrow_constructible<T, Args...>>) :
    IfEmpty(_NEFORCE forward<ToEmpty>(first)),
    value(_NEFORCE forward<Args>(args)...) {}

    constexpr compressed_pair& get_base() & noexcept { return *this; }

    constexpr const compressed_pair& get_base() const& noexcept { return *this; }

    constexpr compressed_pair&& get_base() && noexcept { return _NEFORCE move(*this); }

    constexpr const compressed_pair&& get_base() const&& noexcept { return _NEFORCE move(*this); }

    constexpr void swap(compressed_pair& rhs) noexcept(is_nothrow_swappable_v<T>) { _NEFORCE swap(value, rhs.value); }

    constexpr size_t to_hash() const noexcept(noexcept(hash<T>{}(value))) { return hash<T>{}(value); }

    NEFORCE_NODISCARD constexpr bool equal_to(const compressed_pair& y) const
            noexcept(noexcept(this->value == y.value)) {
        return this->value == y.value;
    }

    NEFORCE_NODISCARD constexpr bool less_than(const compressed_pair& y) const
            noexcept(noexcept(this->value < y.value)) {
        return this->value < y.value;
    }
};
 

template <typename IfEmpty, typename T>
struct compressed_pair<IfEmpty, T, false> final : icommon<compressed_pair<IfEmpty, T, false>> {
    IfEmpty no_compressed; 
    T value;               

    constexpr compressed_pair() noexcept(
            conjunction_v<is_nothrow_default_constructible<IfEmpty>, is_nothrow_default_constructible<T>>) :
    no_compressed(),
    value() {}

    constexpr compressed_pair(const compressed_pair& pir) noexcept(
            conjunction_v<is_nothrow_copy_constructible<IfEmpty>, is_nothrow_copy_constructible<T>>) :
    no_compressed(pir.no_compressed),
    value(pir.value) {}

    constexpr compressed_pair& operator=(const compressed_pair& pir) noexcept(
            conjunction_v<is_nothrow_copy_assignable<IfEmpty>, is_nothrow_copy_assignable<T>>) {
        no_compressed = pir.no_compressed;
        value = pir.value;
        return *this;
    }

    constexpr compressed_pair(compressed_pair&& pir) noexcept(
            conjunction_v<is_nothrow_move_constructible<IfEmpty>, is_nothrow_move_constructible<T>>) :
    no_compressed(_NEFORCE move(pir.no_compressed)),
    value(_NEFORCE move(pir.value)) {}

    constexpr compressed_pair& operator=(compressed_pair&& pir) noexcept(
            conjunction_v<is_nothrow_move_assignable<IfEmpty>, is_nothrow_move_assignable<T>>) {
        no_compressed = _NEFORCE move(pir.no_compressed);
        value = _NEFORCE move(pir.value);
        return *this;
    }

    template <typename... Args>
    constexpr explicit compressed_pair(default_construct_tag /*unused*/, Args&&... args) noexcept(
            conjunction_v<is_nothrow_default_constructible<IfEmpty>, is_nothrow_constructible<T, Args...>>) :
    no_compressed(),
    value(_NEFORCE forward<Args>(args)...) {}

    template <typename ToEmpty, typename... Args>
    constexpr compressed_pair(exact_arg_construct_tag /*unused*/, ToEmpty&& first, Args&&... args) noexcept(
            conjunction_v<is_nothrow_constructible<IfEmpty, ToEmpty>, is_nothrow_constructible<T, Args...>>) :
    no_compressed(_NEFORCE forward<ToEmpty>(first)),
    value(_NEFORCE forward<Args>(args)...) {}

    constexpr IfEmpty& get_base() & noexcept { return no_compressed; }

    constexpr const IfEmpty& get_base() const& noexcept { return no_compressed; }

    constexpr IfEmpty&& get_base() && noexcept { return _NEFORCE move(no_compressed); }

    constexpr const IfEmpty&& get_base() const&& noexcept { return _NEFORCE move(no_compressed); }

    constexpr void
    swap(compressed_pair& rhs) noexcept(conjunction_v<is_nothrow_swappable<IfEmpty>, is_nothrow_swappable<T>>) {
        _NEFORCE swap(value, rhs.value);
        _NEFORCE swap(no_compressed, rhs.no_compressed);
    }

    constexpr size_t to_hash() const noexcept(noexcept(hash<IfEmpty>{}(no_compressed) ^ hash<T>{}(value))) {
        return hash<IfEmpty>{}(no_compressed) ^ hash<T>{}(value);
    }

    NEFORCE_NODISCARD constexpr bool equal_to(const compressed_pair& y) const
            noexcept(noexcept(this->no_compressed == y.no_compressed && this->value == y.value)) {
        return this->no_compressed == y.no_compressed && this->value == y.value;
    }

    NEFORCE_NODISCARD constexpr bool less_than(const compressed_pair& y) const
            noexcept(noexcept(this->no_compressed < y.no_compressed ||
                              (!(y.no_compressed < this->no_compressed) && this->value < y.value))) {
        return this->no_compressed < y.no_compressed ||
               (!(y.no_compressed < this->no_compressed) && this->value < y.value);
    }
};
 
#ifdef NEFORCE_STANDARD_17
template <typename IfEmpty, typename T>
compressed_pair(IfEmpty, T) -> compressed_pair<IfEmpty, T>;
#endif
 // CompressedPair
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_UTILITY_COMPRESSED_PAIR_HPP__