pair.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstddef>
#include <utility>
#include <tuple>
#include <promeki/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename A, typename B> class Pair {
        public:
                using FirstType = A;
 
                using SecondType = B;
 
                Pair() = default;
 
                template <typename A2, typename B2,
                          typename = std::enable_if_t<std::is_constructible_v<A, A2 &&> &&
                                                      std::is_constructible_v<B, B2 &&>>>
                Pair(A2 &&a, B2 &&b) : d(std::forward<A2>(a), std::forward<B2>(b)) {}
 
                Pair(const std::pair<A, B> &p) : d(p) {}
 
                Pair(std::pair<A, B> &&p) : d(std::move(p)) {}
 
                Pair(const Pair &other) = default;
 
                Pair(Pair &&other) noexcept = default;
 
                ~Pair() = default;
 
                Pair &operator=(const Pair &other) = default;
 
                Pair &operator=(Pair &&other) noexcept = default;
 
                A &first() { return d.first; }
 
                const A &first() const { return d.first; }
 
                B &second() { return d.second; }
 
                const B &second() const { return d.second; }
 
                void setFirst(const A &a) { d.first = a; }
 
                void setSecond(const B &b) { d.second = b; }
 
                const std::pair<A, B> &toStdPair() const { return d; }
 
                void swap(Pair &other) noexcept {
                        d.swap(other.d);
                        return;
                }
 
                static Pair make(A a, B b) { return Pair(std::move(a), std::move(b)); }
 
                friend bool operator==(const Pair &lhs, const Pair &rhs) { return lhs.d == rhs.d; }
 
                friend bool operator!=(const Pair &lhs, const Pair &rhs) { return lhs.d != rhs.d; }
 
                friend bool operator<(const Pair &lhs, const Pair &rhs) { return lhs.d < rhs.d; }
 
                template <std::size_t I> auto &get() & {
                        if constexpr (I == 0)
                                return d.first;
                        else
                                return d.second;
                }
 
                template <std::size_t I> const auto &get() const & {
                        if constexpr (I == 0)
                                return d.first;
                        else
                                return d.second;
                }
 
                template <std::size_t I> auto &&get() && {
                        if constexpr (I == 0)
                                return std::move(d.first);
                        else
                                return std::move(d.second);
                }
 
        private:
                std::pair<A, B> d;
};
 
PROMEKI_NAMESPACE_END
 
// Structured bindings support
namespace std {
        template <typename A, typename B>
        struct tuple_size<promeki::Pair<A, B>> : std::integral_constant<std::size_t, 2> {};
 
        template <typename A, typename B> struct tuple_element<0, promeki::Pair<A, B>> {
                        using type = A;
        };
 
        template <typename A, typename B> struct tuple_element<1, promeki::Pair<A, B>> {
                        using type = B;
        };
} // namespace std
 
#endif // PROMEKI_ENABLE_CORE