MetaArgument.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 "Box.hpp"
#include "Type.hpp"
 
namespace CeresEngine {
 
    class MetaArgument final {
    public:
        MetaArgument() noexcept = default;
        MetaArgument(const MetaArgument&) = delete;
        MetaArgument& operator=(const MetaArgument&) = delete;
        MetaArgument(MetaArgument&&) noexcept = default;
        MetaArgument& operator=(MetaArgument&&) = delete;
        ~MetaArgument() noexcept = default;
 
        inline MetaArgument(const Box& value) noexcept;
        inline MetaArgument(Box&& value) noexcept;
        template<typename T> requires(!std::is_same_v<std::decay_t<T>, MetaArgument> && !std::is_same_v<std::decay_t<T>, Box> && !std::is_same_v<std::decay_t<T>, Box>)
        MetaArgument(T&& value) noexcept;
 
        [[nodiscard]] bool empty() const noexcept { return mValue.empty(); }
        template<typename T> [[nodiscard]] T getValue() const;
 
    private:
        [[nodiscard]] bool isMetaValue() const { return Type{mValue.getTypeID()}.getDecayTypeID() == getTypeID<Box>(); }
 
        // rvalue reference
        template<typename T> [[nodiscard]] T getValue(std::integral_constant<int, 0>) const;
 
        // lvalue const reference
        template<typename T> [[nodiscard]] T getValue(std::integral_constant<int, 1>) const;
 
        // lvalue reference
        template<typename T> [[nodiscard]] T getValue(std::integral_constant<int, 2>) const;
 
        // no reference
        template<typename T> [[nodiscard]] T getValue(std::integral_constant<int, 3>) const;
 
        bool mRvalue [[maybe_unused]];
        mutable Box mValue;
        mutable Box mDummy;
    };
 
    MetaArgument::MetaArgument(const Box& value) noexcept : mRvalue(false), mValue(value) {}
    MetaArgument::MetaArgument(Box&& value) noexcept : mRvalue(false), mValue(std::move(value)) {}
    template<typename T> requires(!std::is_same_v<std::decay_t<T>, MetaArgument> && !std::is_same_v<std::decay_t<T>, Box> && !std::is_same_v<std::decay_t<T>, Box>)
    MetaArgument::MetaArgument(T&& value) noexcept : mRvalue(!std::is_reference_v<T>), mValue{std::ref(value)} {}
 
    // rvalue reference
    template<typename T> T MetaArgument::getValue(std::integral_constant<int, 0>) const {
        using namespace std::literals;
        using Decay = std::decay_t<T>;
 
        if(!mRvalue)
            throw BadMetaValueCast("Incompatible argument cast from LValue to RValue reference");
 
        auto* value = &mValue;
        if(isMetaValue())
            value = &mValue.ref<Box>();
 
#if defined(DEBUG)
        auto fromType = Type{value->getTypeID()};
        auto toType = metaType<Decay>();
#endif
 
        if(auto* data = value->data<Decay>())
            return std::move(*data);
 
        mDummy = value->to<Decay>();
        auto* ptr = mDummy.data();
        return std::move(*static_cast<Decay*>(const_cast<void*>(ptr)));
    }
 
    // lvalue const reference
    template<typename T> T MetaArgument::getValue(std::integral_constant<int, 1>) const {
        using Decay = std::decay_t<T>;
 
        const auto* value = &mValue;
        if(isMetaValue())
            value = &mValue.cref<Box>();
 
#if defined(DEBUG)
        auto fromType = Type{value->getTypeID()};
        auto toType = metaType<Decay>();
#endif
        if(auto* data = value->data<Decay>())
            return *data;
 
        mDummy = value->to<Decay>();
        auto* ptr = mDummy.data();
        return *static_cast<const Decay*>(ptr);
    }
 
    // lvalue reference
    template<typename T> T MetaArgument::getValue(std::integral_constant<int, 2>) const {
        using namespace std::literals;
        using Decay = std::decay_t<T>;
 
        if(mRvalue)
            throw BadMetaValueCast("Incompatible argument cast from RValue to non cost LValue reference");
 
        auto* value = &mValue;
        if(isMetaValue())
            value = &mValue.ref<Box>();
 
#if defined(DEBUG)
        auto fromType = Type{value->getTypeID()};
        auto toType = metaType<Decay>();
#endif
 
        return value->ref<Decay>();
    }
 
    // no reference
    template<typename T> T MetaArgument::getValue(std::integral_constant<int, 3>) const {
        using namespace std::literals;
        using Decay = std::decay_t<T>;
 
        const auto* value = &mValue;
        if(isMetaValue())
            value = &mValue.cref<Box>();
 
#if defined(DEBUG)
        auto fromType = Type{value->getTypeID()};
        auto toType = metaType<Decay>();
#endif
 
        return value->to<Decay>();
    }
 
    template<typename T> T MetaArgument::getValue() const {
        using tag_t = std::conditional_t<std::is_rvalue_reference_v<T>, std::integral_constant<int, 0>,
            std::conditional_t<is_lvalue_const_reference<T>, std::integral_constant<int, 1>,
                std::conditional_t<std::is_lvalue_reference_v<T>, std::integral_constant<int, 2>, std::integral_constant<int, 3>>>>;
 
        if(empty()) {
            throw BadArgumentCast("Empty argument");
        }
        return getValue<T>(tag_t{});
    }
 
} // namespace CeresEngine