ManagedExpression.hpp

Go to the documentation of this file.

 
#ifndef LLU_MANAGEDEXPRESSION_HPP
#define LLU_MANAGEDEXPRESSION_HPP
 
#include <memory>
#include <unordered_map>
#include <utility>
 
#include "LLU/LibraryData.h"
#include "LLU/Utilities.hpp"
 
#define DEFINE_MANAGED_STORE_AND_SPECIALIZATION(ClassName)                                        \
    LLU::ManagedExpressionStore<ClassName> ClassName##Store;                                      \
                                                                                                  \
    template<>                                                                                    \
    inline void LLU::manageInstanceCallback<ClassName>(WolframLibraryData, mbool mode, mint id) { \
        ClassName##Store.manageInstance(mode, id);                                                \
    }
 
namespace LLU {
 
    template<class T>
    void manageInstanceCallback(WolframLibraryData /*libData*/, mbool /*mode*/, mint /*id*/) {
        static_assert(dependent_false_v<T>, "Use of unspecialized ManageInstance function.");
    }
 
    template<typename T>
    class ManagedExpressionStore {
    public:
        using iterator = typename std::unordered_map<mint, std::shared_ptr<T>>::iterator;
 
        using const_iterator = typename std::unordered_map<mint, std::shared_ptr<T>>::const_iterator;
 
        using size_type = typename std::unordered_map<mint, std::shared_ptr<T>>::size_type;
    public:
        void manageInstance(mbool mode, mint id) {
            if (mode == False /* create new instance */) {
                store[id] = nullptr;
            } else {
                store.erase(id);
            }
        }
 
        template<class DynamicType = T, typename... Args>
        T& createInstance(mint id, Args&&... args) {
            checkID(id);    // at this point instance must already exist in store
            store[id] = std::make_shared<DynamicType>(std::forward<Args>(args)...);
            return *store[id];
        }
 
        T& createInstance(mint id, std::shared_ptr<T> ptr) {
            checkID(id);
            store[id] = std::move(ptr);
            return instanceAt(id);
        }
 
        T& createInstance(mint id, std::unique_ptr<T> ptr) {
            return createInstance(id, std::shared_ptr<T> {std::move(ptr)});
        }
 
        int releaseInstance(mint id) {
            return LibraryData::API()->releaseManagedLibraryExpression(expressionName.c_str(), id);
        }
 
        [[nodiscard]] bool hasInstance(mint id) const {
            return store.count(id) == 1;
        }
 
        T& getInstance(mint id) {
            checkID(id);
            return instanceAt(id);
        }
 
        std::shared_ptr<T> getInstancePointer(mint id) {
            checkID(id);
            return store[id];
        }
 
        const std::string& getExpressionName() const noexcept {
            return expressionName;
        }
 
        size_type size() const noexcept {
            return store.size();
        }
 
        iterator begin() noexcept {
            return store.begin();
        }
 
        const_iterator begin() const noexcept {
            return store.cbegin();
        }
 
        const_iterator cbegin() const noexcept {
            return store.cbegin();
        }
 
        iterator end() noexcept {
            return store.end();
        }
 
        const_iterator end() const noexcept {
            return store.end();
        }
 
        const_iterator cend() const noexcept {
            return store.cend();
        }
 
        void registerType(std::string name, WolframLibraryData libData = LibraryData::API()) noexcept {
            expressionName = std::move(name);
            libData->registerLibraryExpressionManager(expressionName.c_str(), manageInstanceCallback<T>);
        }
 
        void unregisterType(WolframLibraryData libData = LibraryData::API()) const noexcept {
            libData->unregisterLibraryExpressionManager(expressionName.c_str());
        }
 
    private:
        void checkID(mint id) const {
            if (!hasInstance(id)) {
                ErrorManager::throwException(ErrorName::ManagedExprInvalidID);
            }
        }
 
        T& instanceAt(mint id) {
            auto& instancePtr = store[id];
            if (!instancePtr) {
                ErrorManager::throwException(ErrorName::MLENullInstance);
            }
            return *instancePtr;
        }
 
    private:
        std::unordered_map<mint, std::shared_ptr<T>> store;
 
        std::string expressionName;
    };
 
}    // namespace LLU
 
#endif    // LLU_MANAGEDEXPRESSION_HPP