Variant.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/Assert.h"
#include "common/Globals.h"
#include "math/MathUtils.h"
#include "objects/wrappers/Optional.h"
 
NAMESPACE_SPH_BEGIN
 
template <typename... TArgs>
class AlignedUnion {
private:
    std::aligned_union_t<4, TArgs...> storage;
 
public:
    template <typename T, typename... Ts>
    INLINE void emplace(Ts&&... args) {
        SPH_ASSERT(isAligned(storage));
        new (&storage) T(std::forward<Ts>(args)...);
    }
 
    template <typename T>
    INLINE void destroy() {
        get<T>().~T();
    }
 
    template <typename T>
    INLINE T& get() {
        return reinterpret_cast<T&>(storage);
    }
 
    template <typename T>
    INLINE const T& get() const {
        return reinterpret_cast<const T&>(storage);
    }
};
 
namespace VariantHelpers {
 
template <typename... TArgs>
struct DefaultCreate {
    AlignedUnion<TArgs...>& storage;
 
    template <typename T>
    void visit() {
        storage.template emplace<T>();
    }
};
 
template <typename... TArgs>
struct Delete {
    AlignedUnion<TArgs...>& storage;
 
    template <typename T>
    void visit() {
        storage.template destroy<T>();
    }
};
 
template <typename... TArgs>
struct CopyMoveCreate {
    AlignedUnion<TArgs...>& storage;
 
    template <typename T, typename TOther>
    void visit(const TOther& other) {
        storage.template emplace<T>(other.template get<T>());
    }
 
    template <typename T,
        typename TOther,
        typename = std::enable_if_t<!std::is_lvalue_reference<TOther>::value>>
    void visit(TOther&& other) {
        storage.template emplace<T>(std::move(other.template get<T>()));
    }
};
 
template <typename... TArgs>
struct Assign {
    AlignedUnion<TArgs...>& storage;
 
    template <typename T, typename TOther>
    void visit(TOther&& other) {
        using TRaw = std::decay_t<TOther>;
        storage.template get<TRaw>() = std::forward<TOther>(other);
    }
};
 
template <typename... TArgs>
struct CopyMoveAssign {
    AlignedUnion<TArgs...>& storage;
 
    template <typename T, typename TOther>
    void visit(const TOther& other) {
        storage.template get<T>() = other.template get<T>();
    }
 
    template <typename T,
        typename TOther,
        typename = std::enable_if_t<!std::is_lvalue_reference<TOther>::value>>
    void visit(TOther&& other) {
        storage.template get<T>() = std::move(other.template get<T>());
    }
};
 
template <typename... TArgs>
struct Swap {
    AlignedUnion<TArgs...>& storage;
 
    template <typename T, typename TOther>
    void visit(TOther&& other) {
        std::swap(storage.template get<T>(), other.template get<T>());
    }
};
 
} // namespace VariantHelpers
 
template <typename T0, typename... TArgs>
struct VariantIterator {
    template <typename TVisitor, typename... Ts>
    static void visit(Size idx, TVisitor&& visitor, Ts&&... args) {
        if (idx == 0) {
            visitor.template visit<T0>(std::forward<Ts>(args)...);
        } else {
            VariantIterator<TArgs...>::visit(
                idx - 1, std::forward<TVisitor>(visitor), std::forward<Ts>(args)...);
        }
    }
};
template <typename T0>
struct VariantIterator<T0> {
    template <typename TVisitor, typename... Ts>
    static void visit(Size idx, TVisitor&& visitor, Ts&&... args) {
        SPH_ASSERT(idx == 0);
        visitor.template visit<T0>(std::forward<Ts>(args)...);
    }
};
 
static constexpr struct ConstructTypeIdxTag {
} CONSTRUCT_TYPE_IDX;
 
template <typename... TArgs>
class Variant {
private:
    AlignedUnion<TArgs...> storage;
    int typeIdx;
 
    void destroy() {
        VariantHelpers::Delete<TArgs...> deleter{ storage };
        VariantIterator<TArgs...>::visit(typeIdx, deleter);
    }
 
    static_assert(sizeof...(TArgs) >= 1, "Must have at least 1 variant");
 
public:
    Variant() {
        using T = SelectType<0, TArgs...>;
        storage.template emplace<T>();
        typeIdx = 0;
    }
 
    template <typename T, typename = std::enable_if_t<!std::is_same<std::decay_t<T>, Variant>::value>>
    Variant(T&& value) {
        using RawT = std::decay_t<T>;
        constexpr int idx = getTypeIndex<RawT, TArgs...>;
        static_assert(idx != -1, "Type must be listed in Variant");
        storage.template emplace<RawT>(std::forward<T>(value));
        typeIdx = idx;
    }
 
    Variant(const ConstructTypeIdxTag, const Size typeIdx)
        : typeIdx(typeIdx) {
        SPH_ASSERT(typeIdx < sizeof...(TArgs));
        VariantHelpers::DefaultCreate<TArgs...> creator{ storage };
        VariantIterator<TArgs...>::visit(typeIdx, creator);
    }
 
    Variant(const Variant& other) {
        VariantHelpers::CopyMoveCreate<TArgs...> creator{ storage };
        VariantIterator<TArgs...>::visit(other.typeIdx, creator, other);
        typeIdx = other.typeIdx;
    }
 
    Variant(Variant&& other) {
        VariantHelpers::CopyMoveCreate<TArgs...> creator{ storage };
        VariantIterator<TArgs...>::visit(other.typeIdx, creator, std::move(other));
        typeIdx = other.typeIdx;
    }
 
    ~Variant() {
        destroy();
    }
 
    template <typename T, typename = std::enable_if_t<!std::is_same<std::decay_t<T>, Variant>::value>>
    Variant& operator=(T&& value) {
        using RawT = std::decay_t<T>;
        constexpr int idx = getTypeIndex<RawT, TArgs...>;
        static_assert(idx != -1, "Type must be listed in Variant");
        if (int(typeIdx) != idx) {
            // different type, destroy current and re-create
            destroy();
            storage.template emplace<RawT>(std::forward<T>(value));
        } else {
            // same type, can utilize assignment operator
            storage.template get<RawT>() = std::forward<T>(value);
        }
        typeIdx = idx;
        return *this;
    }
 
    Variant& operator=(const Variant& other) {
        if (typeIdx != other.typeIdx) {
            destroy();
            VariantHelpers::CopyMoveCreate<TArgs...> creator{ storage };
            VariantIterator<TArgs...>::visit(other.typeIdx, creator, other);
        } else {
            VariantHelpers::CopyMoveAssign<TArgs...> assigner{ storage };
            VariantIterator<TArgs...>::visit(other.typeIdx, assigner, other);
        }
        typeIdx = other.typeIdx;
        return *this;
    }
 
    Variant& operator=(Variant&& other) {
        if (typeIdx != other.typeIdx) {
            destroy();
            VariantHelpers::CopyMoveCreate<TArgs...> creator{ storage };
            VariantIterator<TArgs...>::visit(other.typeIdx, creator, std::move(other));
        } else {
            VariantHelpers::CopyMoveAssign<TArgs...> assigner{ storage };
            VariantIterator<TArgs...>::visit(other.typeIdx, assigner, std::move(other));
        }
        typeIdx = other.typeIdx;
        return *this;
    }
 
    void swap(Variant& other) {
        SPH_ASSERT(typeIdx == other.typeIdx);
        VariantHelpers::Swap<TArgs...> swapper{ storage };
        VariantIterator<TArgs...>::visit(typeIdx, swapper, other);
    }
 
    template <typename T, typename... Ts>
    void emplace(Ts&&... args) {
        using RawT = std::decay_t<T>;
        constexpr int idx = getTypeIndex<RawT, TArgs...>;
        static_assert(idx != -1, "Type must be listed in Variant");
        destroy();
        storage.template emplace<RawT>(std::forward<Ts>(args)...);
        typeIdx = idx;
    }
 
    INLINE Size getTypeIdx() const {
        return typeIdx;
    }
 
    template <typename T>
    INLINE bool has() const {
        constexpr int idx = getTypeIndex<std::decay_t<T>, TArgs...>;
        return typeIdx == idx;
    }
 
    template <typename T>
    INLINE static constexpr bool canHold() {
        using RawT = std::decay_t<T>;
        return getTypeIndex<RawT, TArgs...> != -1;
    }
 
    template <typename T>
    INLINE T& get() {
        constexpr int idx = getTypeIndex<std::decay_t<T>, TArgs...>;
        static_assert(idx != -1, "Cannot convert variant to this type");
        SPH_ASSERT(typeIdx == idx);
        return storage.template get<T>();
    }
 
    template <typename T>
    INLINE const T& get() const {
        constexpr int idx = getTypeIndex<std::decay_t<T>, TArgs...>;
        static_assert(idx != -1, "Cannot convert variant to this type");
        SPH_ASSERT(typeIdx == idx);
        return storage.template get<T>();
    }
 
    template <typename T, typename = std::enable_if_t<!std::is_same<std::decay_t<T>, Variant>::value>>
    operator T&() {
        return get<T>();
    }
 
    template <typename T, typename = std::enable_if_t<!std::is_same<std::decay_t<T>, Variant>::value>>
    operator const T&() const {
        return get<T>();
    }
 
    template <typename T>
    Optional<T> tryGet() const {
        constexpr int idx = getTypeIndex<std::decay_t<T>, TArgs...>;
        static_assert(idx != -1, "Cannot convert variant to this type");
        if (typeIdx != getTypeIndex<std::decay_t<T>, TArgs...>) {
            return NOTHING;
        }
        return storage.template get<T>();
    }
};
 
 
namespace Detail {
template <Size N, typename T0, typename... TArgs>
struct ForValue {
    template <typename TVariant, typename TFunctor>
    INLINE static decltype(auto) action(TVariant&& variant, TFunctor&& functor) {
        if (variant.getTypeIdx() == N) {
            return functor(variant.template get<T0>());
        } else {
            return ForValue<N + 1, TArgs...>::action(
                std::forward<TVariant>(variant), std::forward<TFunctor>(functor));
        }
    }
};
 
// specialization for NothingType, does not call the functor
template <Size N, typename... TArgs>
struct ForValue<N, NothingType, TArgs...> {
    template <typename TVariant, typename TFunctor>
    INLINE static decltype(auto) action(TVariant&& variant, TFunctor&& functor) {
        if (variant.getTypeIdx() != N) {
            return ForValue<N + 1, TArgs...>::action(
                std::forward<TVariant>(variant), std::forward<TFunctor>(functor));
        }
        STOP;
    }
};
 
template <Size N, typename T0>
struct ForValue<N, T0> {
    template <typename TVariant, typename TFunctor>
    INLINE static decltype(auto) action(TVariant&& variant, TFunctor&& functor) {
        return functor(variant.template get<T0>());
    }
};
} // namespace Detail
 
template <typename TFunctor, typename... TArgs>
INLINE decltype(auto) forValue(Variant<TArgs...>& variant, TFunctor&& functor) {
    return Detail::ForValue<0, TArgs...>::action(variant, std::forward<TFunctor>(functor));
}
 
template <typename TFunctor, typename... TArgs>
INLINE decltype(auto) forValue(const Variant<TArgs...>& variant, TFunctor&& functor) {
    return Detail::ForValue<0, TArgs...>::action(variant, std::forward<TFunctor>(functor));
}
 
NAMESPACE_SPH_END
 
namespace std {
template <typename... TArgs>
void swap(Sph::Variant<TArgs...>& v1, Sph::Variant<TArgs...>& v2) {
    v1.swap(v2);
}
} // namespace std