Base.hpp

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_GENERIC_BASE_HPP
#define LLU_CONTAINERS_GENERIC_BASE_HPP
 
#include <type_traits>
 
#include "LLU/ErrorLog/ErrorManager.h"
#include "LLU/LibraryData.h"
#include "LLU/MArgument.h"
#include "LLU/Utilities.hpp"
 
#include "LLU/Containers/Interfaces.h"
 
namespace LLU {
 
    enum struct Ownership : uint8_t {
        LibraryLink,    
        Library,    
        Shared      
    };
 
    template<MArgumentType Type>
    class MContainerBase {
    public:
        using Container = Argument::CType<Type>;
 
    public:
        MContainerBase() = default;
 
        MContainerBase(Container c, Ownership owner) : container {c}, owner {owner} {
            if (!c) {
                ErrorManager::throwException(ErrorName::CreateFromNullError);
            }
        }
 
        MContainerBase(const MContainerBase& mc) = delete;
 
        MContainerBase(MContainerBase&& mc) noexcept : container {mc.container}, owner { mc.owner} {
            mc.container = nullptr;
        }
 
        MContainerBase& operator=(const MContainerBase& mc) = delete;
 
        MContainerBase& operator=(MContainerBase&& mc) noexcept {
            if (this != &mc) {
                reset(mc.container, mc.owner);
                mc.container = nullptr;
            }
            return *this;
        }
 
        virtual ~MContainerBase() noexcept {
            if (owner == Ownership::Shared) {
                disown();
            } else if (owner == Ownership::Library) {
                free();
            }
        }
 
        Container getContainer() const noexcept {
            return container;
        }
 
        Container abandonContainer() const noexcept {
            owner = Ownership::LibraryLink;
            return container;
        }
 
        mint shareCount() const noexcept {
            if (container) {
                return shareCountImpl();
            }
            return 0;
        }
 
        void pass(MArgument& res) const {
            if (container) {
                passImpl(res);
            }
            // Per LibraryLink documentation: returning a Shared container does not affect the memory management, so we only need to cover
            // the case where the library owns the container. In such case the ownership is passed to the LibraryLink
            if (owner == Ownership::Library) {
                owner = Ownership::LibraryLink;
            }
        }
 
        Ownership getOwner() const noexcept {
            return owner;
        }
 
    protected:
        Container cloneContainer() const {
            if (container == nullptr) {
                return nullptr;
            }
            return cloneImpl();
        }
 
        void disown() const noexcept {
            if (!container || !LibraryData::hasLibraryData()) {
                return;
            }
            if constexpr (Type == MArgumentType::DataStore) {
                // Disowning does nothing for DataStore as it cannot be shared.
            } else if constexpr (Type == MArgumentType::Image) {
                LibraryData::ImageAPI()->MImage_disown(container);
            } else if constexpr (Type == MArgumentType::NumericArray) {
                LibraryData::NumericArrayAPI()->MNumericArray_disown(container);
            } else if constexpr (Type == MArgumentType::SparseArray) {
                LibraryData::SparseArrayAPI()->MSparseArray_disown(container);
            } else if constexpr (Type == MArgumentType::Tensor) {
                LibraryData::API()->MTensor_disown(container);
            } else {
                static_assert(alwaysFalse<Type>, "Unsupported MContainer type.");
            }
        }
 
        void free() const noexcept {
            if (!container || !LibraryData::hasLibraryData()) {
                return;
            }
            if constexpr (Type == MArgumentType::DataStore) {
                LibraryData::DataStoreAPI()->deleteDataStore(container);
            } else if constexpr (Type == MArgumentType::Image) {
                LibraryData::ImageAPI()->MImage_free(container);
            } else if constexpr (Type == MArgumentType::NumericArray) {
                LibraryData::NumericArrayAPI()->MNumericArray_free(container);
            } else if constexpr (Type == MArgumentType::SparseArray) {
                LibraryData::SparseArrayAPI()->MSparseArray_free(container);
            } else if constexpr (Type == MArgumentType::Tensor) {
                LibraryData::API()->MTensor_free(container);
            } else {
                static_assert(alwaysFalse<Type>, "Unsupported MContainer type.");
            }
        }
 
        void reset(Container newCont, Ownership newOwnerMode = Ownership::Library) noexcept {
            if (newCont != container) {
                switch (owner) {
                    case Ownership::Shared:
                        disown();
                        break;
                    case Ownership::Library:
                        free();
                        break;
                    case Ownership::LibraryLink: break;
                }
                container = newCont;
            }
            owner = newOwnerMode;
        }
 
    private:
        virtual Container cloneImpl() const = 0;
 
        virtual mint shareCountImpl() const = 0;
 
        virtual void passImpl(MArgument& res) const = 0;
 
        Container container {};
 
        mutable Ownership owner = Ownership::Library;
    };
 
    template<MArgumentType Type, typename std::enable_if_t<Argument::ContainerTypeQ<Type>, int> = 0>
#ifdef _WIN32
    class MContainer;    // On Windows we cannot provide a body with static_assert because of ridiculous MSVC compiler errors (probably a bug).
#else                    // On other platforms we get a nice, compile-time error.
    class MContainer {
        static_assert(alwaysFalse<Type>, "Trying to instantiate unspecialized MContainer template.");
    };
#endif
}  // namespace LLU
 
#endif    // LLU_CONTAINERS_GENERIC_BASE_HPP