compressed_pair.hpp

#ifndef ENTT_CORE_COMPRESSED_PAIR_HPP
#define ENTT_CORE_COMPRESSED_PAIR_HPP
 
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>
#include "../config/config.h"
#include "type_traits.hpp"
 
namespace entt {
 
namespace internal {
 
template<typename Type, std::size_t, typename = void>
struct compressed_pair_element {
    using reference = Type &;
    using const_reference = const Type &;
 
    template<bool Dummy = true, typename = std::enable_if_t<Dummy && std::is_default_constructible_v<Type>>>
    compressed_pair_element()
        : value{} {}
 
    template<typename Args, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Args>>, compressed_pair_element>>>
    compressed_pair_element(Args &&args)
        : value{std::forward<Args>(args)} {}
 
    template<typename... Args, std::size_t... Index>
    compressed_pair_element(std::tuple<Args...> args, std::index_sequence<Index...>)
        : value{std::forward<Args>(std::get<Index>(args))...} {}
 
    [[nodiscard]] reference get() ENTT_NOEXCEPT {
        return value;
    }
 
    [[nodiscard]] const_reference get() const ENTT_NOEXCEPT {
        return value;
    }
 
private:
    Type value;
};
 
template<typename Type, std::size_t Tag>
struct compressed_pair_element<Type, Tag, std::enable_if_t<is_ebco_eligible_v<Type>>>: Type {
    using reference = Type &;
    using const_reference = const Type &;
    using base_type = Type;
 
    template<bool Dummy = true, typename = std::enable_if_t<Dummy && std::is_default_constructible_v<base_type>>>
    compressed_pair_element()
        : base_type{} {}
 
    template<typename Args, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Args>>, compressed_pair_element>>>
    compressed_pair_element(Args &&args)
        : base_type{std::forward<Args>(args)} {}
 
    template<typename... Args, std::size_t... Index>
    compressed_pair_element(std::tuple<Args...> args, std::index_sequence<Index...>)
        : base_type{std::forward<Args>(std::get<Index>(args))...} {}
 
    [[nodiscard]] reference get() ENTT_NOEXCEPT {
        return *this;
    }
 
    [[nodiscard]] const_reference get() const ENTT_NOEXCEPT {
        return *this;
    }
};
 
} // namespace internal
 
template<typename First, typename Second>
class compressed_pair final
    : internal::compressed_pair_element<First, 0u>,
      internal::compressed_pair_element<Second, 1u> {
    using first_base = internal::compressed_pair_element<First, 0u>;
    using second_base = internal::compressed_pair_element<Second, 1u>;
 
public:
    using first_type = First;
    using second_type = Second;
 
    template<bool Dummy = true, typename = std::enable_if_t<Dummy && std::is_default_constructible_v<first_type> && std::is_default_constructible_v<second_type>>>
    constexpr compressed_pair()
        : first_base{},
          second_base{} {}
 
    constexpr compressed_pair(const compressed_pair &other) = default;
 
    constexpr compressed_pair(compressed_pair &&other) = default;
 
    template<typename Arg, typename Other>
    constexpr compressed_pair(Arg &&arg, Other &&other)
        : first_base{std::forward<Arg>(arg)},
          second_base{std::forward<Other>(other)} {}
 
    template<typename... Args, typename... Other>
    constexpr compressed_pair(std::piecewise_construct_t, std::tuple<Args...> args, std::tuple<Other...> other)
        : first_base{std::move(args), std::index_sequence_for<Args...>{}},
          second_base{std::move(other), std::index_sequence_for<Other...>{}} {}
 
    constexpr compressed_pair &operator=(const compressed_pair &other) = default;
 
    constexpr compressed_pair &operator=(compressed_pair &&other) = default;
 
    [[nodiscard]] first_type &first() ENTT_NOEXCEPT {
        return static_cast<first_base &>(*this).get();
    }
 
    [[nodiscard]] const first_type &first() const ENTT_NOEXCEPT {
        return static_cast<const first_base &>(*this).get();
    }
 
    [[nodiscard]] second_type &second() ENTT_NOEXCEPT {
        return static_cast<second_base &>(*this).get();
    }
 
    [[nodiscard]] const second_type &second() const ENTT_NOEXCEPT {
        return static_cast<const second_base &>(*this).get();
    }
 
    void swap(compressed_pair &other) {
        using std::swap;
        swap(first(), other.first());
        swap(second(), other.second());
    }
 
    template<std::size_t Index>
    decltype(auto) get() ENTT_NOEXCEPT {
        if constexpr(Index == 0u) {
            return first();
        } else {
            static_assert(Index == 1u, "Index out of bounds");
            return second();
        }
    }
 
    template<std::size_t Index>
    decltype(auto) get() const ENTT_NOEXCEPT {
        if constexpr(Index == 0u) {
            return first();
        } else {
            static_assert(Index == 1u, "Index out of bounds");
            return second();
        }
    }
};
 
template<typename Type, typename Other>
compressed_pair(Type &&, Other &&) -> compressed_pair<std::decay_t<Type>, std::decay_t<Other>>;
 
template<typename First, typename Second>
inline void swap(compressed_pair<First, Second> &lhs, compressed_pair<First, Second> &rhs) {
    lhs.swap(rhs);
}
 
} // namespace entt
 
// disable structured binding support for clang 6, it messes when specializing tuple_size
#if !defined __clang_major__ || __clang_major__ > 6
namespace std {
 
template<typename First, typename Second>
struct tuple_size<entt::compressed_pair<First, Second>>: integral_constant<size_t, 2u> {};
 
template<size_t Index, typename First, typename Second>
struct tuple_element<Index, entt::compressed_pair<First, Second>>: conditional<Index == 0u, First, Second> {
    static_assert(Index < 2u, "Index out of bounds");
};
 
} // namespace std
#endif
 
#endif