dynamic_library.hpp

Go to the documentation of this file.

 
#ifndef EAGINE_DYNAMIC_LIBRARY_HPP
#define EAGINE_DYNAMIC_LIBRARY_HPP
 
#include "callable_ref.hpp"
#include "config/platform.hpp"
#include "nothing.hpp"
#include "string_span.hpp"
#include <dlfcn.h>
#include <string>
#include <type_traits>
 
namespace eagine {
 
class executable_module {
public:
    executable_module() noexcept = default;
 
    executable_module(const executable_module&) = delete;
 
    executable_module(executable_module&&) = delete;
 
    auto operator=(const executable_module&) = delete;
 
    auto operator=(executable_module&&) = delete;
 
    using handle_type = void*;
 
    executable_module(string_view filename, int flags)
      : _handle(::dlopen(c_str(filename), flags)) {
        if(!_handle) {
            _message.assign(::dlerror());
        }
    }
 
    executable_module(nothing_t, int flags)
      : _handle(::dlopen(nullptr, flags)) {
        if(!_handle) {
            _message.assign(::dlerror());
        }
    }
 
    ~executable_module() noexcept {
        if(_handle) {
            ::dlclose(_handle);
        }
    }
 
    auto is_open() const noexcept -> bool {
        return bool(_handle);
    }
 
    auto find_symbol(string_view name) -> optionally_valid<void*> {
        ::dlerror();
        void* result = ::dlsym(_handle, c_str(name));
        if(auto error = ::dlerror()) {
            _message.assign(error);
            return {};
        }
        return {result, true};
    }
 
    auto error_message() const noexcept -> string_view {
        return {_message};
    }
 
private:
    handle_type _handle{nullptr};
    std::string _message{};
};
 
class shared_executable_module {
public:
    shared_executable_module() noexcept = default;
 
    shared_executable_module(nothing_t)
      : _module{_do_open(nothing)} {}
 
    shared_executable_module(string_view filename)
      : _module{_do_open(filename)} {}
 
    auto open_self() -> auto& {
        _module = _do_open(nothing);
        return *this;
    }
 
    auto open(string_view filename) -> auto& {
        _module = _do_open(filename);
        return *this;
    }
 
    auto is_open() const noexcept -> bool {
        return bool(_module) && _module->is_open();
    }
 
    explicit operator bool() const noexcept {
        return is_open();
    }
 
    auto error_message() const noexcept -> string_view {
        return bool(_module) ? _module->error_message() : string_view();
    }
 
    auto exports(string_view name) const noexcept -> bool {
        if(is_open()) {
            if(auto found{_module->find_symbol(name)}) {
                return true;
            }
        }
        return false;
    }
 
    template <typename Signature>
    auto find(string_view name) const noexcept -> std::enable_if_t<
      std::is_function_v<std::remove_pointer_t<Signature>>,
      callable_ref<std::remove_pointer_t<Signature>>> {
        if(is_open()) {
            if(auto found{_module->find_symbol(name)}) {
                return {
                  reinterpret_cast<std::remove_pointer_t<Signature>*>(
                    extract(found)),
                  true};
            }
        }
        return {};
    }
 
private:
    std::shared_ptr<executable_module> _module{};
 
    static auto _do_open(string_view filename)
      -> std::shared_ptr<executable_module> {
        return std::make_shared<executable_module>(filename, RTLD_LAZY);
    }
 
    static auto _do_open(nothing_t) -> std::shared_ptr<executable_module> {
        return std::make_shared<executable_module>(nothing, RTLD_LAZY);
    }
};
 
} // namespace eagine
 
#endif // EAGINE_DYNAMIC_LIBRARY_HPP