ceph/src/boost/libs/dll/include/boost/dll/import_class.hpp

   1 // Copyright 2015-2016 Klemens D. Morgenstern
   2 //
   3 // Distributed under the Boost Software License, Version 1.0.
   4 // (See accompanying file LICENSE_1_0.txt
   5 // or copy at http://www.boost.org/LICENSE_1_0.txt)
   6
   7 #ifndef BOOST_DLL_IMPORT_CLASS_HPP_
   8 #define BOOST_DLL_IMPORT_CLASS_HPP_
   9
  10 #include <boost/dll/smart_library.hpp>
  11 #include <boost/dll/import_mangled.hpp>
  12 #include <memory>
  13
  14 #ifdef BOOST_HAS_PRAGMA_ONCE
  15 # pragma once
  16 #endif
  17
  18 namespace boost { namespace dll { namespace experimental {
  19
  20 namespace detail
  21 {
  22
  23 template<typename T>
  24 struct deleter
  25 {
  26     destructor<T> dtor;
  27     bool use_deleting;
  28
  29     deleter(const destructor<T> & dtor, bool use_deleting = false) :
  30         dtor(dtor), use_deleting(use_deleting) {}
  31
  32     void operator()(T*t)
  33     {
  34         if (use_deleting)
  35             dtor.call_deleting(t);
  36         else
  37         {
  38             dtor.call_standard(t);
  39             //the thing is actually an array, so delete[]
  40             auto p = reinterpret_cast<char*>(t);
  41             delete [] p;
  42         }
  43     }
  44 };
  45
  46 template<class T, class = void>
  47 struct mem_fn_call_proxy;
  48
  49 template<class Class, class U>
  50 struct mem_fn_call_proxy<Class, boost::dll::experimental::detail::mangled_library_mem_fn<Class, U>>
  51 {
  52     typedef boost::dll::experimental::detail::mangled_library_mem_fn<Class, U> mem_fn_t;
  53     Class* t;
  54     mem_fn_t & mem_fn;
  55
  56     mem_fn_call_proxy(mem_fn_call_proxy&&) = default;
  57     mem_fn_call_proxy(const mem_fn_call_proxy & ) = delete;
  58     mem_fn_call_proxy(Class * t, mem_fn_t & mem_fn)
  59                 : t(t), mem_fn(mem_fn) {}
  60
  61     template<typename ...Args>
  62     auto operator()(Args&&...args) const
  63     {
  64         return mem_fn(t, std::forward<Args>(args)...);
  65     }
  66
  67 };
  68
  69 template<class T, class Return, class ...Args>
  70 struct mem_fn_call_proxy<T, Return(Args...)>
  71 {
  72     T* t;
  73     const std::string &name;
  74     smart_library &_lib;
  75
  76     mem_fn_call_proxy(mem_fn_call_proxy&&) = default;
  77     mem_fn_call_proxy(const mem_fn_call_proxy&) = delete;
  78     mem_fn_call_proxy(T *t, const std::string &name, smart_library & _lib)
  79         : t(t), name(name), _lib(_lib) {};
  80
  81     Return operator()(Args...args) const
  82     {
  83         auto f = _lib.get_mem_fn<T, Return(Args...)>(name);
  84         return (t->*f)(static_cast<Args>(args)...);
  85     }
  86 };
  87
  88 }
  89
  90 template<typename T>
  91 class imported_class;
  92
  93 template<typename T, typename ... Args> imported_class<T>
  94 import_class(const smart_library& lib, Args...args);
  95 template<typename T, typename ... Args> imported_class<T>
  96 import_class(const smart_library& lib, const std::string & alias_name, Args...args);
  97 template<typename T, typename ... Args> imported_class<T>
  98 import_class(const smart_library& lib, std::size_t size, Args...args);
  99 template<typename T, typename ... Args> imported_class<T>
 100 import_class(const smart_library& lib, std::size_t size,
 101              const std::string & alias_name, Args...args);
 102
 103
 104 /*! This class represents an imported class.
 105  *
 106  * \note It must be constructed via \ref boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 107  *
 108  * \tparam The type or type-alias of the imported class.
 109  */
 110 template<typename T>
 111 class imported_class
 112 {
 113     smart_library _lib;
 114     std::unique_ptr<T, detail::deleter<T>> _data;
 115     bool _is_allocating;
 116     std::size_t _size;
 117     const std::type_info& _ti;
 118
 119     template<typename ... Args>
 120     inline std::unique_ptr<T, detail::deleter<T>> make_data(const smart_library& lib, Args ... args);
 121     template<typename ... Args>
 122     inline std::unique_ptr<T, detail::deleter<T>> make_data(const smart_library& lib, std::size_t size, Args...args);
 123
 124     template<typename ...Args>
 125     imported_class(detail::sequence<Args...> *, const smart_library& lib,  Args...args);
 126
 127     template<typename ...Args>
 128     imported_class(detail::sequence<Args...> *, const smart_library& lib, std::size_t size,  Args...args);
 129
 130     template<typename ...Args>
 131     imported_class(detail::sequence<Args...> *, smart_library&& lib,  Args...args);
 132
 133     template<typename ...Args>
 134     imported_class(detail::sequence<Args...> *, smart_library&& lib, std::size_t size,  Args...args);
 135 public:
 136     //alias to construct with explicit parameter list
 137     template<typename ...Args>
 138     static imported_class<T> make(smart_library&& lib,  Args...args)
 139     {
 140         typedef detail::sequence<Args...> *seq;
 141         return imported_class(seq(), boost::move(lib), static_cast<Args>(args)...);
 142     }
 143
 144     template<typename ...Args>
 145     static imported_class<T> make(smart_library&& lib, std::size_t size,  Args...args)
 146     {
 147         typedef detail::sequence<Args...> *seq;
 148         return imported_class(seq(), boost::move(lib), size, static_cast<Args>(args)...);
 149     }
 150     template<typename ...Args>
 151     static imported_class<T> make(const smart_library& lib,  Args...args)
 152     {
 153         typedef detail::sequence<Args...> *seq;
 154         return imported_class(seq(), lib, static_cast<Args>(args)...);
 155     }
 156
 157     template<typename ...Args>
 158     static imported_class<T> make(const smart_library& lib, std::size_t size,  Args...args)
 159     {
 160         typedef detail::sequence<Args...> *seq;
 161         return imported_class(seq(), lib, size, static_cast<Args>(args)...);
 162     }
 163
 164     typedef imported_class<T> base_t;
 165     ///Returns a pointer to the underlying class
 166     T* get() {return _data.get();}
 167     imported_class() = delete;
 168
 169     imported_class(imported_class&) = delete;
 170     imported_class(imported_class&&) = default;                ///<Move constructor
 171     imported_class& operator=(imported_class&) = delete;
 172     imported_class& operator=(imported_class&&) = default;  ///<Move assignmend
 173
 174     ///Check if the imported class is move-constructible
 175     bool is_move_constructible() {return !_lib.symbol_storage().template get_constructor<T(T&&)>     ().empty();}
 176     ///Check if the imported class is move-assignable
 177     bool is_move_assignable()    {return !_lib.symbol_storage().template get_mem_fn<T, T&(T&&)>     ("operator=").empty();}
 178     ///Check if the imported class is copy-constructible
 179     bool is_copy_constructible() {return !_lib.symbol_storage().template get_constructor<T(const T&)>().empty();}
 180     ///Check if the imported class is copy-assignable
 181     bool is_copy_assignable()    {return !_lib.symbol_storage().template get_mem_fn<T, T&(const T&)>("operator=").empty();}
 182
 183     imported_class<T> copy() const; ///<Invoke the copy constructor. \attention Undefined behaviour if the imported object is not copy constructible.
 184     imported_class<T> move();       ///<Invoke the move constructor. \attention Undefined behaviour if the imported object is not move constructible.
 185
 186     ///Invoke the copy assignment. \attention Undefined behaviour if the imported object is not copy assignable.
 187     void copy_assign(const imported_class<T> & lhs) const;
 188     ///Invoke the move assignment. \attention Undefined behaviour if the imported object is not move assignable.
 189     void move_assign(      imported_class<T> & lhs);
 190
 191     ///Check if the class is loaded.
 192     explicit operator bool() const  {return _data;}
 193
 194     ///Get a const reference to the std::type_info.
 195     const std::type_info& get_type_info() {return _ti;};
 196
 197     /*! Call a member function. This returns a proxy to the function.
 198      * The proxy mechanic mechanic is necessary, so the signaute can be passed.
 199      *
 200      * \b Example
 201      *
 202      * \code
 203      * im_class.call<void(const char*)>("function_name")("MyString");
 204      * \endcode
 205      */
 206     template<class Signature>
 207     const detail::mem_fn_call_proxy<T, Signature> call(const std::string& name)
 208     {
 209         return detail::mem_fn_call_proxy<T, Signature>(_data.get(), name, _lib);
 210     }
 211     /*! Call a qualified member function, i.e. const and or volatile.
 212      *
 213      * \b Example
 214      *
 215      * \code
 216      * im_class.call<const type_alias, void(const char*)>("function_name")("MyString");
 217      * \endcode
 218      */
 219     template<class Tin, class Signature, class = boost::enable_if<detail::unqalified_is_same<T, Tin>>>
 220     const detail::mem_fn_call_proxy<Tin, Signature> call(const std::string& name)
 221     {
 222         return detail::mem_fn_call_proxy<Tin, Signature>(_data.get(), name, _lib);
 223     }
 224     ///Overload of ->* for an imported method.
 225     template<class Tin, class T2>
 226     const detail::mem_fn_call_proxy<Tin, boost::dll::experimental::detail::mangled_library_mem_fn<Tin, T2>>
 227             operator->*(detail::mangled_library_mem_fn<Tin, T2>& mn)
 228     {
 229         return detail::mem_fn_call_proxy<Tin, boost::dll::experimental::detail::mangled_library_mem_fn<Tin, T2>>(_data.get(), mn);
 230     }
 231
 232     ///Import a method of the class.
 233     template <class ...Args>
 234     typename boost::dll::experimental::detail::mangled_import_type<boost::dll::experimental::detail::sequence<T, Args...>>::type
 235     import(const std::string & name)
 236     {
 237         return boost::dll::experimental::import_mangled<T, Args...>(_lib, name);
 238     }
 239 };
 240
 241
 242
 243 //helper function, uses the allocating
 244 template<typename T>
 245 template<typename ... Args>
 246 inline std::unique_ptr<T, detail::deleter<T>> imported_class<T>::make_data(const smart_library& lib, Args ... args)
 247 {
 248     constructor<T(Args...)> ctor = lib.get_constructor<T(Args...)>();
 249     destructor<T>           dtor = lib.get_destructor <T>();
 250
 251     if (!ctor.has_allocating() || !dtor.has_deleting())
 252     {
 253         boost::system::error_code ec;
 254
 255         ec = boost::system::error_code(
 256             boost::system::errc::bad_file_descriptor,
 257             boost::system::generic_category()
 258         );
 259
 260         // report_error() calls dlsym, do not use it here!
 261         boost::throw_exception(
 262             boost::system::system_error(
 263                 ec, "boost::dll::detail::make_data() failed: no allocating ctor or dtor was found"
 264             )
 265         );
 266     }
 267
 268      return std::unique_ptr<T, detail::deleter<T>> (
 269             ctor.call_allocating(static_cast<Args>(args)...),
 270             detail::deleter<T>(dtor, false /* not deleting dtor*/));
 271 }
 272
 273 //helper function, using the standard
 274 template<typename T>
 275 template<typename ... Args>
 276 inline std::unique_ptr<T, detail::deleter<T>> imported_class<T>::make_data(const smart_library& lib, std::size_t size, Args...args)
 277 {
 278     constructor<T(Args...)> ctor = lib.get_constructor<T(Args...)>();
 279     destructor<T>           dtor = lib.get_destructor <T>();
 280
 281     if (!ctor.has_standard() || !dtor.has_standard())
 282     {
 283         boost::system::error_code ec;
 284
 285         ec = boost::system::error_code(
 286             boost::system::errc::bad_file_descriptor,
 287             boost::system::generic_category()
 288         );
 289
 290         // report_error() calls dlsym, do not use it here!
 291         boost::throw_exception(
 292             boost::system::system_error(
 293                 ec, "boost::dll::detail::make_data() failed: no regular ctor or dtor was found"
 294             )
 295         );
 296     }
 297
 298     T *data = reinterpret_cast<T*>(new char[size]);
 299
 300     ctor.call_standard(data, static_cast<Args>(args)...);
 301
 302     return std::unique_ptr<T, detail::deleter<T>> (
 303             reinterpret_cast<T*>(data),
 304             detail::deleter<T>(dtor, false /* not deleting dtor*/));
 305
 306 }
 307
 308
 309 template<typename T>
 310 template<typename ...Args>
 311 imported_class<T>::imported_class(detail::sequence<Args...> *, const smart_library & lib,  Args...args)
 312     : _lib(lib),
 313       _data(make_data<Args...>(lib, static_cast<Args>(args)...)),
 314       _is_allocating(false),
 315       _size(0),
 316       _ti(lib.get_type_info<T>())
 317 {
 318
 319 }
 320
 321 template<typename T>
 322 template<typename ...Args>
 323 imported_class<T>::imported_class(detail::sequence<Args...> *, const smart_library & lib, std::size_t size,  Args...args)
 324     : _lib(lib),
 325       _data(make_data<Args...>(lib, size, static_cast<Args>(args)...)),
 326       _is_allocating(true),
 327       _size(size),
 328       _ti(lib.get_type_info<T>())
 329 {
 330
 331 }
 332
 333 template<typename T>
 334 template<typename ...Args>
 335 imported_class<T>::imported_class(detail::sequence<Args...> *, smart_library && lib,  Args...args)
 336     : _lib(boost::move(lib)),
 337       _data(make_data<Args...>(lib, static_cast<Args>(args)...)),
 338       _is_allocating(false),
 339       _size(0),
 340       _ti(lib.get_type_info<T>())
 341 {
 342
 343 }
 344
 345 template<typename T>
 346 template<typename ...Args>
 347 imported_class<T>::imported_class(detail::sequence<Args...> *, smart_library && lib, std::size_t size,  Args...args)
 348     : _lib(boost::move(lib)),
 349       _data(make_data<Args...>(lib, size, static_cast<Args>(args)...)),
 350       _is_allocating(true),
 351       _size(size),
 352       _ti(lib.get_type_info<T>())
 353 {
 354
 355 }
 356
 357 template<typename T>
 358 inline imported_class<T> boost::dll::experimental::imported_class<T>::copy() const
 359 {
 360     if (this->_is_allocating)
 361         return imported_class<T>::template make<const T&>(_lib, *_data);
 362     else
 363         return imported_class<T>::template make<const T&>(_lib, _size, *_data);
 364 }
 365
 366 template<typename T>
 367 inline imported_class<T> boost::dll::experimental::imported_class<T>::move()
 368 {
 369     if (this->_is_allocating)
 370         return imported_class<T>::template make<T&&>(_lib, *_data);
 371     else
 372         return imported_class<T>::template make<T&&>(_lib, _size, *_data);
 373 }
 374
 375 template<typename T>
 376 inline void boost::dll::experimental::imported_class<T>::copy_assign(const imported_class<T>& lhs) const
 377 {
 378     this->call<T&(const T&)>("operator=")(*lhs._data);
 379 }
 380
 381 template<typename T>
 382 inline void boost::dll::experimental::imported_class<T>::move_assign(imported_class<T>& lhs)
 383 {
 384     this->call<T&(T&&)>("operator=")(static_cast<T&&>(*lhs._data));
 385 }
 386
 387
 388
 389 /*!
 390 * Returns an instance of \ref imported_class which allows to call or import more functions.
 391 * It takes a copy of the smart_libray, so no added type_aliases will be visible,
 392 * for the object.
 393 *
 394 * Few compilers do implement an allocating constructor, which allows the construction
 395 * of the class without knowing the size. That is not portable, so the actual size of the class
 396 * shall always be provided.
 397 *
 398 * \b Example:
 399 *
 400 * \code
 401 * auto import_class<class type_alias, const std::string&, std::size_t>(lib, "class_name", 20, "param1", 42);
 402 * \endcode
 403 *
 404 * In this example we construct an instance of the class "class_name" with the size 20, which has "type_alias" as an alias,
 405 * through a constructor which takes a const-ref of std::string and an std::size_t parameter.
 406 *
 407 * \tparam T Class type or alias
 408 * \tparam Args Constructor argument list.
 409 * \param lib Path to shared library or shared library to load function from.
 410 * \param name Null-terminated C or C++ mangled name of the function to import. Can handle std::string, char*, const char*.
 411 * \param mode An mode that will be used on library load.
 412 *
 413 * \return class object.
 414 *
 415 * \throw boost::system::system_error if symbol does not exist or if the DLL/DSO was not loaded.
 416 *       Overload that accepts path also throws std::bad_alloc in case of insufficient memory.
 417 */
 418 template<typename T, typename ... Args> imported_class<T>
 419 import_class(const smart_library& lib_, std::size_t size, Args...args)
 420 {
 421     smart_library lib(lib_);
 422
 423     return imported_class<T>::template make<Args...>(boost::move(lib), size, static_cast<Args>(args)...);
 424 }
 425
 426 //! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 427 template<typename T, typename ... Args> imported_class<T>
 428 import_class(const smart_library& lib_, Args...args)
 429 {
 430     smart_library lib(lib_);
 431     return imported_class<T>::template make<Args...>(boost::move(lib), static_cast<Args>(args)...);
 432 }
 433
 434 //! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 435 template<typename T, typename ... Args> imported_class<T>
 436 import_class(const smart_library& lib_, const std::string & alias_name, Args...args)
 437 {
 438     smart_library lib(lib_);
 439     lib.add_type_alias<T>(alias_name);
 440     return imported_class<T>::template make<Args...>(boost::move(lib), static_cast<Args>(args)...);
 441 }
 442
 443 //! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 444 template<typename T, typename ... Args> imported_class<T>
 445 import_class(const smart_library& lib_, std::size_t size, const std::string & alias_name, Args...args)
 446 {
 447     smart_library lib(lib_);
 448
 449     lib.add_type_alias<T>(alias_name);
 450     return imported_class<T>::template make<Args...>(boost::move(lib), size, static_cast<Args>(args)...);
 451 }
 452
 453 //! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 454 template<typename T, typename ... Args> imported_class<T>
 455 import_class(const smart_library& lib_, const std::string & alias_name, std::size_t size, Args...args)
 456 {
 457     smart_library lib(lib_);
 458
 459     lib.add_type_alias<T>(alias_name);
 460     return imported_class<T>::template make<Args...>(boost::move(lib), size, static_cast<Args>(args)...);
 461 }
 462
 463 //! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 464 template<typename T, typename ... Args> imported_class<T>
 465 import_class(smart_library && lib, Args...args)
 466 {
 467     return imported_class<T>::template make<Args...>(boost::move(lib), static_cast<Args>(args)...);
 468 }
 469
 470 //! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 471 template<typename T, typename ... Args> imported_class<T>
 472 import_class(smart_library && lib, const std::string & alias_name, Args...args)
 473 {
 474     lib.add_type_alias<T>(alias_name);
 475     return imported_class<T>::template make<Args...>(boost::move(lib), static_cast<Args>(args)...);
 476 }
 477
 478 //! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 479 template<typename T, typename ... Args> imported_class<T>
 480 import_class(smart_library && lib, std::size_t size, Args...args)
 481 {
 482     return imported_class<T>::template make<Args...>(boost::move(lib), size, static_cast<Args>(args)...);
 483 }
 484
 485 //! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 486 template<typename T, typename ... Args> imported_class<T>
 487 import_class(smart_library && lib, std::size_t size, const std::string & alias_name, Args...args)
 488 {
 489     lib.add_type_alias<T>(alias_name);
 490     return imported_class<T>::template make<Args...>(boost::move(lib), size, static_cast<Args>(args)...);
 491 }
 492
 493 //! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 494 template<typename T, typename ... Args> imported_class<T>
 495 import_class(smart_library && lib, const std::string & alias_name, std::size_t size, Args...args)
 496 {
 497     lib.add_type_alias<T>(alias_name);
 498     return imported_class<T>::template make<Args...>(boost::move(lib), size, static_cast<Args>(args)...);
 499 }
 500
 501
 502
 503 /*! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 504  * \note This function does add the type alias to the \ref boost::dll::experimental::smart_library.
 505  */
 506
 507 template<typename T, typename ... Args> imported_class<T>
 508 import_class(smart_library & lib, Args...args)
 509 {
 510     return imported_class<T>::template make<Args...>(lib, static_cast<Args>(args)...);
 511 }
 512
 513 /*! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 514  * \note This function does add the type alias to the \ref boost::dll::experimental::smart_library.
 515  */
 516 template<typename T, typename ... Args> imported_class<T>
 517 import_class(smart_library & lib, const std::string & alias_name, Args...args)
 518 {
 519     lib.add_type_alias<T>(alias_name);
 520     return imported_class<T>::template make<Args...>(lib, static_cast<Args>(args)...);
 521 }
 522
 523 /*! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 524  * \note This function does add the type alias to the \ref boost::dll::experimental::smart_library.
 525  */
 526 template<typename T, typename ... Args> imported_class<T>
 527 import_class(smart_library & lib, std::size_t size, Args...args)
 528 {
 529     return imported_class<T>::template make<Args...>(lib, size, static_cast<Args>(args)...);
 530 }
 531
 532 /*! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 533  * \note This function does add the type alias to the \ref boost::dll::experimental::smart_library.
 534  */
 535 template<typename T, typename ... Args> imported_class<T>
 536 import_class(smart_library & lib, std::size_t size, const std::string & alias_name, Args...args)
 537 {
 538     lib.add_type_alias<T>(alias_name);
 539     return imported_class<T>::template make<Args...>(lib, size, static_cast<Args>(args)...);
 540 }
 541
 542 /*! \overload boost::dll::import_class(const smart_library& lib, std::size_t, Args...)
 543  * \note This function does add the type alias to the \ref boost::dll::experimental::smart_library.
 544  */
 545 template<typename T, typename ... Args> imported_class<T>
 546 import_class(smart_library & lib, const std::string & alias_name, std::size_t size, Args...args)
 547 {
 548     lib.add_type_alias<T>(alias_name);
 549     return imported_class<T>::template make<Args...>(lib, size, static_cast<Args>(args)...);
 550 }
 551
 552 }
 553 }
 554 }
 555
 556
 557
 558 #endif /* BOOST_DLL_IMPORT_CLASS_HPP_ */