MArgumentManager.h

Go to the documentation of this file.

 
#ifndef LLU_MARGUMENTMANAGER_H
#define LLU_MARGUMENTMANAGER_H
 
#include <complex>
#include <cstdint>
#include <limits>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
#include "LLU/Containers/DataList.h"
#include "LLU/Containers/Image.h"
#include "LLU/Containers/NumericArray.h"
#include "LLU/Containers/SparseArray.h"
#include "LLU/Containers/Tensor.h"
#include "LLU/ErrorLog/ErrorManager.h"
#include "LLU/LibraryData.h"
#include "LLU/MArgument.h"
#include "LLU/ManagedExpression.hpp"
#include "LLU/ProgressMonitor.h"
 
namespace LLU {
 
    enum class Passing {
        Automatic,
        Constant,
        Manual,
        Shared
    };
 
    class MArgumentManager {
    public:
        using size_type = std::size_t;
 
    public:
        MArgumentManager(mint Argc, MArgument* Args, MArgument& Res);
 
        MArgumentManager(WolframLibraryData ld, mint Argc, MArgument* Args, MArgument& Res);
 
        /************************************ MArgument "getters" ************************************/
 
        bool getBoolean(size_type index) const;
 
        double getReal(size_type index) const;
 
        template<typename T>
        T getInteger(size_type index) const;
 
        std::complex<double> getComplex(size_type index) const;
 
        char* getCString(size_type index) const;
 
        std::string getString(size_type index) const;
 
        template<typename T, Passing Mode = Passing::Automatic>
        NumericArray<T> getNumericArray(size_type index) const;
 
        template<Passing Mode = Passing::Automatic>
        GenericNumericArray getGenericNumericArray(size_type index) const;
 
        MNumericArray getMNumericArray(size_type index) const;
 
        template<typename T, Passing Mode = Passing::Automatic>
        Tensor<T> getTensor(size_type index) const;
 
        template<Passing Mode = Passing::Automatic>
        GenericTensor getGenericTensor(size_type index) const;
 
        MTensor getMTensor(size_type index) const;
 
        template<typename T, Passing Mode = Passing::Automatic>
        SparseArray<T> getSparseArray(size_type index) const;
 
        template<Passing Mode = Passing::Automatic>
        GenericSparseArray getGenericSparseArray(size_type index) const;
 
        MSparseArray getMSparseArray(size_type index) const;
 
        template<typename T, Passing Mode = Passing::Automatic>
        Image<T> getImage(size_type index) const;
 
        template<Passing Mode = Passing::Automatic>
        GenericImage getGenericImage(size_type index) const;
 
        MImage getMImage(size_type index) const;
 
        template<typename T, Passing Mode = Passing::Automatic>
        DataList<T> getDataList(size_type index) const;
 
        template<Passing Mode = Passing::Automatic>
        GenericDataList getGenericDataList(size_type index) const;
 
        DataStore getDataStore(size_type index) const;
 
        template<class ManagedExpr, class DynamicType = ManagedExpr>
        DynamicType& getManagedExpression(size_type index, ManagedExpressionStore<ManagedExpr>& store) const;
 
        template<class ManagedExpr, class DynamicType = ManagedExpr>
        std::shared_ptr<DynamicType> getManagedExpressionPtr(size_type index, ManagedExpressionStore<ManagedExpr>& store) const;
 
        /************************************ MArgument generic "getters" ************************************/
 
        template<class Container, Passing Mode>
        struct Managed {};
 
    private:
        template<typename T>
        struct RequestedTypeImpl {
            using type = T;
        };
 
        template<class Container, Passing P>
        struct RequestedTypeImpl<Managed<Container, P>> {
            using type = Container;
        };
 
    public:
        template<typename T>
        using RequestedType = typename RequestedTypeImpl<T>::type;
 
        template<typename T>
        RequestedType<T> get(size_type index) const {
            if constexpr (std::is_integral_v<T>) {
                return getInteger<T>(index);
            } else {
                return Getter<std::remove_cv_t<T>>::get(*this, index);
            }
        }
 
        template<typename... ArgTypes>
        std::tuple<RequestedType<ArgTypes>...> getTuple(size_type index = 0) const {
            const auto indices = getOffsets(index, std::array<size_type, sizeof...(ArgTypes)> {getArgSlotCount<std::remove_cv_t<ArgTypes>>()...});
            return MArgPackGetter<ArgTypes...>::template getImpl(*this, indices, std::index_sequence_for<ArgTypes...>{});
        }
 
        template<typename... ArgTypes>
        std::tuple<RequestedType<ArgTypes>...> getTuple(std::array<size_type, sizeof...(ArgTypes)> indices) const {
            return MArgPackGetter<ArgTypes...>::template getImpl(*this, indices, std::index_sequence_for<ArgTypes...>{});
        }
 
        /************************************ MArgument "setters" ************************************/
 
        void setBoolean(bool result) noexcept;
 
        void setReal(double result) noexcept;
 
        void setInteger(mint result) noexcept;
 
        template<typename T>
        bool setMintAndCheck(T result) noexcept;
 
        void setComplex(std::complex<double> c) noexcept;
 
        void setString(const std::string& str);
 
        void setString(const char* str);
 
        void setString(std::string&& str);
 
        template<typename T>
        void setNumericArray(const NumericArray<T>& na);
 
        void setMNumericArray(MNumericArray na);
 
        template<typename T>
        void setTensor(const Tensor<T>& ten);
 
        void setMTensor(MTensor t);
 
        template<typename T>
        void setImage(const Image<T>& im);
 
        void setMImage(MImage im);
 
        template<typename T>
        void setDataList(const DataList<T>& ds);
 
        void setDataStore(DataStore ds);
 
        template<typename T>
        void setSparseArray(const SparseArray<T>& sa);
        
        void setMSparseArray(MSparseArray sa);
 
        /************************************ generic setters ************************************/
 
        void set(bool result) noexcept {
            setBoolean(result);
        }
 
        void set(double result) noexcept {
            setReal(result);
        }
 
        void set(mint result) noexcept {
            setInteger(result);
        }
 
        void set(std::complex<double> c) noexcept {
            setComplex(c);
        }
 
        void set(const std::string& str) {
            setString(str);
        }
 
        void set(const char* str) {
            setString(str);
        }
 
        void set(std::string&& str) {
            setString(std::move(str));
        }
 
        template<typename T>
        void set(const NumericArray<T>& na) {
            setNumericArray(na);
        }
 
        void set(const GenericNumericArray& na) {
            na.pass(res);
        }
 
        template<typename T>
        void set(const SparseArray<T>& ten) {
            setSparseArray(ten);
        }
 
        void set(const GenericSparseArray& t) {
            t.pass(res);
        }
 
        template<typename T>
        void set(const Tensor<T>& ten) {
            setTensor(ten);
        }
 
        void set(const GenericTensor& t) {
            t.pass(res);
        }
 
        template<typename T>
        void set(const Image<T>& im) {
            setImage(im);
        }
 
        void set(const GenericImage& im) {
            im.pass(res);
        }
 
        template<typename T>
        void set(const DataList<T>& ds) {
            setDataList(ds);
        }
 
        void set(const GenericDataList& ds) {
            ds.pass(res);
        }
 
        template<typename T>
        void set(const T& arg) {
            Setter<T>::set(*this, arg);
        }
 
        /************************************ utility functions ************************************/
 
        ProgressMonitor getProgressMonitor(double step = ProgressMonitor::getDefaultStep()) const;
 
        numericarray_data_t getNumericArrayType(size_type index) const;
 
        template<Passing Mode, class Operator, class... OpArgs>
        void operateOnNumericArray(size_type index, OpArgs&&... opArgs);
 
        template<Passing Mode = Passing::Automatic, class Operator>
        void operateOnNumericArray(size_type index, Operator&& op);
 
        unsigned char getTensorType(size_type index) const;
 
        template<Passing Mode, class Operator, class... Args>
        void operateOnTensor(size_type index, Args&&... opArgs);
 
        template<Passing Mode = Passing::Automatic, class Operator>
        void operateOnTensor(size_type index, Operator&& op);
 
        imagedata_t getImageType(size_type index) const;
 
        template<Passing Mode, class Operator, class... Args>
        void operateOnImage(size_type index, Args&&... opArgs);
 
        template<Passing Mode = Passing::Automatic, class Operator>
        void operateOnImage(size_type index, Operator&& op);
 
        /************************************ User-defined types registration ************************************/
 
        template<typename T>
        struct CustomType {
//          using CorrespondingTypes = std::tuple<...>;
        };
 
        template<typename T>
        struct Getter {
            static T get(const MArgumentManager& mngr, size_type firstIndex) {
                if constexpr (isCustomMArgumentType<T>) {
                    return DefaultCustomGetter<T, typename CustomType<T>::CorrespondingTypes>::get(mngr, firstIndex);
                } else {
                    static_assert(dependent_false_v<T>, "Unrecognized MArgument type passed as template parameter to MArgumentManager::get.");
                    return {};
                }
            }
        };
 
        template<typename T>
        struct Setter {
            static void set(MArgumentManager& /*mngr*/, const T& /*value*/) {
                static_assert(dependent_false_v<T>, "Unrecognized MArgument type passed as template parameter to MArgumentManager::set.");
            }
        };
 
    private:
        template<typename... ArgTypes>
        struct MArgPackGetter {
            template<size_type... Indices>
            static std::tuple<ArgTypes...>
            getImpl(const MArgumentManager& mngr, std::array<size_type, sizeof...(ArgTypes)> inds, std::index_sequence<Indices...> /*seq*/) {
                if (sizeof...(ArgTypes) > static_cast<size_type>(mngr.argc)) {
                    ErrorManager::throwException(ErrorName::MArgumentIndexError);
                }
                return {mngr.get<ArgTypes>(inds[Indices])...};
            }
        };
 
        template<typename, typename>
        struct DefaultCustomGetter;
        template<typename T, typename... Args>
        struct DefaultCustomGetter<T, std::tuple<Args...>> {
            static T get(const MArgumentManager& mngr, size_type firstIndex) {
                return std::make_from_tuple<T>(mngr.getTuple<Args...>(firstIndex));
            }
        };
 
        template<typename T>
        struct CustomMArgumentTypeDetector {
            template<typename U>
            static std::true_type isSpecialized(typename CustomType<U>::CorrespondingTypes* /*unused*/) { return {}; }
 
            template<typename>
            static std::false_type isSpecialized(...) { return {}; } // NOLINT(cert-dcl50-cpp): this is a common idiom
 
            static constexpr bool value = decltype(isSpecialized<T>(nullptr))::value; // NOLINT(cppcoreguidelines-pro-type-vararg): this is a common idiom
        };
 
        template<typename T>
        static constexpr bool isCustomMArgumentType = CustomMArgumentTypeDetector<T>::value;
 
        template<typename T>
        static constexpr size_type getArgSlotCount() {
            if constexpr (isCustomMArgumentType<T>) {
                return std::tuple_size_v<typename CustomType<T>::CorrespondingTypes>;
            }
            return 1;
        }
 
        template<size_t N>
        static std::array<size_type, N> getOffsets(size_t I0, std::array<size_type, N> a) {
            if constexpr (N == 0) {
                return {};
            } else {
                std::array<size_type, N> offsets = {I0};
                for (size_t i = 1; i < N; ++i) {
                    offsets[i] = offsets[i - 1] + a[i - 1];
                }
                return offsets;
            }
        }
        /********************************* End of user-defined types registration ************************************/
 
    private:
 
        // Efficient and memory-safe type for storing string arguments from LibraryLink
        using LLStringPtr = std::unique_ptr<char[], decltype(st_WolframLibraryData::UTF8String_disown)>;
 
        MArgument getArgs(size_type index) const;
 
        void initStringArgs();
 
        void acquireUTF8String(size_type index) const;
 
        static constexpr Ownership getOwner(Passing m) noexcept {
            if (m == Passing::Manual) {
                return Ownership::Library;
            }
            if (m == Passing::Shared) {
                return Ownership::Shared;
            }
            return Ownership::LibraryLink;
        }
 
        static std::string stringResultBuffer;
 
        static constexpr mint MINT_MAX = (std::numeric_limits<mint>::max)();
 
        static constexpr mint MINT_MIN = (std::numeric_limits<mint>::min)();
 
        mint argc;
 
        MArgument* args;
 
        MArgument& res;
 
        mutable std::vector<LLStringPtr> stringArgs;
    };
 
    template<typename T>
    T MArgumentManager::getInteger(size_type index) const {
        return static_cast<T>(MArgument_getInteger(getArgs(index)));
    }
 
#define LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION(type, getFunction) \
    template<>                                                          \
    inline type MArgumentManager::get<type>(size_type index) const {    \
        return getFunction(index);                                      \
    }
 
    LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION(bool, getBoolean)
    LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION(double, getReal)
    LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION(std::string, getString)
    LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION(const char*, getCString)
    LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION(std::complex<double>, getComplex)
 
#undef LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION
 
#define LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION_FOR_CONTAINER(Container)                                             \
    template<typename T> /* NOLINTNEXTLINE(bugprone-macro-parentheses): false positive here and below */                      \
    struct MArgumentManager::Getter<Container<T>> {                                                                           \
        static Container<T> get(const MArgumentManager& mngr, size_type index) { /* NOLINT(bugprone-macro-parentheses) */     \
            return mngr.get##Container<T, Passing::Automatic>(index);                                                         \
        }                                                                                                                     \
    };                                                                                                                        \
    template<typename T, Passing Mode>                                                                                        \
    struct MArgumentManager::Getter<MArgumentManager::Managed<Container<T>, Mode>> { /* NOLINT(bugprone-macro-parentheses) */ \
        static Container<T> get(const MArgumentManager& mngr, size_type index) {     /* NOLINT(bugprone-macro-parentheses) */ \
            return mngr.get##Container<T, Mode>(index);                                                                       \
        }                                                                                                                     \
    };                                                                                                                        \
    template<>                                                                                                                \
    struct MArgumentManager::Getter<Generic##Container> {                                                                     \
        static Generic##Container get(const MArgumentManager& mngr, size_type index) {                                        \
            return mngr.getGeneric##Container<Passing::Automatic>(index);                                                     \
        }                                                                                                                     \
    };                                                                                                                        \
    template<Passing Mode>                                                                                                    \
    struct MArgumentManager::Getter<MArgumentManager::Managed<Generic##Container, Mode>> {                                    \
        static Generic##Container get(const MArgumentManager& mngr, size_type index) {                                        \
            return mngr.getGeneric##Container<Mode>(index);                                                                   \
        }                                                                                                                     \
    };
 
    LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION_FOR_CONTAINER(NumericArray)
    LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION_FOR_CONTAINER(Tensor)
    LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION_FOR_CONTAINER(Image)
    LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION_FOR_CONTAINER(DataList)
    LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION_FOR_CONTAINER(SparseArray)
 
#undef LLU_MARGUMENTMANAGER_GENERATE_GET_SPECIALIZATION_FOR_CONTAINER
 
    template<typename T>
    bool MArgumentManager::setMintAndCheck(T result) noexcept {
        if (result >= MINT_MAX) {
            setInteger(MINT_MAX);
            return true;
        }
        if (result <= MINT_MIN) {
            setInteger(MINT_MIN);
            return true;
        }
        setInteger(result);
        return false;
    }
 
    template<typename T, Passing Mode>
    NumericArray<T> MArgumentManager::getNumericArray(size_type index) const {
        return NumericArray<T> { getGenericNumericArray<Mode>(index) };
    }
 
    template<typename T>
    void MArgumentManager::setNumericArray(const NumericArray<T>& na) {
        na.pass(res);
    }
 
    template<Passing Mode, class Operator, class... Args>
    void MArgumentManager::operateOnNumericArray(size_type index, Args&&... opArgs) {
        Operator op;
        switch (getNumericArrayType(index)) {
            case MNumericArray_Type_Bit8: op(this->getNumericArray<int8_t, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MNumericArray_Type_UBit8: op(this->getNumericArray<uint8_t, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MNumericArray_Type_Bit16: op(this->getNumericArray<int16_t, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MNumericArray_Type_UBit16: op(this->getNumericArray<uint16_t, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MNumericArray_Type_Bit32: op(this->getNumericArray<int32_t, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MNumericArray_Type_UBit32: op(this->getNumericArray<uint32_t, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MNumericArray_Type_Bit64: op(this->getNumericArray<int64_t, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MNumericArray_Type_UBit64: op(this->getNumericArray<uint64_t, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MNumericArray_Type_Real32: op(this->getNumericArray<float, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MNumericArray_Type_Real64: op(this->getNumericArray<double, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MNumericArray_Type_Complex_Real32: op(this->getNumericArray<std::complex<float>, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MNumericArray_Type_Complex_Real64: op(this->getNumericArray<std::complex<double>, Mode>(index), std::forward<Args>(opArgs)...); break;
            default:
                ErrorManager::throwExceptionWithDebugInfo(ErrorName::MArgumentNumericArrayError,
                                                          "Incorrect type of NumericArray argument. Argument index: " + std::to_string(index));
        }
    }
 
    template<Passing Mode, class Operator>
    void MArgumentManager::operateOnNumericArray(size_type index, Operator&& op) {
        switch (getNumericArrayType(index)) {
            case MNumericArray_Type_Bit8: op(this->getNumericArray<int8_t, Mode>(index)); break;
            case MNumericArray_Type_UBit8: op(this->getNumericArray<uint8_t, Mode>(index)); break;
            case MNumericArray_Type_Bit16: op(this->getNumericArray<int16_t, Mode>(index)); break;
            case MNumericArray_Type_UBit16: op(this->getNumericArray<uint16_t, Mode>(index)); break;
            case MNumericArray_Type_Bit32: op(this->getNumericArray<int32_t, Mode>(index)); break;
            case MNumericArray_Type_UBit32: op(this->getNumericArray<uint32_t, Mode>(index)); break;
            case MNumericArray_Type_Bit64: op(this->getNumericArray<int64_t, Mode>(index)); break;
            case MNumericArray_Type_UBit64: op(this->getNumericArray<uint64_t, Mode>(index)); break;
            case MNumericArray_Type_Real32: op(this->getNumericArray<float, Mode>(index)); break;
            case MNumericArray_Type_Real64: op(this->getNumericArray<double, Mode>(index)); break;
            case MNumericArray_Type_Complex_Real32: op(this->getNumericArray<std::complex<float>, Mode>(index)); break;
            case MNumericArray_Type_Complex_Real64: op(this->getNumericArray<std::complex<double>, Mode>(index)); break;
            default:
                ErrorManager::throwExceptionWithDebugInfo(ErrorName::MArgumentNumericArrayError,
                                                          "Incorrect type of NumericArray argument. Argument index: " + std::to_string(index));
        }
    }
 
    template<typename T, Passing Mode>
    Tensor<T> MArgumentManager::getTensor(size_type index) const {
        return Tensor<T> { getGenericTensor<Mode>(index) };
    }
 
    template<typename T>
    void MArgumentManager::setTensor(const Tensor<T>& ten) {
        ten.pass(res);
    }
 
    template<Passing Mode, class Operator, class... Args>
    void MArgumentManager::operateOnTensor(size_type index, Args&&... opArgs) {
        Operator op;
        switch (getTensorType(index)) {
            case MType_Integer: op(this->getTensor<mint, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MType_Real: op(this->getTensor<double, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MType_Complex: op(this->getTensor<std::complex<double>, Mode>(index), std::forward<Args>(opArgs)...); break;
            default:
                ErrorManager::throwExceptionWithDebugInfo(ErrorName::MArgumentTensorError,
                                                          "Incorrect type of Tensor argument. Argument index: " + std::to_string(index));
        }
    }
 
    template<Passing Mode, class Operator>
    void MArgumentManager::operateOnTensor(size_type index, Operator&& op) {
        switch (getTensorType(index)) {
            case MType_Integer: op(this->getTensor<mint, Mode>(index)); break;
            case MType_Real: op(this->getTensor<double, Mode>(index)); break;
            case MType_Complex: op(this->getTensor<std::complex<double>, Mode>(index)); break;
            default:
                ErrorManager::throwExceptionWithDebugInfo(ErrorName::MArgumentTensorError,
                                                          "Incorrect type of Tensor argument. Argument index: " + std::to_string(index));
        }
    }
 
    template<typename T, Passing Mode>
    Image<T> MArgumentManager::getImage(size_type index) const {
        return Image<T> { getGenericImage<Mode>(index) };
    }
 
    template<typename T>
    void MArgumentManager::setImage(const Image<T>& im) {
        im.pass(res);
    }
 
    template<Passing Mode, class Operator, class... Args>
    void MArgumentManager::operateOnImage(size_type index, Args&&... opArgs) {
        Operator op;
        switch (getImageType(index)) {
            case MImage_Type_Bit: op(this->getImage<int8_t, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MImage_Type_Bit8: op(this->getImage<uint8_t, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MImage_Type_Bit16: op(this->getImage<uint16_t, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MImage_Type_Real32: op(this->getImage<float, Mode>(index), std::forward<Args>(opArgs)...); break;
            case MImage_Type_Real: op(this->getImage<double, Mode>(index), std::forward<Args>(opArgs)...); break;
            default:
                ErrorManager::throwExceptionWithDebugInfo(ErrorName::MArgumentImageError,
                                                          "Incorrect type of Image argument. Argument index: " + std::to_string(index));
        }
    }
 
    template<Passing Mode, class Operator>
    void MArgumentManager::operateOnImage(size_type index, Operator&& op) {
        switch (getImageType(index)) {
            case MImage_Type_Bit: op(std::move(this->getImage<int8_t, Mode>(index))); break;
            case MImage_Type_Bit8: op(this->getImage<uint8_t, Mode>(index)); break;
            case MImage_Type_Bit16: op(this->getImage<uint16_t, Mode>(index)); break;
            case MImage_Type_Real32: op(this->getImage<float, Mode>(index)); break;
            case MImage_Type_Real: op(this->getImage<double, Mode>(index)); break;
            default:
                ErrorManager::throwExceptionWithDebugInfo(ErrorName::MArgumentImageError,
                                                          "Incorrect type of Image argument. Argument index: " + std::to_string(index));
        }
    }
 
    template<typename T, Passing Mode>
    DataList<T> MArgumentManager::getDataList(size_type index) const {
        return DataList<T>(getGenericDataList<Mode>(index));
    }
 
    template<typename T>
    void MArgumentManager::setDataList(const DataList<T>& ds) {
        ds.pass(res);
    }
 
    template<Passing Mode>
    GenericNumericArray MArgumentManager::getGenericNumericArray(size_type index) const {
        return GenericNumericArray(getMNumericArray(index), getOwner(Mode));
    }
 
    template<Passing Mode>
    GenericTensor MArgumentManager::getGenericTensor(size_type index) const {
        return {getMTensor(index), getOwner(Mode)};
    }
 
    template<Passing Mode>
    GenericImage MArgumentManager::getGenericImage(size_type index) const {
        return {getMImage(index), getOwner(Mode)};
    }
 
    template<Passing Mode>
    GenericDataList MArgumentManager::getGenericDataList(size_type index) const {
        static_assert(Mode != Passing::Shared, "DataStore cannot be passed as \"Shared\".");
        return {getDataStore(index), getOwner(Mode)};
    }
 
    template<typename T, Passing Mode>
    SparseArray<T> MArgumentManager::getSparseArray(size_type index) const {
        return SparseArray<T> { getGenericSparseArray<Mode>(index) };
    }
 
    template<typename T>
    void MArgumentManager::setSparseArray(const SparseArray<T>& sa) {
        sa.pass(res);
    }
    
    template<Passing Mode>
    GenericSparseArray MArgumentManager::getGenericSparseArray(size_type index) const {
        return GenericSparseArray(getMSparseArray(index), getOwner(Mode));
    }
 
    template<class ManagedExpr, class DynamicType>
    DynamicType& MArgumentManager::getManagedExpression(size_type index, ManagedExpressionStore<ManagedExpr>& store) const {
        auto ptr = getManagedExpressionPtr<ManagedExpr, DynamicType>(index, store);
        if (!ptr) {
            ErrorManager::throwException(ErrorName::MLEDynamicTypeError);
        }
        return *ptr;
    }
 
    template<class ManagedExpr, class DynamicType>
    std::shared_ptr<DynamicType> MArgumentManager::getManagedExpressionPtr(size_type index, ManagedExpressionStore<ManagedExpr>& store) const {
        auto exprID = getInteger<mint>(index);
        auto baseClassPtr = store.getInstancePointer(exprID);
        return std::dynamic_pointer_cast<DynamicType>(baseClassPtr);
    }
} /* namespace LLU */
 
#endif // LLU_MARGUMENTMANAGER_H