pair.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <utility>
#include <tuple>
#include <promeki/core/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename A, typename B>
class Pair {
        public:
                using FirstType = A;
 
                using SecondType = B;
 
                Pair() = default;
 
                Pair(const A &a, const B &b) : d(a, b) {}
 
                Pair(A &&a, B &&b) : d(std::move(a), std::move(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