Variant.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 "CeresEngine/Foundation/Hash.hpp"
 
#include <variant>
 
namespace CeresEngine {
    template<typename... Ts> class Variant : private std::variant<Ts...> {
    private:
        using Base = std::variant<Ts...>;
 
    public:
        using Base::Base;
        using Base::emplace;
        using Base::swap;
 
    public:
        [[nodiscard]] constexpr std::size_t getIndex() const noexcept { return base().index(); }
 
        template<typename T> [[nodiscard]] constexpr bool is() const noexcept { return std::holds_alternative<T>(base()); }
 
        template<typename T> constexpr T& as() & { return std::get<T>(base()); }
        template<typename T> constexpr T&& as() && { return std::forward<T>(std::get<T>(base())); }
        template<typename T> [[nodiscard]] [[nodiscard]] constexpr const T& as() const& { return std::get<T>(base()); }
        template<typename T> constexpr const T&& as() const&& { return std::forward<T>(std::get<T>(base())); }
 
        template<typename T> constexpr std::add_pointer_t<T> asIf() noexcept { return std::get_if<T>(base()); }
        template<typename T> constexpr std::add_pointer_t<const T> asIf() const noexcept { return std::get_if<T>(base()); }
 
        template<typename Visitor> constexpr decltype(auto) visit(Visitor&& visitor) & { return std::visit(visitor, base()); }
        template<typename Visitor> constexpr decltype(auto) visit(Visitor&& visitor) && { return std::visit(visitor, base()); }
        template<typename Visitor> constexpr decltype(auto) visit(Visitor&& visitor) const& { return std::visit(visitor, base()); }
        template<typename Visitor> constexpr decltype(auto) visit(Visitor&& visitor) const&& { return std::visit(visitor, base()); }
 
    public: // Comparison Operators
        friend constexpr bool operator==(const Variant& lhs, const Variant& rhs) { return lhs.base() == rhs.base(); }
        friend constexpr bool operator!=(const Variant& lhs, const Variant& rhs) { return lhs.base() != rhs.base(); }
        friend constexpr bool operator>(const Variant& lhs, const Variant& rhs) { return lhs.base() > rhs.base(); }
        friend constexpr bool operator>=(const Variant& lhs, const Variant& rhs) { return lhs.base() >= rhs.base(); }
        friend constexpr bool operator<(const Variant& lhs, const Variant& rhs) { return lhs.base() < rhs.base(); }
        friend constexpr bool operator<=(const Variant& lhs, const Variant& rhs) { return lhs.base() <= rhs.base(); }
 
    private:
        template<typename U> friend struct std::hash;
 
        [[nodiscard]] Base& base() & { return static_cast<Base&>(*this); }
        [[nodiscard]] 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); }
    };
 
} // namespace CeresEngine
 
template<typename... Ts> struct std::hash<CeresEngine::Variant<Ts...>> {
    using Type = CeresEngine::Variant<Ts...>;
    inline size_t operator()(const Type& object) const noexcept { return CeresEngine::hash(object.base()); }
};