loader.hpp

Go to the documentation of this file.

/* 
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__UTILS_DYNLIB_LOADER_H
#define PLASK__UTILS_DYNLIB_LOADER_H
 
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
#   define PLASK__UTILS_PLUGIN_WINAPI
#else
#   define PLASK__UTILS_PLUGIN_DLOPEN
#endif
 
#include <string>
#include <functional>   //std::hash
 
#include <plask/config.hpp>
 
namespace plask {
 
struct PLASK_API DynamicLibrary {
 
    enum Flags {
        DONT_CLOSE = 1  
    };
 
    typedef void* handle_t;    // real type on windows is HINSTANCE, but it is a pointer (to struct), so we are going to cast it from/to void* to avoid indluding windows.h
 
private:
    handle_t handle;
#ifdef PLASK__UTILS_PLUGIN_WINAPI
    bool unload;    // true if lib. should be unloaded, destructor just don't call FreeLibrary if this is false, undefined when handle == 0
#endif
 
public:
 
    handle_t getHandle() const { return handle; }
 
    static constexpr const char* DEFAULT_EXTENSION =
#ifdef PLASK__UTILS_PLUGIN_WINAPI
            ".dll";
#else
            ".so";
#endif
 
    explicit DynamicLibrary(const std::string& filename, unsigned flags);
 
    DynamicLibrary();
 
    DynamicLibrary(const DynamicLibrary&) = delete;
 
    DynamicLibrary& operator=(const DynamicLibrary &) = delete;
 
    DynamicLibrary(DynamicLibrary&& to_move) noexcept;
 
    DynamicLibrary& operator=(DynamicLibrary && to_move) noexcept {
        swap(to_move);  // destructor of to_move will close current this library
        return *this;
    }
 
    void swap(DynamicLibrary& to_swap) noexcept {
        std::swap(handle, to_swap.handle);
#ifdef PLASK__UTILS_PLUGIN_WINAPI
        std::swap(unload, to_swap.unload);
#endif
    }
 
    ~DynamicLibrary();
 
    void open(const std::string& filename, unsigned flags);
 
    void close();
 
    void* getSymbol(const std::string &symbol_name) const;
 
    template <typename SymbolType>
    SymbolType getSymbol(const std::string &symbol_name) const {
        return reinterpret_cast<SymbolType>(getSymbol(symbol_name));
    }
 
    void* operator[](const std::string &symbol_name) const {
        return getSymbol(symbol_name);
    }
 
    void* requireSymbol(const std::string &symbol_name) const;
 
    template <typename SymbolType>
    SymbolType requireSymbol(const std::string &symbol_name) const {
        return reinterpret_cast<SymbolType>(requireSymbol(symbol_name));
    }
 
    bool isOpen() const { return handle != 0; }
 
    handle_t getSystemHandler() const { return handle; }
 
    handle_t release();
 
    bool operator<(const DynamicLibrary& other) const {
#ifdef PLASK__UTILS_PLUGIN_WINAPI
        return this->handle < other.handle || (this->handle == other.handle && !this->unload && other.unload);
#else
        return this->handle < other.handle;
#endif
    }
 
    bool operator == (const DynamicLibrary& other) const {
#ifdef PLASK__UTILS_PLUGIN_WINAPI
        return (this->handle == other.handle) && (this->unload == other.unload);
#else
        return this->handle == other.handle;
#endif
    }
 
};
 
}   // namespace plask
 
namespace std {
 
inline void swap(plask::DynamicLibrary& a, plask::DynamicLibrary& b) noexcept { a.swap(b); }
 
template<>
struct hash<plask::DynamicLibrary> {
    std::hash<plask::DynamicLibrary::handle_t> h;
public:
    std::size_t operator()(const plask::DynamicLibrary &s) const {
        return h(s.getSystemHandler());
    }
};
 
 
 
}
 
#endif // PLASK__UTILS_DYNLIB_LOADER_H