dylib.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <stdexcept>
#include <string>
#include <utility>
 
#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
#define DYLIB_CPP17
#include <filesystem>
#endif
 
#if (defined(_WIN32) || defined(_WIN64))
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#define DYLIB_UNDEFINE_LEAN_AND_MEAN
#endif
#ifndef NOMINMAX
#define NOMINMAX
#define DYLIB_UNDEFINE_NOMINMAX
#endif
#include <windows.h>
#ifdef DYLIB_UNDEFINE_LEAN_AND_MEAN
#undef WIN32_LEAN_AND_MEAN
#undef DYLIB_UNDEFINE_LEAN_AND_MEAN
#endif
#ifdef DYLIB_UNDEFINE_NOMINMAX
#undef NOMINMAX
#undef DYLIB_UNDEFINE_NOMINMAX
#endif
#else
#include <dlfcn.h>
#endif
 
#if (defined(_WIN32) || defined(_WIN64))                            // NOLINT
#define DYLIB_WIN_MAC_OTHER(win_def, mac_def, other_def) win_def    // NOLINT
#define DYLIB_WIN_OTHER(win_def, other_def) win_def                 // NOLINT
#elif defined(__APPLE__)                                            // NOLINT
#define DYLIB_WIN_MAC_OTHER(win_def, mac_def, other_def) mac_def    // NOLINT
#define DYLIB_WIN_OTHER(win_def, other_def) other_def               // NOLINT
#else                                                               // NOLINT
#define DYLIB_WIN_MAC_OTHER(win_def, mac_def, other_def) other_def  // NOLINT
#define DYLIB_WIN_OTHER(win_def, other_def) other_def               // NOLINT
#endif                                                              // NOLINT
 
namespace kynema::util {
 
class dylib {
public:
    struct filename_components {
        static constexpr const char* prefix = DYLIB_WIN_OTHER("", "lib");
        static constexpr const char* suffix = DYLIB_WIN_MAC_OTHER(".dll", ".dylib", ".so");
    };
    using native_handle_type = DYLIB_WIN_OTHER(HINSTANCE, void*);
    using native_symbol_type = DYLIB_WIN_OTHER(FARPROC, void*);
 
    static_assert(std::is_pointer_v<native_handle_type>, "Expecting HINSTANCE to be a pointer");
    static_assert(std::is_pointer_v<native_symbol_type>, "Expecting FARPROC to be a pointer");
 
    static constexpr bool add_filename_decorations = true;
    static constexpr bool no_filename_decorations = false;
 
    class exception : public std::runtime_error {
        using std::runtime_error::runtime_error;
    };
 
    class load_error : public exception {
        using exception::exception;
    };
 
    class symbol_error : public exception {
        using exception::exception;
    };
 
    dylib(const dylib&) = delete;
    dylib& operator=(const dylib&) = delete;
 
    dylib(dylib&& other) noexcept : m_handle(other.m_handle) { other.m_handle = nullptr; }
 
    dylib& operator=(dylib&& other) noexcept {
        if (this != &other) {
            std::swap(m_handle, other.m_handle);
        }
        return *this;
    }
 
    dylib(const char* dir_path, const char* lib_name, bool decorations = add_filename_decorations) {
        if (dir_path == nullptr) {
            throw std::invalid_argument("The directory path is null");
        }
        if (lib_name == nullptr) {
            throw std::invalid_argument("The library name is null");
        }
 
        std::string final_name = lib_name;
        std::string final_path = dir_path;
 
        if (decorations) {
            final_name = filename_components::prefix + final_name + filename_components::suffix;
        }
 
        if (!final_path.empty() && final_path.find_last_of('/') != final_path.size() - 1) {
            final_path += '/';
        }
 
        m_handle = open((final_path + final_name).c_str());
 
        if (m_handle == nullptr) {
            throw load_error(
                "Could not load library \"" + final_path + final_name + "\"\n" +
                get_error_description()
            );
        }
    }
 
    dylib(
        const std::string& dir_path, const std::string& lib_name,
        bool decorations = add_filename_decorations
    )
        : dylib(dir_path.c_str(), lib_name.c_str(), decorations) {}
 
    dylib(
        const std::string& dir_path, const char* lib_name,
        bool decorations = add_filename_decorations
    )
        : dylib(dir_path.c_str(), lib_name, decorations) {}
 
    dylib(
        const char* dir_path, const std::string& lib_name,
        bool decorations = add_filename_decorations
    )
        : dylib(dir_path, lib_name.c_str(), decorations) {}
 
    explicit dylib(const std::string& lib_name, bool decorations = add_filename_decorations)
        : dylib("", lib_name.c_str(), decorations) {}
 
    explicit dylib(const char* lib_name, bool decorations = add_filename_decorations)
        : dylib("", lib_name, decorations) {}
 
#ifdef DYLIB_CPP17
    explicit dylib(const std::filesystem::path& lib_path)
        : dylib("", lib_path.string().c_str(), no_filename_decorations) {}
 
    dylib(
        const std::filesystem::path& dir_path, const std::string& lib_name,
        bool decorations = add_filename_decorations
    )
        : dylib(dir_path.string().c_str(), lib_name.c_str(), decorations) {}
 
    dylib(
        const std::filesystem::path& dir_path, const char* lib_name,
        bool decorations = add_filename_decorations
    )
        : dylib(dir_path.string().c_str(), lib_name, decorations) {}
#endif
 
    ~dylib() {
        if (m_handle != nullptr) {
            close(m_handle);
        }
    }
 
    native_symbol_type get_symbol(const char* symbol_name) const {
        if (symbol_name == nullptr) {
            throw std::invalid_argument("The symbol name to lookup is null");
        }
        if (m_handle == nullptr) {
            throw std::logic_error(
                "The dynamic library handle is null. This object may have been moved from."
            );
        }
 
        auto* symbol = locate_symbol(m_handle, symbol_name);
 
        if (symbol == nullptr) {
            throw symbol_error(
                "Could not get symbol \"" + std::string(symbol_name) + "\"\n" +
                get_error_description()
            );
        }
        return symbol;
    }
 
    [[nodiscard]] native_symbol_type get_symbol(const std::string& symbol_name) const {
        return get_symbol(symbol_name.c_str());
    }
 
    template <typename T>
    T* get_function(const char* symbol_name) const {
#if (defined(__GNUC__) && __GNUC__ >= 8)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-function-type"
#endif
        return reinterpret_cast<T*>(get_symbol(symbol_name));  // NOLINT
#if (defined(__GNUC__) && __GNUC__ >= 8)
#pragma GCC diagnostic pop
#endif
    }
 
    template <typename T>
    T* get_function(const std::string& symbol_name) const {  // NOLINT
        return get_function<T>(symbol_name.c_str());
    }
 
    template <typename T>
    T& get_variable(const char* symbol_name) const {
        return *reinterpret_cast<T*>(get_symbol(symbol_name));  // NOLINT
    }
 
    template <typename T>
    T& get_variable(const std::string& symbol_name) const {
        return get_variable<T>(symbol_name.c_str());
    }
 
    [[nodiscard]] bool has_symbol(const char* symbol_name) const noexcept {
        if (m_handle == nullptr || symbol_name == nullptr) {
            return false;
        }
        return locate_symbol(m_handle, symbol_name) != nullptr;
    }
 
    [[nodiscard]] bool has_symbol(const std::string& symbol) const noexcept {
        return has_symbol(symbol.c_str());
    }
 
    native_handle_type native_handle() noexcept { return m_handle; }
 
protected:
    native_handle_type m_handle{nullptr};
 
    static native_handle_type open(const char* path) noexcept {
#if (defined(_WIN32) || defined(_WIN64))
        return LoadLibraryA(path);
#else
        return dlopen(path, RTLD_NOW | RTLD_LOCAL);
#endif
    }
 
    static native_symbol_type locate_symbol(native_handle_type lib, const char* name) noexcept {
        return DYLIB_WIN_OTHER(GetProcAddress, dlsym)(lib, name);
    }
 
    static void close(native_handle_type lib) noexcept {
        DYLIB_WIN_OTHER(FreeLibrary, dlclose)(lib);
    }
 
    static std::string get_error_description() {
#if (defined(_WIN32) || defined(_WIN64))
        constexpr const size_t BUF_SIZE = 512;
        const auto error_code = GetLastError();
        if (!error_code)
            return "No error reported by GetLastError";
        char description[BUF_SIZE];
        const auto lang = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
        const DWORD length = FormatMessageA(
            FORMAT_MESSAGE_FROM_SYSTEM, nullptr, error_code, lang, description, BUF_SIZE, nullptr
        );
        return (length == 0) ? "Unknown error (FormatMessage failed)" : description;
#else
        const auto* const description = dlerror();
        return (description == nullptr) ? "No error reported by dlerror" : description;
#endif
    }
};
 
#undef DYLIB_WIN_MAC_OTHER
#undef DYLIB_WIN_OTHER
#undef DYLIB_CPP17
 
}  // namespace kynema::util