Tuple.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include <tuple>
 
namespace CeresEngine {
    template<typename... Ts> class Tuple : private std::tuple<Ts...> {
    private:
        using Base = std::tuple<Ts...>;
 
    public:
        template<std::size_t I> using ElementType = typename std::tuple_element<I, Base>::type;
 
    public:
        using Base::Base;
        using Base::swap;
 
        template<typename T> constexpr T& get() & { return std::get<T>(base()); }
        template<typename T> constexpr T&& get() && { return std::forward<T>(std::get<T>(base())); }
        template<typename T> constexpr const T& get() const& { return std::get<T>(base()); }
        template<typename T> constexpr const T&& get() const&& { return std::forward<T>(std::get<T>(base())); }
 
        template<std::size_t I> constexpr ElementType<I>& get() & { return std::get<I>(base()); }
        template<std::size_t I> constexpr ElementType<I>&& get() && { return std::forward<ElementType<I>>(std::get<I>(base())); }
        template<std::size_t I> [[nodiscard]] constexpr const ElementType<I>& get() const& { return std::get<I>(base()); }
        template<std::size_t I> [[nodiscard]] constexpr const ElementType<I>&& get() const&& { return std::forward<ElementType<I>>(std::get<I>(base())); }
 
        template<typename Function> decltype(auto) apply(Function&& function) & { return std::apply(std::forward<Function>(function), base()); }
        template<typename Function> decltype(auto) apply(Function&& function) && { return std::apply(std::forward<Function>(function), base()); }
        template<typename Function> [[nodiscard]] decltype(auto) apply(Function&& function) const& {
            return std::apply(std::forward<Function>(function), base());
        }
        template<typename Function> decltype(auto) apply(Function&& function) const&& { return std::apply(std::forward<Function>(function), base()); }
 
        template<class... TTypes, class... UTypes> friend constexpr bool operator==(const Tuple<TTypes...>& lhs, const Tuple<UTypes...>& rhs);
        template<class... TTypes, class... UTypes> friend constexpr bool operator!=(const Tuple<TTypes...>& lhs, const Tuple<UTypes...>& rhs);
        template<class... TTypes, class... UTypes> friend constexpr bool operator<(const Tuple<TTypes...>& lhs, const Tuple<UTypes...>& rhs);
        template<class... TTypes, class... UTypes> friend constexpr bool operator<=(const Tuple<TTypes...>& lhs, const Tuple<UTypes...>& rhs);
        template<class... TTypes, class... UTypes> friend constexpr bool operator>(const Tuple<TTypes...>& lhs, const Tuple<UTypes...>& rhs);
        template<class... TTypes, class... UTypes> friend constexpr bool operator>=(const Tuple<TTypes...>& lhs, const Tuple<UTypes...>& rhs);
 
    private:
        Base& base() & { return static_cast<Base&>(*this); }
        Base&& base() && { return static_cast<Base&&>(*this); }
        [[nodiscard]] const Base& base() const& { return static_cast<const Base&>(*this); }
        [[nodiscard]] const Base&& base() const&& { return static_cast<const Base&&>(*this); }
 
        template<typename> friend struct std::tuple_size;
        template<std::size_t, typename> friend struct std::tuple_element;
        template<typename, typename> friend struct std::uses_allocator;
    };
 
    template<class... TTypes, class... UTypes> constexpr bool operator==(const Tuple<TTypes...>& lhs, const Tuple<UTypes...>& rhs) {
        return lhs.base() == rhs.base();
    }
    template<class... TTypes, class... UTypes> constexpr bool operator!=(const Tuple<TTypes...>& lhs, const Tuple<UTypes...>& rhs) {
        return lhs.base() != rhs.base();
    }
    template<class... TTypes, class... UTypes> constexpr bool operator<(const Tuple<TTypes...>& lhs, const Tuple<UTypes...>& rhs) {
        return lhs.base() < rhs.base();
    }
    template<class... TTypes, class... UTypes> constexpr bool operator<=(const Tuple<TTypes...>& lhs, const Tuple<UTypes...>& rhs) {
        return lhs.base() <= rhs.base();
    }
    template<class... TTypes, class... UTypes> constexpr bool operator>(const Tuple<TTypes...>& lhs, const Tuple<UTypes...>& rhs) {
        return lhs.base() > rhs.base();
    }
    template<class... TTypes, class... UTypes> constexpr bool operator>=(const Tuple<TTypes...>& lhs, const Tuple<UTypes...>& rhs) {
        return lhs.base() >= rhs.base();
    }
 
    template<typename... Ts> Tuple<Ts&...> tie(Ts&... values) { return Tuple<Ts&...>(values...); }
} // namespace CeresEngine
 
template<typename... Ts> struct std::tuple_size<CeresEngine::Tuple<Ts...>> : std::tuple_size<typename CeresEngine::Tuple<Ts...>::Base> {};
 
template<std::size_t I, typename... Ts>
struct std::tuple_element<I, CeresEngine::Tuple<Ts...>> : std::tuple_element<I, typename CeresEngine::Tuple<Ts...>::Base> {};
 
template<typename... Ts, typename Allocator>
struct std::uses_allocator<CeresEngine::Tuple<Ts...>, Allocator> : std::uses_allocator<typename CeresEngine::Tuple<Ts...>::Base, Allocator> {};