DynamicLibrary.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Variant.hpp"
#include "CeresEngine/Foundation/IO/FilePath.hpp"
 
namespace CeresEngine {
 
    class DynamicLibrary final {
    public:
        enum class Binding {
            Lazy,
 
            Immediate
        };
 
        enum class Sharing {
            Global,
 
            Local
        };
 
    public:
        using NativeHandle = void*;
 
        template<typename = void> struct Symbol;
 
    private:
        NativeHandle mHandle = nullptr;
 
    public:
        DynamicLibrary();
 
        explicit DynamicLibrary(const FilePath& path, Binding binding = Binding::Immediate, Sharing sharing = Sharing::Local);
 
        explicit DynamicLibrary(StringView name, Binding binding = Binding::Immediate, Sharing sharing = Sharing::Local);
 
        DynamicLibrary(const DynamicLibrary&) = delete;
 
        DynamicLibrary& operator=(const DynamicLibrary&) = delete;
 
        DynamicLibrary(DynamicLibrary&& other) noexcept;
 
        DynamicLibrary& operator=(DynamicLibrary&& other) noexcept;
 
        ~DynamicLibrary() noexcept;
 
    public: // Symbol loading
        [[nodiscard]] Symbol<> resolve(StringView symbolName) const noexcept;
 
        template<typename T> [[nodiscard]] T resolve(StringView symbolName) const noexcept;
 
    public: // Loading & Unloading
        [[nodiscard]] bool loaded() const noexcept;
 
        void unload() noexcept;
 
    public: // Operator overloading
        [[nodiscard]] explicit operator bool() const noexcept;
 
        [[nodiscard]] Symbol<> operator[](StringView symbolName) const noexcept;
 
        friend bool operator==(const DynamicLibrary& a, const DynamicLibrary& b) noexcept;
 
        friend bool operator!=(const DynamicLibrary& a, const DynamicLibrary& b) noexcept;
 
        friend bool operator==(const DynamicLibrary& library, std::nullptr_t) noexcept;
 
        friend bool operator!=(const DynamicLibrary& library, std::nullptr_t) noexcept;
 
    public:
        static const StringView prefix;
 
        static const StringView suffix;
 
    public:
        using NameVariant = Variant<StringView, FilePath>;
 
        using NameSequence = std::initializer_list<NameVariant>;
 
        static bool available(const FilePath& path);
 
        static bool available(StringView name);
 
        static bool available(const NameSequence& names);
 
        template<typename... Ts> static bool available(Ts&&... names) { return available({names...}); }
 
        static DynamicLibrary tryOpen(const NameSequence& names);
 
        template<typename... Ts> static DynamicLibrary tryOpen(Ts&&... names) { return tryOpen({names...}); }
    };
 
    template<> struct DynamicLibrary::Symbol<void> {
        using Ptr = void*;
 
        Ptr ptr;
 
        explicit operator bool() const noexcept { return ptr != nullptr; }
 
        template<typename T,
            typename = typename std::enable_if_t<std::is_pointer_v<T>>> operator T() const noexcept { // NOLINT
            return reinterpret_cast<T>(ptr);
        }
 
        template<typename T> operator Symbol<T>() const noexcept { // NOLINT
            return Symbol<T>(reinterpret_cast<typename Symbol<T>::Ptr>(ptr));
        }
    };
 
    template<typename T> struct DynamicLibrary::Symbol {
        using Ptr = T*;
 
        Ptr ptr = nullptr;
 
        explicit Symbol(const Ptr ptr) : ptr(ptr) {}
 
        explicit operator bool() const noexcept { return ptr != nullptr; }
 
        operator T() const { // NOLINT
            return *ptr;
        }
 
        operator const T&() const { // NOLINT
            return *ptr;
        }
 
        operator T&() { // NOLINT
            return *ptr;
        }
 
        Symbol& operator=(T&& value) {
            *ptr = std::forward<T>(value);
            return *this;
        }
 
        T* operator->() noexcept { return ptr; }
 
        // \return A pointer to the variable
        const T* operator->() const noexcept { return ptr; }
 
        // \return A reference to the variable
        T& operator*() noexcept { return *ptr; }
 
        // \return A reference to the variable
        const T& operator*() const noexcept { return *ptr; }
    };
 
    template<typename R, typename... Args> struct DynamicLibrary::Symbol<R(Args...)> {
        using Ptr = R (*)(Args...);
 
        Ptr ptr = nullptr;
 
        explicit Symbol(const Ptr ptr) : ptr(ptr) {}
 
        explicit operator bool() const noexcept { return ptr != nullptr; }
 
        R operator()(Args... args) const noexcept { return ptr(std::forward<Args>(args)...); }
    };
 
    template<typename R, typename... Args> struct DynamicLibrary::Symbol<R (*)(Args...)> : DynamicLibrary::Symbol<R(Args...)> {
        using Symbol<R(Args...)>::Symbol;
    };
 
    template<typename T> T DynamicLibrary::resolve(const StringView symbolName) const noexcept { return reinterpret_cast<T>(resolve(symbolName).ptr); }
 
    template<typename T1, typename T2> bool operator==(const DynamicLibrary::Symbol<T1>& a, const DynamicLibrary::Symbol<T2>& b) { return a.ptr == b.ptr; }
    template<typename T1, typename T2> bool operator!=(const DynamicLibrary::Symbol<T1>& a, const DynamicLibrary::Symbol<T2>& b) { return a.ptr != b.ptr; }
 
    template<typename T> bool operator==(const DynamicLibrary::Symbol<T>& a, std::nullptr_t) { return a.ptr == nullptr; }
    template<typename T> bool operator!=(const DynamicLibrary::Symbol<T>& a, std::nullptr_t) { return a.ptr != nullptr; }
 
} // namespace CeresEngine