MArgument.h

Go to the documentation of this file.

 
#ifndef LLU_MARGUMENT_H
#define LLU_MARGUMENT_H
 
#include <string>
#include <variant>
 
#include "LLU/LibraryData.h"
#include "LLU/Utilities.hpp"
 
namespace LLU {
 
    enum class MArgumentType {
        MArgument = MType_Undef,
        Boolean = MType_Boolean,
        Integer = MType_Integer,
        Real = MType_Real,
        Complex = MType_Complex,
        Tensor = MType_Tensor,
        SparseArray = MType_SparseArray,
        NumericArray = MType_NumericArray,
        Image = MType_Image,
        UTF8String = MType_UTF8String,
        DataStore = MType_DataStore
    };
 
    namespace Argument {
        using PrimitiveAny = std::variant<std::monostate, mbool, mint, mreal, mcomplex, MTensor, MSparseArray, MNumericArray, MImage, char*, DataStore>;
 
        template<typename T>
        inline constexpr MArgumentType PrimitiveIndex = static_cast<MArgumentType>(variant_index<PrimitiveAny, T>());
 
        template<typename T>
        inline constexpr bool PrimitiveQ = (variant_index<PrimitiveAny, T>() < std::variant_size_v<PrimitiveAny>);
 
        template<MArgumentType T>
        using CType = std::conditional_t<T == MArgumentType::MArgument, MArgument, std::variant_alternative_t<static_cast<size_t>(T), PrimitiveAny>>;
 
        template<MArgumentType T>
        inline constexpr bool ContainerTypeQ = (T == MArgumentType::Tensor || T == MArgumentType::Image || T == MArgumentType::NumericArray ||
                                         T == MArgumentType::DataStore || T == MArgumentType::SparseArray);
    } // namespace Argument
 
    template<MArgumentType T>
    inline constexpr bool alwaysFalse = false;
 
 
    template<MArgumentType T>
    class PrimitiveWrapper {
    public:
        using value_type = Argument::CType<T>;
 
    public:
        explicit PrimitiveWrapper(MArgument& a) : arg(a) {}
 
        value_type& get();
 
        const value_type& get() const;
 
        value_type* getAddress() const;
 
        void set(value_type newValue);
 
        void addToDataStore(DataStore ds, const std::string& name, MArgumentType actualType = T) const;
 
        static void addDataStoreNode(DataStore ds, std::string_view name, value_type val);
 
        static void addDataStoreNode(DataStore ds, value_type val);
 
    private:
        MArgument& arg;
    };
 
    template<MArgumentType T>
    void PrimitiveWrapper<T>::addToDataStore(DataStore ds, const std::string& name, [[maybe_unused]] MArgumentType actualType) const {
        addDataStoreNode(ds, name, get());
    }
 
    /* Explicit specialization for member functions of PrimitiveWrapper class */
#define LLU_ARGUMENT_DEFINE_SPECIALIZATIONS_OF_MEMBER_FUNCTIONS(ArgType)                                              \
    template<>                                                                                                    \
    auto PrimitiveWrapper<MArgumentType::ArgType>::get()->typename PrimitiveWrapper::value_type&;                                 \
    template<>                                                                                                    \
    auto PrimitiveWrapper<MArgumentType::ArgType>::get() const->const typename PrimitiveWrapper::value_type&;                     \
    template<>                                                                                                    \
    void PrimitiveWrapper<MArgumentType::ArgType>::addDataStoreNode(DataStore ds, std::string_view name, value_type val); \
    template<>                                                                                                    \
    void PrimitiveWrapper<MArgumentType::ArgType>::addDataStoreNode(DataStore ds, value_type val);                        \
    template<>                                                                                                    \
    auto PrimitiveWrapper<MArgumentType::ArgType>::getAddress() const->typename PrimitiveWrapper::value_type*;                    \
    template<>                                                                                                    \
    void PrimitiveWrapper<MArgumentType::ArgType>::set(typename PrimitiveWrapper::value_type newValue);
 
    LLU_ARGUMENT_DEFINE_SPECIALIZATIONS_OF_MEMBER_FUNCTIONS(Boolean)
    LLU_ARGUMENT_DEFINE_SPECIALIZATIONS_OF_MEMBER_FUNCTIONS(Integer)
    LLU_ARGUMENT_DEFINE_SPECIALIZATIONS_OF_MEMBER_FUNCTIONS(Real)
    LLU_ARGUMENT_DEFINE_SPECIALIZATIONS_OF_MEMBER_FUNCTIONS(Complex)
    LLU_ARGUMENT_DEFINE_SPECIALIZATIONS_OF_MEMBER_FUNCTIONS(Tensor)
    LLU_ARGUMENT_DEFINE_SPECIALIZATIONS_OF_MEMBER_FUNCTIONS(DataStore)
    LLU_ARGUMENT_DEFINE_SPECIALIZATIONS_OF_MEMBER_FUNCTIONS(SparseArray)
    LLU_ARGUMENT_DEFINE_SPECIALIZATIONS_OF_MEMBER_FUNCTIONS(NumericArray)
    LLU_ARGUMENT_DEFINE_SPECIALIZATIONS_OF_MEMBER_FUNCTIONS(Image)
    LLU_ARGUMENT_DEFINE_SPECIALIZATIONS_OF_MEMBER_FUNCTIONS(UTF8String)
 
    template<>
    auto PrimitiveWrapper<MArgumentType::MArgument>::get() -> typename PrimitiveWrapper::value_type&;
    template<>
    auto PrimitiveWrapper<MArgumentType::MArgument>::get() const -> const typename PrimitiveWrapper::value_type&;
    template<>
    void PrimitiveWrapper<MArgumentType::MArgument>::addDataStoreNode(DataStore ds, std::string_view name, value_type val) = delete;
    template<>
    void PrimitiveWrapper<MArgumentType::MArgument>::addDataStoreNode(DataStore ds, value_type val) = delete;
    template<>
    auto PrimitiveWrapper<MArgumentType::MArgument>::getAddress() const -> typename PrimitiveWrapper::value_type*;
    template<>
    void PrimitiveWrapper<MArgumentType::MArgument>::set(typename PrimitiveWrapper::value_type newValue);
    template<>
    void PrimitiveWrapper<MArgumentType::MArgument>::addToDataStore(DataStore ds, const std::string& name, MArgumentType actualType) const;
 
#undef LLU_ARGUMENT_DEFINE_SPECIALIZATIONS_OF_MEMBER_FUNCTIONS
 
}    // namespace LLU
 
#endif // LLU_MARGUMENT_H