townforge/dll
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #30 from klemens-morgenstern/develop

Browse Source 
Doc & shared_ptr
This commit is contained in:
Antony Polukhin 2016-06-17 23:02:20 +04:00 committed by GitHub
commit 83b8227b00
10 changed files with 365 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
doc/Jamfile.v2
View File

@ -58,6 +58,7 @@ doxygen autodoc_shared_library_core
../include/boost/dll/alias.hpp
../include/boost/dll/smart_library.hpp
../include/boost/dll/import_class.hpp
]
:
$(doxygen_params)

21
doc/mangled.qbk
View File

@ -10,7 +10,26 @@
[section Mangled Import]
This section describes the experimental feature of allowing the import of mangled symbols from an dll. While this feature is unique to this library and looks quite promising, it is not throroughly tested and thus not considered stable.
This section describes the experimental feature of allowing the import of mangled symbols from an dll. While this feature is unique to this library and looks quite promising, it is not throroughly tested and thus not considered stable.
As a short example we can import the following functions quite easily:
```
//library.dll
namespace foo {
int bar(int);
double bar(double);
}
```
And the import looks like this:
```
auto f1 = import_mangled<int(int)>("library.dll", "foo::bar");
auto f2 = import_mangled<double(double)>("library.dll", "foo::bar");
cout << f1(42) << endl;
cout << f2(3.2) << endl;
```
[section Support & Requirements]

2
example/mangled/smart_lib.cpp
View File

@ -23,7 +23,7 @@ int main(int argc, char* argv[]) {
//[smart_lib_size
auto size_f = lib.get_function<std::size_t()>("space::my_plugin::size"); //get the size function
auto size = (*size_f)(); // get the size of the class
auto size = size_f(); // get the size of the class
std::unique_ptr<char[], size> buffer(new char[size]); //allocate a buffer for the import
alias & inst = *reinterpret_cast<alias*>(buffer.get()); //cast it to our alias type.
//]

32
include/boost/dll/detail/demangling/itanium.hpp
View File

@ -27,12 +27,12 @@ class mangled_storage_impl : public mangled_storage_base
struct dummy {};
template<typename Return, typename ...Args>
std::vector<std::string> get_func_params(dummy<Return(Args...)>)
std::vector<std::string> get_func_params(dummy<Return(Args...)>) const
{
return {get_name<Args>()...};
}
template<typename Return, typename ...Args>
std::string get_return_type(dummy<Return(Args...)>)
std::string get_return_type(dummy<Return(Args...)>) const
{
return get_name<Return>();
}
@ -62,25 +62,25 @@ public:
};
template<typename T>
std::string get_variable(const std::string &name);
std::string get_variable(const std::string &name) const;
template<typename Func>
std::string get_function(const std::string &name);
std::string get_function(const std::string &name) const;
template<typename Class, typename Func>
std::string get_mem_fn(const std::string &name);
std::string get_mem_fn(const std::string &name) const;
template<typename Signature>
ctor_sym get_constructor();
ctor_sym get_constructor() const;
template<typename Class>
dtor_sym get_destructor();
dtor_sym get_destructor() const;
template<typename T>
std::string get_type_info();
std::string get_type_info() const;
template<typename T>
std::vector<std::string> get_related();
std::vector<std::string> get_related() const;
};
@ -146,7 +146,7 @@ namespace parser
template<typename T> std::string mangled_storage_impl::get_variable(const std::string &name)
template<typename T> std::string mangled_storage_impl::get_variable(const std::string &name) const
{
auto found = std::find_if(storage_.begin(), storage_.end(),
[&](const entry& e) {return e.demangled == name;});
@ -157,7 +157,7 @@ template<typename T> std::string mangled_storage_impl::get_variable(const std::s
return "";
}
template<typename Func> std::string mangled_storage_impl::get_function(const std::string &name)
template<typename Func> std::string mangled_storage_impl::get_function(const std::string &name) const
{
using func_type = Func*;
@ -172,7 +172,7 @@ template<typename Func> std::string mangled_storage_impl::get_function(const std
}
template<typename Class, typename Func>
std::string mangled_storage_impl::get_mem_fn(const std::string &name)
std::string mangled_storage_impl::get_mem_fn(const std::string &name) const
{
using namespace parser;
@ -195,7 +195,7 @@ std::string mangled_storage_impl::get_mem_fn(const std::string &name)
template<typename Signature>
auto mangled_storage_impl::get_constructor() -> ctor_sym
auto mangled_storage_impl::get_constructor() const -> ctor_sym
{
using namespace parser;
@ -242,7 +242,7 @@ auto mangled_storage_impl::get_constructor() -> ctor_sym
}
template<typename Class>
auto mangled_storage_impl::get_destructor() -> dtor_sym
auto mangled_storage_impl::get_destructor() const -> dtor_sym
{
std::string dtor_name; // = class_name + "::" + name;
std::string unscoped_cname; //the unscoped class-name
@ -286,7 +286,7 @@ auto mangled_storage_impl::get_destructor() -> dtor_sym
}
template<typename T>
std::string mangled_storage_impl::get_type_info()
std::string mangled_storage_impl::get_type_info() const
{
std::string id = "typeinfo for " + get_name<T>();
@ -306,7 +306,7 @@ std::string mangled_storage_impl::get_type_info()
}
template<typename T>
std::vector<std::string> mangled_storage_impl::get_related()
std::vector<std::string> mangled_storage_impl::get_related() const
{
std::vector<std::string> ret;
auto name = get_name<T>();

32
include/boost/dll/detail/demangling/msvc.hpp
View File

@ -27,12 +27,12 @@ class mangled_storage_impl : public mangled_storage_base
struct dummy {};
template<typename Return, typename ...Args>
std::vector<std::string> get_func_params(dummy<Return(Args...)>)
std::vector<std::string> get_func_params(dummy<Return(Args...)>) const
{
return {get_name<Args>()...};
}
template<typename Return, typename ...Args>
std::string get_return_type(dummy<Return(Args...)>)
std::string get_return_type(dummy<Return(Args...)>) const
{
return get_name<Return>();
}
@ -46,19 +46,19 @@ public:
using mangled_storage_base::mangled_storage_base;
template<typename T>
std::string get_variable(const std::string &name);
std::string get_variable(const std::string &name) const;
template<typename Func>
std::string get_function(const std::string &name);
std::string get_function(const std::string &name) const;
template<typename Class, typename Func>
std::string get_mem_fn(const std::string &name);
std::string get_mem_fn(const std::string &name) const;
template<typename Signature>
ctor_sym get_constructor();
ctor_sym get_constructor() const;
template<typename Class>
dtor_sym get_destructor();
dtor_sym get_destructor() const;
template<typename T> //overload, does not need to virtual.
std::string get_name() const
@ -69,10 +69,10 @@ public:
}
template<typename T>
std::string get_vtable();
std::string get_vtable() const;
template<typename T>
std::vector<std::string> get_related();
std::vector<std::string> get_related() const;
};
@ -192,7 +192,7 @@ namespace parser
}
template<typename T> std::string mangled_storage_impl::get_variable(const std::string &name)
template<typename T> std::string mangled_storage_impl::get_variable(const std::string &name) const
{
using namespace std;
using namespace boost;
@ -226,7 +226,7 @@ template<typename T> std::string mangled_storage_impl::get_variable(const std::s
return "";
}
template<typename Func> std::string mangled_storage_impl::get_function(const std::string &name)
template<typename Func> std::string mangled_storage_impl::get_function(const std::string &name) const
{
namespace x3 = spirit::x3;
using namespace parser;
@ -264,7 +264,7 @@ template<typename Func> std::string mangled_storage_impl::get_function(const std
}
template<typename Class, typename Func>
std::string mangled_storage_impl::get_mem_fn(const std::string &name)
std::string mangled_storage_impl::get_mem_fn(const std::string &name) const
{
namespace x3 = spirit::x3;
using namespace parser;
@ -302,7 +302,7 @@ std::string mangled_storage_impl::get_mem_fn(const std::string &name)
template<typename Signature>
auto mangled_storage_impl::get_constructor() -> ctor_sym
auto mangled_storage_impl::get_constructor() const -> ctor_sym
{
namespace x3 = spirit::x3;
using namespace parser;
@ -352,7 +352,7 @@ auto mangled_storage_impl::get_constructor() -> ctor_sym
}
template<typename Class>
auto mangled_storage_impl::get_destructor() -> dtor_sym
auto mangled_storage_impl::get_destructor() const -> dtor_sym
{
namespace x3 = spirit::x3;
using namespace parser;
@ -398,7 +398,7 @@ auto mangled_storage_impl::get_destructor() -> dtor_sym
}
template<typename T>
std::string mangled_storage_impl::get_vtable()
std::string mangled_storage_impl::get_vtable() const
{
std::string id = "const " + get_name<T>() + "::`vftable'";
@ -417,7 +417,7 @@ std::string mangled_storage_impl::get_vtable()
}
template<typename T>
std::vector<std::string> mangled_storage_impl::get_related()
std::vector<std::string> mangled_storage_impl::get_related() const
{
std::vector<std::string> ret;
auto name = get_name<T>();

306
include/boost/dll/import_class.hpp
View File

@ -11,7 +11,6 @@
#include <boost/dll/import_mangled.hpp>
#include <memory>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
@ -92,87 +91,137 @@ template<typename T>
class imported_class;
template<typename T, typename ... Args> imported_class<T>
import_class(const boost::shared_ptr<smart_library>& lib, Args...args);
import_class(const smart_library& lib, Args...args);
template<typename T, typename ... Args> imported_class<T>
import_class(const boost::shared_ptr<smart_library>& lib, const std::string & alias_name, Args...args);
import_class(const smart_library& lib, const std::string & alias_name, Args...args);
template<typename T, typename ... Args> imported_class<T>
import_class(const boost::shared_ptr<smart_library>& lib, std::size_t size, Args...args);
import_class(const smart_library& lib, std::size_t size, Args...args);
template<typename T, typename ... Args> imported_class<T>
import_class(const boost::shared_ptr<smart_library>& lib, std::size_t size,
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
{
boost::shared_ptr<smart_library> _lib;
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 boost::shared_ptr<smart_library>& lib, Args ... 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 boost::shared_ptr<smart_library>& lib, std::size_t size, Args...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 boost::shared_ptr<smart_library>& lib, Args...args);
imported_class(detail::sequence<Args...> *, const smart_library& lib, Args...args);
template<typename ...Args>
imported_class(detail::sequence<Args...> *, const boost::shared_ptr<smart_library>& lib, std::size_t size, Args...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(const boost::shared_ptr<smart_library>& lib, Args...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 boost::shared_ptr<smart_library>& lib, std::size_t size, Args...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;
imported_class(imported_class&&) = default; ///<Move constructor
imported_class& operator=(imported_class&) = delete;
imported_class& operator=(imported_class&&) = default;
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();}
bool is_move_constructible() {return !_lib->symbol_storage().template get_constructor<T(T&&)> ().empty();}
bool is_move_assignable() {return !_lib->symbol_storage().template get_mem_fn<T, T&(T&&)> ("operator=").empty();}
bool is_copy_constructible() {return !_lib->symbol_storage().template get_constructor<T(const T&)>().empty();}
bool is_copy_assignable() {return !_lib->symbol_storage().template get_mem_fn<T, T&(const T&)>("operator=").empty();}
imported_class<T> copy();
imported_class<T> move();
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);
return detail::mem_fn_call_proxy<T, Signature>(_data.get(), name, _lib);
}
//overload for const/volatile functions.
/*! 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);
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)
@ -180,7 +229,7 @@ public:
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)
@ -194,10 +243,11 @@ public:
//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 boost::shared_ptr<smart_library>& lib, Args ... 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>();
constructor<T(Args...)> ctor = lib.get_constructor<T(Args...)>();
destructor<T> dtor = lib.get_destructor <T>();
if (!ctor.has_allocating() || !dtor.has_deleting())
{
boost::system::error_code ec;
@ -223,10 +273,10 @@ inline std::unique_ptr<T, detail::deleter<T>> imported_class<T>::make_data(const
//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 boost::shared_ptr<smart_library>& lib, std::size_t size, Args...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>();
constructor<T(Args...)> ctor = lib.get_constructor<T(Args...)>();
destructor<T> dtor = lib.get_destructor <T>();
if (!ctor.has_standard() || !dtor.has_standard())
{
@ -258,30 +308,54 @@ inline std::unique_ptr<T, detail::deleter<T>> imported_class<T>::make_data(const
template<typename T>
template<typename ...Args>
imported_class<T>::imported_class(detail::sequence<Args...> *, const boost::shared_ptr<smart_library> & lib, Args...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>())
_ti(lib.get_type_info<T>())
{
}
template<typename T>
template<typename ...Args>
imported_class<T>::imported_class(detail::sequence<Args...> *, const boost::shared_ptr<smart_library> & lib, std::size_t size, Args...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>())
_ti(lib.get_type_info<T>())
{
}
template<typename T>
inline imported_class<T> boost::dll::experimental::imported_class<T>::copy()
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);
@ -310,36 +384,170 @@ inline void boost::dll::experimental::imported_class<T>::move_assign(imported_cl
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 boost::system::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 boost::shared_ptr<smart_library>& lib, Args...args)
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(const boost::shared_ptr<smart_library>& lib, const std::string & alias_name, Args...args)
import_class(smart_library & lib, const std::string & alias_name, Args...args)
{
lib->add_type_alias<T>(alias_name);
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(const boost::shared_ptr<smart_library>& lib, std::size_t size, Args...args)
import_class(smart_library & lib, std::size_t size, Args...args)
{
return imported_class<T>::template make<Args...>(lib, size, static_cast<Args>(args)...);
}
template<typename T, typename ... Args> imported_class<T>
import_class(const boost::shared_ptr<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(const boost::shared_ptr<smart_library>& lib, const std::string & alias_name, std::size_t size, Args...args)
import_class(smart_library & lib, std::size_t size, const std::string & alias_name, Args...args)
{
lib->add_type_alias<T>(alias_name);
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)...);
}
}
}

39
include/boost/dll/import_mangled.hpp
View File

@ -37,7 +37,7 @@ class mangled_library_function {
boost::shared_ptr<function_tuple<Ts...>> f_;
public:
inline mangled_library_function(const boost::shared_ptr<smart_library>& lib, Ts*... func_ptr) BOOST_NOEXCEPT
inline mangled_library_function(const boost::shared_ptr<shared_library>& lib, Ts*... func_ptr) BOOST_NOEXCEPT
: f_(lib, new function_tuple<Ts...>(func_ptr...))
{}
@ -69,7 +69,7 @@ class mangled_library_mem_fn<Class, sequence<Ts...>> {
boost::shared_ptr<call_tuple_t> f_;
public:
inline mangled_library_mem_fn(const boost::shared_ptr<smart_library>& lib,
inline mangled_library_mem_fn(const boost::shared_ptr<shared_library>& lib,
typename Ts::mem_fn... func_ptr) BOOST_NOEXCEPT
: f_(lib, new call_tuple_t(func_ptr...))
{}
@ -99,10 +99,12 @@ struct mangled_import_type<sequence<Args...>, true,false,false> //is function
{
typedef boost::dll::experimental::detail::mangled_library_function<Args...> type;
static type make(
const boost::shared_ptr<boost::dll::experimental::smart_library>& p,
const boost::dll::experimental::smart_library& p,
const std::string& name)
{
return type(p, boost::addressof(p->get_function<Args>(name))...);
return type(
boost::make_shared<shared_library>(p.shared_lib()),
boost::addressof(p.get_function<Args>(name))...);
}
};
@ -115,15 +117,16 @@ struct mangled_import_type<sequence<Class, Args...>, false, true, false> //is me
template<class ... ArgsIn>
static type make_impl(
const boost::shared_ptr<boost::dll::experimental::smart_library>& p,
const boost::dll::experimental::smart_library& p,
const std::string & name,
sequence<ArgsIn...> * )
{
return type(p, p->get_mem_fn<typename ArgsIn::class_type, typename ArgsIn::func_type>(name)...);
return type(boost::make_shared<shared_library>(p.shared_lib()),
p.get_mem_fn<typename ArgsIn::class_type, typename ArgsIn::func_type>(name)...);
}
static type make(
const boost::shared_ptr<boost::dll::experimental::smart_library>& p,
const boost::dll::experimental::smart_library& p,
const std::string& name)
{
return make_impl(p, name, static_cast<actual_sequence*>(nullptr));
@ -137,10 +140,12 @@ struct mangled_import_type<sequence<T>, false, false, true> //is variable
typedef boost::shared_ptr<T> type;
static type make(
const boost::shared_ptr<boost::dll::experimental::smart_library>& p,
const boost::dll::experimental::smart_library& p,
const std::string& name)
{
return type(p, boost::addressof(p->get_variable<T>(name)));
return type(
boost::make_shared<shared_library>(p.shared_lib()),
boost::addressof(p.get_variable<T>(name)));
}
};
@ -219,8 +224,7 @@ BOOST_DLL_MANGLED_IMPORT_RESULT_TYPE import_mangled(const boost::filesystem::pat
typedef typename boost::dll::experimental::detail::mangled_import_type<
boost::dll::experimental::detail::sequence<Args...>> type;
boost::shared_ptr<boost::dll::experimental::smart_library> p =
boost::make_shared<boost::dll::experimental::smart_library>(lib, mode);
boost::dll::experimental::smart_library p(lib, mode);
//the load
return type::make(p, name);
}
@ -240,8 +244,7 @@ template <class ...Args>
BOOST_DLL_MANGLED_IMPORT_RESULT_TYPE import_mangled(const smart_library& lib, const char* name) {
typedef typename boost::dll::experimental::detail::mangled_import_type<detail::sequence<Args...>> type;
boost::shared_ptr<boost::dll::experimental::smart_library> p = boost::make_shared<boost::dll::experimental::smart_library>(lib);
return type::make(p, name);
return type::make(lib, name);
}
//! \overload boost::dll::import(const boost::filesystem::path& lib, const char* name, load_mode::type mode)
@ -255,10 +258,7 @@ template <class ...Args>
BOOST_DLL_MANGLED_IMPORT_RESULT_TYPE import_mangled(BOOST_RV_REF(smart_library) lib, const char* name) {
typedef typename boost::dll::experimental::detail::mangled_import_type<detail::sequence<Args...>> type;
boost::shared_ptr<boost::dll::experimental::smart_library> p = boost::make_shared<boost::dll::experimental::smart_library>(
boost::move(lib)
);
return type::make(p, name);
return type::make(lib, name);
}
//! \overload boost::dll::import(const boost::filesystem::path& lib, const char* name, load_mode::type mode)
@ -287,9 +287,8 @@ template <class ...Args>
BOOST_DLL_MANGLED_IMPORT_RESULT_TYPE import_mangled(BOOST_RV_REF(shared_library) lib, const char* name) {
typedef typename boost::dll::experimental::detail::mangled_import_type<detail::sequence<Args...>> type;
boost::shared_ptr<boost::dll::experimental::smart_library> p = boost::make_shared<boost::dll::experimental::smart_library>(
boost::move(lib)
);
boost::dll::experimental::smart_library p(boost::move(lib));
return type::make(p, name);
}

24
include/boost/dll/smart_library.hpp
View File

@ -125,7 +125,7 @@ public:
* \throw Nothing.
*/
smart_library(BOOST_RV_REF(smart_library) lib) BOOST_NOEXCEPT
: _lib(boost::move(static_cast<shared_library&>(lib._lib))), _storage(boost::move(lib._storage))
: _lib(boost::move(lib._lib)), _storage(boost::move(lib._storage))
{}
/*!
@ -202,7 +202,7 @@ public:
* \throw boost::system::system_error if symbol does not exist or if the DLL/DSO was not loaded.
*/
template<typename T>
T& get_variable(const std::string &name) {
T& get_variable(const std::string &name) const {
return _lib.get<T>(_storage.get_variable<T>(name));
}
@ -228,7 +228,7 @@ public:
* \throw boost::system::system_error if symbol does not exist or if the DLL/DSO was not loaded.
*/
template<typename Func>
Func& get_function(const std::string &name) {
Func& get_function(const std::string &name) const {
return _lib.get<Func>(_storage.get_function<Func>(name));
}
@ -257,9 +257,9 @@ public:
* \throw boost::system::system_error if symbol does not exist or if the DLL/DSO was not loaded.
*/
template<typename Class, typename Func>
typename boost::dll::detail::get_mem_fn_type<Class, Func>::mem_fn get_mem_fn(const std::string& name) {
typename boost::dll::detail::get_mem_fn_type<Class, Func>::mem_fn get_mem_fn(const std::string& name) const {
return _lib.get<typename boost::dll::detail::get_mem_fn_type<Class, Func>::mem_fn>(
_storage.get_mem_fn<Class, Func>(name)
_storage.get_mem_fn<Class, Func>(name)
);
}
@ -280,7 +280,7 @@ public:
* \throw boost::system::system_error if symbol does not exist or if the DLL/DSO was not loaded.
*/
template<typename Signature>
constructor<Signature> get_constructor() {
constructor<Signature> get_constructor() const {
return boost::dll::detail::load_ctor<Signature>(_lib, _storage.get_constructor<Signature>());
}
@ -302,7 +302,7 @@ public:
*
*/
template<typename Class>
destructor<Class> get_destructor() {
destructor<Class> get_destructor() const {
return boost::dll::detail::load_dtor<Class>(_lib, _storage.get_destructor<Class>());
}
/*!
@ -323,7 +323,7 @@ public:
*
*/
template<typename Class>
const std::type_info& get_type_info()
const std::type_info& get_type_info() const
{
return boost::dll::detail::load_type_info<Class>(_lib, _storage);
}
@ -432,24 +432,24 @@ inline void swap(smart_library& lhs, smart_library& rhs) BOOST_NOEXCEPT {
* @param name The name of the entity to import
*/
template<class T, class T2>
void get(smart_library& sm, const std::string &name);
void get(const smart_library& sm, const std::string &name);
#endif
template<class T>
T& get(smart_library& sm, const std::string &name, typename boost::enable_if<boost::is_object<T>,T>::type* = nullptr)
T& get(const smart_library& sm, const std::string &name, typename boost::enable_if<boost::is_object<T>,T>::type* = nullptr)
{
return sm.get_variable<T>(name);
}
template<class T>
auto get(smart_library& sm, const std::string &name, typename boost::enable_if<boost::is_function<T>>::type* = nullptr)
auto get(const smart_library& sm, const std::string &name, typename boost::enable_if<boost::is_function<T>>::type* = nullptr)
{
return sm.get_function<T>(name);
}
template<class Class, class Signature>
auto get(smart_library& sm, const std::string &name) -> typename detail::get_mem_fn_type<Class, Signature>::mem_fn
auto get(const smart_library& sm, const std::string &name) -> typename detail::get_mem_fn_type<Class, Signature>::mem_fn
{
return sm.get_mem_fn<Class, Signature>(name);
}

41
test/cpp_import_class_test.cpp
View File

@ -6,6 +6,7 @@
// For more information, see http://www.boost.org
#include <boost/predef.h>
#if (__cplusplus >= 201402L) || (BOOST_COMP_MSVC >= BOOST_VERSION_NUMBER(14,0,0))
@ -25,22 +26,23 @@ using namespace std;
#include <boost/variant.hpp>
#include <boost/function.hpp>
#define L cout << __LINE__ << endl;
int main(int argc, char* argv[])
{
using namespace boost::dll;
using namespace boost::dll::experimental;
using namespace boost::dll;
using namespace boost::dll::experimental;
boost::filesystem::path pt = b2_workarounds::first_lib_from_argv(argc, argv);
BOOST_TEST(!pt.empty());
std::cout << "Library: " << pt << std::endl;
boost::shared_ptr<smart_library> sm = boost::make_shared<smart_library>(pt);
smart_library sm(pt);
auto static_val = import_mangled<int>(sm, "some_space::some_class::value");
std::cout << "--------------------- Entry Points ------------------------\n" << std::endl;
for (auto &s : sm->symbol_storage().get_storage())
for (auto &s : sm.symbol_storage().get_storage())
std::cout << s.demangled << std::endl;
std::cout << "-----------------------------------------------------------\n\n" << std::endl;
@ -52,31 +54,30 @@ int main(int argc, char* argv[])
auto unscoped_var = import_mangled<int>(sm, "unscoped_var");
std::size_t type_size = *import_mangled<std::size_t>(sm, "some_space::size_of_some_class");
{
#if defined(BOOST_MSVC) || defined(BOOST_MSVC_FULL_VER)
class override_class{};
auto cl = import_class<override_class, int>(sm, "some_space::some_class", type_size, 42);
class override_class{};
auto cl = import_class<override_class, int>(sm, "some_space::some_class", type_size, 42);
#else
auto cl = import_class<class override_class, int>(sm, "some_space::some_class", type_size, 42);
auto cl = import_class<class override_class, int>(sm, "some_space::some_class", type_size, 42);
#endif
BOOST_TEST(!cl.is_copy_assignable());
BOOST_TEST(!cl.is_copy_constructible());
BOOST_TEST(!cl.is_copy_assignable());
BOOST_TEST(!cl.is_copy_constructible());
BOOST_TEST( cl.is_move_assignable());
BOOST_TEST( cl.is_move_constructible());
BOOST_TEST( cl.is_move_assignable());
BOOST_TEST( cl.is_move_constructible());
BOOST_TEST(*static_val == 42);
BOOST_TEST(*static_val == 42);
auto i = cl.call<const override_class, int()>("get")();
BOOST_TEST(i == 456);
cl.call<void(int)>("set")(42);
i = 0;
i = cl.call<const override_class, int()>("get")();
BOOST_TEST(i == 42);
auto i = cl.call<const override_class, int()>("get")();
BOOST_TEST(i == 456);
cl.call<void(int)>("set")(42);
i = 0;
i = cl.call<const override_class, int()>("get")();
BOOST_TEST(i == 42);
auto func = import_mangled<
auto func = import_mangled<
override_class, double(double, double), int(int, int),
volatile override_class, int(int, int),
const volatile override_class, double(double, double)>(sm, "func");

4
test/cpp_import_test.cpp
View File

@ -30,8 +30,8 @@ struct override_class
int main(int argc, char* argv[])
{
using namespace boost::dll;
using namespace boost::dll::experimental;
using namespace boost::dll;
using namespace boost::dll::experimental;
boost::filesystem::path pt = b2_workarounds::first_lib_from_argv(argc, argv);
BOOST_TEST(!pt.empty());