Generic/DataStore.hpp

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_GENERIC_DATASTORE_HPP
#define LLU_CONTAINERS_GENERIC_DATASTORE_HPP
 
#include "LLU/Containers/Generic/Base.hpp"
#include "LLU/Containers/Iterators/DataStore.hpp"
#include "LLU/MArgument.h"
#include "LLU/TypedMArgument.h"
 
namespace LLU {
 
    using GenericDataList = MContainer<MArgumentType::DataStore>;
 
    template<>
    class MContainer<MArgumentType::DataStore> : public MContainerBase<MArgumentType::DataStore> {
 
        template<typename T>
        using EnableIfArgumentType = std::enable_if_t<Argument::PrimitiveQ<remove_cv_ref<T>> || Argument::WrapperQ<remove_cv_ref<T>>, int>;
 
        template<MArgumentType T>
        using EnableIfUnambiguousWrapperType = std::enable_if_t<!Argument::PrimitiveQ<Argument::WrapperType<T>>, int>;
 
    public:
        using iterator = DataStoreIterator;
 
        using const_iterator = iterator;
 
        using MContainerBase<MArgumentType::DataStore>::MContainerBase;
 
        MContainer() : MContainer(LibraryData::DataStoreAPI()->createDataStore(), Ownership::Library) {}
 
        MContainer(Container c, Ownership owner);
 
        MContainer clone() const {
            return MContainer {cloneContainer(), Ownership::Library};
        }
 
        mint length() const {
            return LibraryData::DataStoreAPI()->DataStore_getLength(this->getContainer());
        }
 
        DataStoreNode front() const {
            return LibraryData::DataStoreAPI()->DataStore_getFirstNode(this->getContainer());
        };
 
        DataStoreNode back() const {
            return LibraryData::DataStoreAPI()->DataStore_getLastNode(this->getContainer());
        };
 
        iterator begin() const {
            return iterator {front()};
        }
 
        // NOLINTNEXTLINE(readability-convert-member-functions-to-static): although in theory end() could be static, it would be uncommon and confusing
        iterator end() const {
            return iterator {nullptr};
        }
 
        const_iterator cbegin() const {
            return begin();
        }
 
        const_iterator cend() const {
            return end();
        }
 
        template<typename T, EnableIfArgumentType<T> = 0>
        void push_back(T nodeValue);
 
        template<typename T, EnableIfArgumentType<T> = 0>
        void push_back(std::string_view name, T nodeValue);
 
        template<MArgumentType Type, EnableIfUnambiguousWrapperType<Type> = 0>
        void push_back(Argument::WrapperType<Type> nodeValue) {
            PrimitiveWrapper<Type>::addDataStoreNode(getContainer(), Argument::toPrimitiveType<Type>(nodeValue));
        }
 
        template<MArgumentType Type, EnableIfUnambiguousWrapperType<Type> = 0>
        void push_back(std::string_view name, Argument::WrapperType<Type> nodeValue) {
            PrimitiveWrapper<Type>::addDataStoreNode(getContainer(), name, Argument::toPrimitiveType<Type>(nodeValue));
        }
 
        template<MArgumentType Type>
        void push_back(Argument::CType<Type> nodeValue) {
            PrimitiveWrapper<Type>::addDataStoreNode(getContainer(), nodeValue);
        }
 
        template<MArgumentType Type>
        void push_back(std::string_view name, Argument::CType<Type> nodeValue) {
            PrimitiveWrapper<Type>::addDataStoreNode(getContainer(), name, nodeValue);
        }
 
        void push_back(const Argument::Typed::Any& node);
 
        void push_back(std::string_view name, const Argument::Typed::Any& node);
 
    private:
        Container cloneImpl() const override {
            return LibraryData::DataStoreAPI()->copyDataStore(this->getContainer());
        }
 
        mint shareCountImpl() const noexcept override {
            return 0;
        }
 
        void passImpl(MArgument& res) const noexcept override {
            //NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast): c-style cast used in a macro in WolframIOLibraryFunctions.h
            MArgument_setDataStore(res, this->getContainer());
        }
    };
 
    template<typename T, GenericDataList::EnableIfArgumentType<T>>
    void GenericDataList::push_back(T nodeValue) {
        static_assert(!std::is_same_v<T, MTensor>, "Do not use push_back templated on the argument type with MTensor or MNumericArray.");
        if constexpr (Argument::PrimitiveQ<T>) {
            constexpr MArgumentType Type = Argument::PrimitiveIndex<T>;
            PrimitiveWrapper<Type>::addDataStoreNode(getContainer(), nodeValue);
        } else if constexpr (Argument::WrapperQ<T>) {
            constexpr MArgumentType Type = Argument::WrapperIndex<T>;
            PrimitiveWrapper<Type>::addDataStoreNode(getContainer(), Argument::toPrimitiveType<Type>(nodeValue));
        }
    }
 
    template<typename T,  GenericDataList::EnableIfArgumentType<T>>
    void  GenericDataList::push_back(std::string_view name, T nodeValue) {
        static_assert(!std::is_same_v<T, MTensor>, "Do not use push_back templated on the argument type with MTensor or MNumericArray.");
        if constexpr (Argument::PrimitiveQ<T>) {
            constexpr MArgumentType Type = Argument::PrimitiveIndex<T>;
            PrimitiveWrapper<Type>::addDataStoreNode(getContainer(), name, nodeValue);
        } else if constexpr (Argument::WrapperQ<T>) {
            constexpr MArgumentType Type = Argument::WrapperIndex<T>;
            PrimitiveWrapper<Type>::addDataStoreNode(getContainer(), name, Argument::toPrimitiveType<Type>(nodeValue));
        }
    }
 
    template<typename T>
    T GenericDataNode::as() const {
        auto v = value();
        auto* ptr = std::get_if<T>(std::addressof(v));
        if (!ptr) {
            ErrorManager::throwException(ErrorName::DLInvalidNodeType);
        }
        return std::move(*ptr);
    }
}  // namespace LLU
 
#endif    // LLU_CONTAINERS_GENERIC_DATASTORE_HPP