// Copyright 2015-2018 Klemens D. Morgenstern
|
// Copyright 2019-2020 Antony Polukhin
|
//
|
// Distributed under the Boost Software License, Version 1.0.
|
// (See accompanying file LICENSE_1_0.txt
|
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
#ifndef BOOST_DLL_IMPORT_CLASS_HPP_
|
#define BOOST_DLL_IMPORT_CLASS_HPP_
|
|
/// \file boost/dll/import_class.hpp
|
/// \warning Extremely experimental! Requires C++11! Will change in next version of Boost! boost/dll/import_class.hpp is not included in boost/dll.hpp
|
/// \brief Contains the boost::dll::experimental::import_class function for importing classes.
|
|
#include <boost/dll/smart_library.hpp>
|
#include <boost/dll/import_mangled.hpp>
|
#include <memory>
|
|
#if (__cplusplus < 201103L) && (!defined(_MSVC_LANG) || _MSVC_LANG < 201103L)
|
# error This file requires C++11 at least!
|
#endif
|
|
#ifdef BOOST_HAS_PRAGMA_ONCE
|
# pragma once
|
#endif
|
|
namespace boost { namespace dll { namespace experimental {
|
|
namespace detail
|
{
|
|
template<typename T>
|
struct deleter
|
{
|
destructor<T> dtor;
|
bool use_deleting;
|
|
deleter(const destructor<T> & dtor, bool use_deleting = false) :
|
dtor(dtor), use_deleting(use_deleting) {}
|
|
void operator()(T*t)
|
{
|
if (use_deleting)
|
dtor.call_deleting(t);
|
else
|
{
|
dtor.call_standard(t);
|
//the thing is actually an array, so delete[]
|
auto p = reinterpret_cast<char*>(t);
|
delete [] p;
|
}
|
}
|
};
|
|
template<class T, class = void>
|
struct mem_fn_call_proxy;
|
|
template<class Class, class U>
|
struct mem_fn_call_proxy<Class, boost::dll::experimental::detail::mangled_library_mem_fn<Class, U>>
|
{
|
typedef boost::dll::experimental::detail::mangled_library_mem_fn<Class, U> mem_fn_t;
|
Class* t;
|
mem_fn_t & mem_fn;
|
|
mem_fn_call_proxy(mem_fn_call_proxy&&) = default;
|
mem_fn_call_proxy(const mem_fn_call_proxy & ) = delete;
|
mem_fn_call_proxy(Class * t, mem_fn_t & mem_fn)
|
: t(t), mem_fn(mem_fn) {}
|
|
template<typename ...Args>
|
auto operator()(Args&&...args) const
|
{
|
return mem_fn(t, std::forward<Args>(args)...);
|
}
|
|
};
|
|
template<class T, class Return, class ...Args>
|
struct mem_fn_call_proxy<T, Return(Args...)>
|
{
|
T* t;
|
const std::string &name;
|
smart_library &_lib;
|
|
mem_fn_call_proxy(mem_fn_call_proxy&&) = default;
|
mem_fn_call_proxy(const mem_fn_call_proxy&) = delete;
|
mem_fn_call_proxy(T *t, const std::string &name, smart_library & _lib)
|
: t(t), name(name), _lib(_lib) {};
|
|
Return operator()(Args...args) const
|
{
|
auto f = _lib.get_mem_fn<T, Return(Args...)>(name);
|
return (t->*f)(static_cast<Args>(args)...);
|
}
|
};
|
|
}
|
|
template<typename T>
|
class imported_class;
|
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(const smart_library& lib, Args...args);
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(const smart_library& lib, const std::string & alias_name, Args...args);
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(const smart_library& lib, std::size_t size, Args...args);
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(const smart_library& lib, std::size_t size,
|
const std::string & alias_name, Args...args);
|
|
|
/*! This class represents an imported class.
|
*
|
* \note It must be constructed via \ref boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
*
|
* \tparam The type or type-alias of the imported class.
|
*/
|
template<typename T>
|
class imported_class
|
{
|
smart_library _lib;
|
std::unique_ptr<T, detail::deleter<T>> _data;
|
bool _is_allocating;
|
std::size_t _size;
|
const std::type_info& _ti;
|
|
template<typename ... Args>
|
inline std::unique_ptr<T, detail::deleter<T>> make_data(const smart_library& lib, Args ... args);
|
template<typename ... Args>
|
inline std::unique_ptr<T, detail::deleter<T>> make_data(const smart_library& lib, std::size_t size, Args...args);
|
|
template<typename ...Args>
|
imported_class(detail::sequence<Args...> *, const smart_library& lib, Args...args);
|
|
template<typename ...Args>
|
imported_class(detail::sequence<Args...> *, const smart_library& lib, std::size_t size, Args...args);
|
|
template<typename ...Args>
|
imported_class(detail::sequence<Args...> *, smart_library&& lib, Args...args);
|
|
template<typename ...Args>
|
imported_class(detail::sequence<Args...> *, smart_library&& lib, std::size_t size, Args...args);
|
public:
|
//alias to construct with explicit parameter list
|
template<typename ...Args>
|
static imported_class<T> make(smart_library&& lib, Args...args)
|
{
|
typedef detail::sequence<Args...> *seq;
|
return imported_class(seq(), boost::move(lib), static_cast<Args>(args)...);
|
}
|
|
template<typename ...Args>
|
static imported_class<T> make(smart_library&& lib, std::size_t size, Args...args)
|
{
|
typedef detail::sequence<Args...> *seq;
|
return imported_class(seq(), boost::move(lib), size, static_cast<Args>(args)...);
|
}
|
template<typename ...Args>
|
static imported_class<T> make(const smart_library& lib, Args...args)
|
{
|
typedef detail::sequence<Args...> *seq;
|
return imported_class(seq(), lib, static_cast<Args>(args)...);
|
}
|
|
template<typename ...Args>
|
static imported_class<T> make(const smart_library& lib, std::size_t size, Args...args)
|
{
|
typedef detail::sequence<Args...> *seq;
|
return imported_class(seq(), lib, size, static_cast<Args>(args)...);
|
}
|
|
typedef imported_class<T> base_t;
|
///Returns a pointer to the underlying class
|
T* get() {return _data.get();}
|
imported_class() = delete;
|
|
imported_class(imported_class&) = delete;
|
imported_class(imported_class&&) = default; ///<Move constructor
|
imported_class& operator=(imported_class&) = delete;
|
imported_class& operator=(imported_class&&) = default; ///<Move assignmend
|
|
///Check if the imported class is move-constructible
|
bool is_move_constructible() {return !_lib.symbol_storage().template get_constructor<T(T&&)> ().empty();}
|
///Check if the imported class is move-assignable
|
bool is_move_assignable() {return !_lib.symbol_storage().template get_mem_fn<T, T&(T&&)> ("operator=").empty();}
|
///Check if the imported class is copy-constructible
|
bool is_copy_constructible() {return !_lib.symbol_storage().template get_constructor<T(const T&)>().empty();}
|
///Check if the imported class is copy-assignable
|
bool is_copy_assignable() {return !_lib.symbol_storage().template get_mem_fn<T, T&(const T&)>("operator=").empty();}
|
|
imported_class<T> copy() const; ///<Invoke the copy constructor. \attention Undefined behaviour if the imported object is not copy constructible.
|
imported_class<T> move(); ///<Invoke the move constructor. \attention Undefined behaviour if the imported object is not move constructible.
|
|
///Invoke the copy assignment. \attention Undefined behaviour if the imported object is not copy assignable.
|
void copy_assign(const imported_class<T> & lhs) const;
|
///Invoke the move assignment. \attention Undefined behaviour if the imported object is not move assignable.
|
void move_assign( imported_class<T> & lhs);
|
|
///Check if the class is loaded.
|
explicit operator bool() const {return _data;}
|
|
///Get a const reference to the std::type_info.
|
const std::type_info& get_type_info() {return _ti;};
|
|
/*! Call a member function. This returns a proxy to the function.
|
* The proxy mechanic mechanic is necessary, so the signaute can be passed.
|
*
|
* \b Example
|
*
|
* \code
|
* im_class.call<void(const char*)>("function_name")("MyString");
|
* \endcode
|
*/
|
template<class Signature>
|
const detail::mem_fn_call_proxy<T, Signature> call(const std::string& name)
|
{
|
return detail::mem_fn_call_proxy<T, Signature>(_data.get(), name, _lib);
|
}
|
/*! Call a qualified member function, i.e. const and or volatile.
|
*
|
* \b Example
|
*
|
* \code
|
* im_class.call<const type_alias, void(const char*)>("function_name")("MyString");
|
* \endcode
|
*/
|
template<class Tin, class Signature, class = boost::enable_if<detail::unqalified_is_same<T, Tin>>>
|
const detail::mem_fn_call_proxy<Tin, Signature> call(const std::string& name)
|
{
|
return detail::mem_fn_call_proxy<Tin, Signature>(_data.get(), name, _lib);
|
}
|
///Overload of ->* for an imported method.
|
template<class Tin, class T2>
|
const detail::mem_fn_call_proxy<Tin, boost::dll::experimental::detail::mangled_library_mem_fn<Tin, T2>>
|
operator->*(detail::mangled_library_mem_fn<Tin, T2>& mn)
|
{
|
return detail::mem_fn_call_proxy<Tin, boost::dll::experimental::detail::mangled_library_mem_fn<Tin, T2>>(_data.get(), mn);
|
}
|
|
///Import a method of the class.
|
template <class ...Args>
|
typename boost::dll::experimental::detail::mangled_import_type<boost::dll::experimental::detail::sequence<T, Args...>>::type
|
import(const std::string & name)
|
{
|
return boost::dll::experimental::import_mangled<T, Args...>(_lib, name);
|
}
|
};
|
|
|
|
//helper function, uses the allocating
|
template<typename T>
|
template<typename ... Args>
|
inline std::unique_ptr<T, detail::deleter<T>> imported_class<T>::make_data(const smart_library& lib, Args ... args)
|
{
|
constructor<T(Args...)> ctor = lib.get_constructor<T(Args...)>();
|
destructor<T> dtor = lib.get_destructor <T>();
|
|
if (!ctor.has_allocating() || !dtor.has_deleting())
|
{
|
boost::dll::fs::error_code ec;
|
|
ec = boost::dll::fs::make_error_code(
|
boost::dll::fs::errc::bad_file_descriptor
|
);
|
|
// report_error() calls dlsym, do not use it here!
|
boost::throw_exception(
|
boost::dll::fs::system_error(
|
ec, "boost::dll::detail::make_data() failed: no allocating ctor or dtor was found"
|
)
|
);
|
}
|
|
return std::unique_ptr<T, detail::deleter<T>> (
|
ctor.call_allocating(static_cast<Args>(args)...),
|
detail::deleter<T>(dtor, false /* not deleting dtor*/));
|
}
|
|
//helper function, using the standard
|
template<typename T>
|
template<typename ... Args>
|
inline std::unique_ptr<T, detail::deleter<T>> imported_class<T>::make_data(const smart_library& lib, std::size_t size, Args...args)
|
{
|
constructor<T(Args...)> ctor = lib.get_constructor<T(Args...)>();
|
destructor<T> dtor = lib.get_destructor <T>();
|
|
if (!ctor.has_standard() || !dtor.has_standard())
|
{
|
boost::dll::fs::error_code ec;
|
|
ec = boost::dll::fs::make_error_code(
|
boost::dll::fs::errc::bad_file_descriptor
|
);
|
|
// report_error() calls dlsym, do not use it here!
|
boost::throw_exception(
|
boost::dll::fs::system_error(
|
ec, "boost::dll::detail::make_data() failed: no regular ctor or dtor was found"
|
)
|
);
|
}
|
|
T *data = reinterpret_cast<T*>(new char[size]);
|
|
ctor.call_standard(data, static_cast<Args>(args)...);
|
|
return std::unique_ptr<T, detail::deleter<T>> (
|
reinterpret_cast<T*>(data),
|
detail::deleter<T>(dtor, false /* not deleting dtor*/));
|
|
}
|
|
|
template<typename T>
|
template<typename ...Args>
|
imported_class<T>::imported_class(detail::sequence<Args...> *, const smart_library & lib, Args...args)
|
: _lib(lib),
|
_data(make_data<Args...>(lib, static_cast<Args>(args)...)),
|
_is_allocating(false),
|
_size(0),
|
_ti(lib.get_type_info<T>())
|
{
|
|
}
|
|
template<typename T>
|
template<typename ...Args>
|
imported_class<T>::imported_class(detail::sequence<Args...> *, const smart_library & lib, std::size_t size, Args...args)
|
: _lib(lib),
|
_data(make_data<Args...>(lib, size, static_cast<Args>(args)...)),
|
_is_allocating(true),
|
_size(size),
|
_ti(lib.get_type_info<T>())
|
{
|
|
}
|
|
template<typename T>
|
template<typename ...Args>
|
imported_class<T>::imported_class(detail::sequence<Args...> *, smart_library && lib, Args...args)
|
: _lib(boost::move(lib)),
|
_data(make_data<Args...>(lib, static_cast<Args>(args)...)),
|
_is_allocating(false),
|
_size(0),
|
_ti(lib.get_type_info<T>())
|
{
|
|
}
|
|
template<typename T>
|
template<typename ...Args>
|
imported_class<T>::imported_class(detail::sequence<Args...> *, smart_library && lib, std::size_t size, Args...args)
|
: _lib(boost::move(lib)),
|
_data(make_data<Args...>(lib, size, static_cast<Args>(args)...)),
|
_is_allocating(true),
|
_size(size),
|
_ti(lib.get_type_info<T>())
|
{
|
|
}
|
|
template<typename T>
|
inline imported_class<T> boost::dll::experimental::imported_class<T>::copy() const
|
{
|
if (this->_is_allocating)
|
return imported_class<T>::template make<const T&>(_lib, *_data);
|
else
|
return imported_class<T>::template make<const T&>(_lib, _size, *_data);
|
}
|
|
template<typename T>
|
inline imported_class<T> boost::dll::experimental::imported_class<T>::move()
|
{
|
if (this->_is_allocating)
|
return imported_class<T>::template make<T&&>(_lib, *_data);
|
else
|
return imported_class<T>::template make<T&&>(_lib, _size, *_data);
|
}
|
|
template<typename T>
|
inline void boost::dll::experimental::imported_class<T>::copy_assign(const imported_class<T>& lhs) const
|
{
|
this->call<T&(const T&)>("operator=")(*lhs._data);
|
}
|
|
template<typename T>
|
inline void boost::dll::experimental::imported_class<T>::move_assign(imported_class<T>& lhs)
|
{
|
this->call<T&(T&&)>("operator=")(static_cast<T&&>(*lhs._data));
|
}
|
|
|
|
/*!
|
* Returns an instance of \ref imported_class which allows to call or import more functions.
|
* It takes a copy of the smart_libray, so no added type_aliases will be visible,
|
* for the object.
|
*
|
* Few compilers do implement an allocating constructor, which allows the construction
|
* of the class without knowing the size. That is not portable, so the actual size of the class
|
* shall always be provided.
|
*
|
* \b Example:
|
*
|
* \code
|
* auto import_class<class type_alias, const std::string&, std::size_t>(lib, "class_name", 20, "param1", 42);
|
* \endcode
|
*
|
* In this example we construct an instance of the class "class_name" with the size 20, which has "type_alias" as an alias,
|
* through a constructor which takes a const-ref of std::string and an std::size_t parameter.
|
*
|
* \tparam T Class type or alias
|
* \tparam Args Constructor argument list.
|
* \param lib Path to shared library or shared library to load function from.
|
* \param name Null-terminated C or C++ mangled name of the function to import. Can handle std::string, char*, const char*.
|
* \param mode An mode that will be used on library load.
|
*
|
* \return class object.
|
*
|
* \throw \forcedlinkfs{system_error} if symbol does not exist or if the DLL/DSO was not loaded.
|
* Overload that accepts path also throws std::bad_alloc in case of insufficient memory.
|
*/
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(const smart_library& lib_, std::size_t size, Args...args)
|
{
|
smart_library lib(lib_);
|
|
return imported_class<T>::template make<Args...>(boost::move(lib), size, static_cast<Args>(args)...);
|
}
|
|
//! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(const smart_library& lib_, Args...args)
|
{
|
smart_library lib(lib_);
|
return imported_class<T>::template make<Args...>(boost::move(lib), static_cast<Args>(args)...);
|
}
|
|
//! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(const smart_library& lib_, const std::string & alias_name, Args...args)
|
{
|
smart_library lib(lib_);
|
lib.add_type_alias<T>(alias_name);
|
return imported_class<T>::template make<Args...>(boost::move(lib), static_cast<Args>(args)...);
|
}
|
|
//! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(const smart_library& lib_, std::size_t size, const std::string & alias_name, Args...args)
|
{
|
smart_library lib(lib_);
|
|
lib.add_type_alias<T>(alias_name);
|
return imported_class<T>::template make<Args...>(boost::move(lib), size, static_cast<Args>(args)...);
|
}
|
|
//! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(const smart_library& lib_, const std::string & alias_name, std::size_t size, Args...args)
|
{
|
smart_library lib(lib_);
|
|
lib.add_type_alias<T>(alias_name);
|
return imported_class<T>::template make<Args...>(boost::move(lib), size, static_cast<Args>(args)...);
|
}
|
|
//! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(smart_library && lib, Args...args)
|
{
|
return imported_class<T>::template make<Args...>(boost::move(lib), static_cast<Args>(args)...);
|
}
|
|
//! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(smart_library && lib, const std::string & alias_name, Args...args)
|
{
|
lib.add_type_alias<T>(alias_name);
|
return imported_class<T>::template make<Args...>(boost::move(lib), static_cast<Args>(args)...);
|
}
|
|
//! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(smart_library && lib, std::size_t size, Args...args)
|
{
|
return imported_class<T>::template make<Args...>(boost::move(lib), size, static_cast<Args>(args)...);
|
}
|
|
//! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(smart_library && lib, std::size_t size, const std::string & alias_name, Args...args)
|
{
|
lib.add_type_alias<T>(alias_name);
|
return imported_class<T>::template make<Args...>(boost::move(lib), size, static_cast<Args>(args)...);
|
}
|
|
//! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(smart_library && lib, const std::string & alias_name, std::size_t size, Args...args)
|
{
|
lib.add_type_alias<T>(alias_name);
|
return imported_class<T>::template make<Args...>(boost::move(lib), size, static_cast<Args>(args)...);
|
}
|
|
|
|
/*! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
* \note This function does add the type alias to the \ref boost::dll::experimental::smart_library.
|
*/
|
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(smart_library & lib, Args...args)
|
{
|
return imported_class<T>::template make<Args...>(lib, static_cast<Args>(args)...);
|
}
|
|
/*! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
* \note This function does add the type alias to the \ref boost::dll::experimental::smart_library.
|
*/
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(smart_library & lib, const std::string & alias_name, Args...args)
|
{
|
lib.add_type_alias<T>(alias_name);
|
return imported_class<T>::template make<Args...>(lib, static_cast<Args>(args)...);
|
}
|
|
/*! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
* \note This function does add the type alias to the \ref boost::dll::experimental::smart_library.
|
*/
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(smart_library & lib, std::size_t size, Args...args)
|
{
|
return imported_class<T>::template make<Args...>(lib, size, static_cast<Args>(args)...);
|
}
|
|
/*! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
* \note This function does add the type alias to the \ref boost::dll::experimental::smart_library.
|
*/
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(smart_library & lib, std::size_t size, const std::string & alias_name, Args...args)
|
{
|
lib.add_type_alias<T>(alias_name);
|
return imported_class<T>::template make<Args...>(lib, size, static_cast<Args>(args)...);
|
}
|
|
/*! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
|
* \note This function does add the type alias to the \ref boost::dll::experimental::smart_library.
|
*/
|
template<typename T, typename ... Args> imported_class<T>
|
import_class(smart_library & lib, const std::string & alias_name, std::size_t size, Args...args)
|
{
|
lib.add_type_alias<T>(alias_name);
|
return imported_class<T>::template make<Args...>(lib, size, static_cast<Args>(args)...);
|
}
|
|
}
|
}
|
}
|
|
|
|
#endif /* BOOST_DLL_IMPORT_CLASS_HPP_ */
|
