C++ Dependency injection with Dynamic library loading

Question

I am unable to use C++ dependency injection library " boost::di " with another boost library for dynamic loading of libraries named " Boost.dll ".

I broke down the problem into two parts - firstly, Testing dynamic loading, and secondly, binding the abstract class to implementation (which is loaded dynamically).

I am able to successfully load the libraries dynamically. But when I am trying to use Dependency injection binding then It is reporting the mismatch that class template is expected and not received.

I have a very basic sample code in this repo:https://bitbucket.org/kobe_la/boost-plugins-prework/src/master/

I would really use some help in figuring out the binding process for dynamically loaded library. (see exact error at bottom)

• File ioperation.hpp

   #include <string> class ioperation { public: virtual std::string name() const = 0; virtual float calculate(float x, float y) = 0; virtual ~ioperation() {} };

• File sum.cpp

   #include <boost/config.hpp> #include <boost/dll/alias.hpp> #include <boost/dll/import.hpp> #include "ioperation.hpp" #include <iostream> namespace sum_namespace { class sum: public ioperation { public: sum() { std::cout << "[sum_constructor]" << std::endl; } std::string name() const { return "sum"; } float calculate(float x, float y) { return x + y; } ~sum() { std::cout << "[~sum_destructor]" << std::endl; } // Factory method static boost::shared_ptr<sum> create_sum() { return boost::shared_ptr<sum>( new sum() ); } }; } BOOST_DLL_ALIAS( sum_namespace::sum::create_sum, // <-- this function is exported with... create_sum // <-- ...this alias name )

• File dot_product.cpp

   #include <boost/config.hpp> #include <boost/dll/alias.hpp> #include <boost/dll/import.hpp> #include <iostream> #include "ioperation.hpp" namespace dot_product_namespace { class dot_product: public ioperation { boost::shared_ptr<ioperation> sum_ptr; public: dot_product(boost::shared_ptr<ioperation> &arg) { sum_ptr = arg; std::cout << "[dot_product_constructor]" << std::endl; } std::string name() const { return "dot_product"; } float calculate(float a1, float a2) { //dot product given vector with itself //formula: ab = a1*b1 + a2*b2 return sum_ptr->calculate(a1*a1, a2*a2); } // Factory method static boost::shared_ptr<ioperation> create_dot_product(boost::shared_ptr<ioperation> sum_ptr) { return boost::shared_ptr<ioperation>( new dot_product(sum_ptr) ); } ~dot_product() { std::cout << "[~dot_product_destructor]" << std::endl; } }; }; BOOST_DLL_ALIAS( dot_product_namespace::dot_product::create_dot_product, // <-- this function is exported with... create_dot_product // <-- ...this alias name )

• File application_di.cpp

   #include "boost/shared_ptr.hpp" #include <boost/dll/import.hpp> #include "boost/function.hpp" #include <boost/di.hpp> #include "ioperation.hpp" #include <iostream> namespace di = boost::di; namespace dll = boost::dll; class app { private: boost::shared_ptr<ioperation> ptr_; public: app(boost::shared_ptr<ioperation> ptr) : ptr_(ptr) { std::cout<<"name: " << ptr_->name()<<std::endl; } }; int main(int argc, char* argv[]) { //setting up paths to library(.so) files boost::filesystem::path shared_library_path("."); // argv[1] contains path to directory with our plugin library boost::filesystem::path child_library_path = shared_library_path/"dot_product"; boost::filesystem::path parent_library_path = shared_library_path/"sum"; //defining function types for lib constructors typedef boost::shared_ptr<ioperation> (sum_create_t)(); typedef boost::shared_ptr<ioperation> (dot_product_create_t)(boost::shared_ptr<ioperation>); boost::function<sum_create_t> sum_creator; boost::function<dot_product_create_t> dot_product_creator; //importing SUM lib constructor(takes no arg) sum_creator = boost::dll::import_alias<sum_create_t>( // type of imported symbol must be explicitly specified parent_library_path, // path to library "create_sum", // symbol to import dll::load_mode::append_decorations // do append extensions and prefixes ); //importing DOT_PRODUCT lib constructor(takes 1 arg of ptr to IOPERATION) dot_product_creator = boost::dll::import_alias<dot_product_create_t>( // type of imported symbol must be explicitly specified child_library_path, // path to library "create_dot_product", // symbol to import dll::load_mode::append_decorations // do append extensions and prefixes ); //creating a ptr to SUM object boost::shared_ptr<ioperation> sum_ptr = sum_creator(); //creating a ptr to DOT_PRODUCT object(passing above created SUM object ptr) boost::shared_ptr<ioperation> dot_product_ptr = dot_product_creator(sum_ptr); auto use_sum = true; const auto injector = di::make_injector( di::bind<ioperation>().to([&](const auto& injector) -> boost::shared_ptr<ioperation> { if (use_sum) return injector.template create<boost::shared_ptr<sum_ptr>>(); else return injector.template create<boost::shared_ptr<dot_product_ptr>>(); }) ); injector.create<app>(); }

• File application_main.cpp

   #include "boost/shared_ptr.hpp" #include <boost/dll/import.hpp> #include "boost/function.hpp" #include <iostream> #include "ioperation.hpp" namespace dll = boost::dll; int main(int argc, char* argv[]) { //setting up paths to library(.so) files boost::filesystem::path shared_library_path(argv[1]); // argv[1] contains path to directory with our plugin library boost::filesystem::path child_library_path = shared_library_path/"dot_product"; boost::filesystem::path parent_library_path = shared_library_path/"sum"; //defining function types for lib constructors typedef boost::shared_ptr<ioperation> (sum_create_t)(); typedef boost::shared_ptr<ioperation> (dot_product_create_t)(boost::shared_ptr<ioperation>); boost::function<sum_create_t> sum_creator; boost::function<dot_product_create_t> dot_product_creator; //importing SUM lib constructor(takes no arg) sum_creator = boost::dll::import_alias<sum_create_t>( // type of imported symbol must be explicitly specified parent_library_path, // path to library "create_sum", // symbol to import dll::load_mode::append_decorations // do append extensions and prefixes ); //importing DOT_PRODUCT lib constructor(takes 1 arg of ptr to IOPERATION) dot_product_creator = boost::dll::import_alias<dot_product_create_t>( // type of imported symbol must be explicitly specified child_library_path, // path to library "create_dot_product", // symbol to import dll::load_mode::append_decorations // do append extensions and prefixes ); //creating a ptr to PARENT_PLUGIN_SUM objecti boost::shared_ptr<ioperation> sum_ptr = sum_creator(); //creating a ptr to CHILD_PLUGIN_MULT object(passing above created PARENT_PLUGIN_SUM object ptr) boost::shared_ptr<ioperation> dot_product_ptr = dot_product_creator(sum_ptr); //executing calculate methods for object ptrs std::cout << "Plugin Name: " << sum_ptr->name() << std::endl; std::cout << "sum_ptr->calculate(1, 2)[expected=3]: " << sum_ptr->calculate(1, 2) << std::endl; std::cout << "Plugin Name: " << dot_product_ptr->name() << std::endl; std::cout << "dot_product_ptr->calculate(1, 2)[expected=5]: " << dot_product_ptr->calculate(1, 2) << std::endl; }

---

Below is the exact error observed:

    + echo '=> Compiling libraries and application_main.cpp ...'
    => Compiling libraries and application_main.cpp ...

    + g++ -std=c++14 -fPIC -c -o libsum.o sum.cpp
    + g++ -shared -o libsum.so libsum.o
    + g++ -std=c++14 -fPIC -c -o libdot_product.o dot_product.cpp
    + g++ -shared -o libdot_product.so libdot_product.o
    + g++ -std=c++14 -lboost_filesystem -lboost_system -ldl application_main.cpp -o application_main
    + echo '=> Compilation completed. '
    => Compilation completed. 

    + echo '=> Executing ./application_main .'
    => Executing ./application_main .

    + ./application_main .
    [sum_constructor]
    [dot_product_constructor]
    Plugin Name: sum
    sum_ptr->calculate(1, 2)[expected=3]: 3
    Plugin Name: dot_product
    dot_product_ptr->calculate(1, 2)[expected=5]: 5
    [~dot_product_destructor]
    [~sum_destructor]
    + echo ==================================
    ==================================
    + echo '=> Compiling application_di.cpp ...'

    => Compiling application_di.cpp …
    + g++ application_di.cpp -lboost_filesystem -lboost_system -ldl -o application_di
    application_di.cpp: In lambda function:
    application_di.cpp:62:65: error: type/value mismatch at argument 1 in template parameter list for ‘template<class T> class boost::shared_ptr’
        62 |               return injector.template create<boost::shared_ptr<sum_ptr>>();
            |                                                                 ^~~~~~~
    application_di.cpp:62:65: note:   expected a type, got ‘sum_ptr’
    application_di.cpp:64:65: error: type/value mismatch at argument 1 in template parameter list for ‘template<class T> class boost::shared_ptr’
        64 |               return injector.template create<boost::shared_ptr<dot_product_ptr>>();
            |                                                                 ^~~~~~~~~~~~~~~
    application_di.cpp:64:65: note:   expected a type, got ‘dot_product_ptr’

---

Answer 1

Shared pointer is the problem. The bind<> template argument cannot be a pointer or reference type

There's some information about why pointers are disallowed in bind<> : https://github.com/boost-ext/di/issues/317

I figured out a working way to bind the dependency:

const auto injector =
    di::make_injector(di::bind<ioperation>().to(
        [=, &use_sum](const auto& injector) -> op_ptr
        {
            return use_sum
                ? sum_creator()
                : dot_product_creator(sum_creator());
        }) //
    );

Note that capturing the factory functions by value keeps the DLL around as long as the injector exists. This is safer than capturing by reference. Capturing the use_sum by reference highlights that the injector is dynamic. If that's not required, then I'd replace the whole injector with:

 const auto injector = di::make_injector(di::bind<ioperation>().to( use_sum ? sum_creator() : dot_product_creator(sum_creator())) // );

Full Demo

See also Github: https://github.com/sehe/boost-plugins-prework

• File ioperation.hpp

   #pragma once #include <boost/shared_ptr.hpp> #include <string> struct ioperation { virtual std::string name() const = 0; virtual float calculate(float x, float y) = 0; virtual ~ioperation() = default; }; using op_ptr = boost::shared_ptr<ioperation>;

• File sum.cpp

   #include <boost/config.hpp> #include <boost/dll/alias.hpp> #include <boost/dll/import.hpp> #include "ioperation.hpp" #include <iostream> namespace sum_namespace { class sum : public ioperation { public: sum() { std::cout << "[sum_constructor]" << std::endl; } std::string name() const { return "sum"; } float calculate(float x, float y) { return x + y; } ~sum() { std::cout << "[~sum_destructor]" << std::endl; } // Factory method static op_ptr create_sum() { return op_ptr(new sum()); } }; } // namespace sum_namespace BOOST_DLL_ALIAS( sum_namespace::sum::create_sum, // <-- this function is exported with... create_sum // <-- ...this alias name )

• File sum.hpp

   #pragma once #include "ioperation.hpp" #include "ioperation.hpp" namespace sum_namespace { struct sum : ioperation { sum(); ~sum() override; std::string name() const override; float calculate(float, float) override; static op_ptr create_sum(); }; } // namespace sum_namespace

• File dot_product.cpp

   #include "dot_product.h" #include <boost/config.hpp> #include <boost/dll/alias.hpp> #include <boost/dll/import.hpp> #include <iostream> namespace dot_product_namespace { dot_product::dot_product(op_ptr& arg) { sum_ptr = arg; std::cout << "[dot_product_constructor]" << std::endl; } std::string dot_product::name() const { return "dot_product"; } float dot_product::calculate(float a1, float a2) { // dot product given vector with itself // formula: ab = a1*b1 + a2*b2 return sum_ptr->calculate(a1 * a1, a2 * a2); } // Factory method /*static*/ op_ptr dot_product::create_dot_product(op_ptr sum_ptr) { return op_ptr(new dot_product(sum_ptr)); } dot_product::~dot_product() { std::cout << "[~dot_product_destructor]" << std::endl; } }; // namespace dot_product_namespace BOOST_DLL_ALIAS(dot_product_namespace::dot_product:: create_dot_product, // <-- this function is exported with... create_dot_product // <-- ...this alias name )

• File dot_product.h

   #pragma once #include "ioperation.hpp" namespace dot_product_namespace { struct dot_product : ioperation { dot_product(op_ptr&); ~dot_product() override; std::string name() const override; float calculate(float, float) override; static op_ptr create_dot_product(op_ptr sum_ptr); private: op_ptr sum_ptr; }; }; // namespace dot_product_namespace

• File application_di.cpp

   #include "boost/function.hpp" #include "ioperation.hpp" #include <boost/di.hpp> #include <boost/dll/import.hpp> #include <iostream> namespace di = boost::di; namespace dll = boost::dll; class app { private: op_ptr ptr_; public: app(boost::shared_ptr<ioperation> ptr) : ptr_(ptr) { std::cout << "name: " << ptr_->name() << std::endl; } }; using boost::filesystem::path; int main(int argc, char** argv) { // setting up paths to library(.so) files path lib_path(argc > 1 ? argv[1] : "."), child_library_path = lib_path / "dot_product", parent_library_path = lib_path / "sum"; // defining function types for lib constructors using sum_create_t = op_ptr(); using dot_product_create_t = op_ptr(op_ptr); // importing SUM lib factory auto sum_creator = boost::dll::import_alias<sum_create_t>( parent_library_path, "create_sum", dll::load_mode::append_decorations); // importing DOT_PRODUCT lib factory auto dot_product_creator = boost::dll::import_alias<dot_product_create_t>( child_library_path, "create_dot_product", dll::load_mode::append_decorations); auto use_sum = true; const auto injector = di::make_injector(di::bind<ioperation>().to( [=, &use_sum](const auto& injector) -> op_ptr { return use_sum ? sum_creator() : dot_product_creator(sum_creator()); }) // ); use_sum = argc > 2; injector.create<app>(); }

• File application_main.cpp

   #include "boost/shared_ptr.hpp" #include <boost/dll/import.hpp> #include "boost/function.hpp" #include <iostream> #include "ioperation.hpp" namespace dll = boost::dll; using boost::filesystem::path; int main(int argc, char** argv) { // setting up paths to library(.so) files path lib_path(argc > 1 ? argv[1] : "."), child_library_path = lib_path / "dot_product", parent_library_path = lib_path / "sum"; // defining function types for lib constructors using sum_create_t = op_ptr(); using dot_product_create_t = op_ptr(op_ptr); // importing SUM lib factory auto sum_creator = dll::import_alias<sum_create_t>( parent_library_path, "create_sum", dll::load_mode::append_decorations); // importing DOT_PRODUCT lib factory auto dot_product_creator = dll::import_alias<dot_product_create_t>( child_library_path, "create_dot_product", dll::load_mode::append_decorations); auto sum_ptr = sum_creator(); auto dot_product_ptr = dot_product_creator(sum_ptr); //executing calculate methods for object ptrs for (op_ptr op : {sum_creator(), dot_product_creator(sum_creator()) }) { std::cout << "\nPlugin Name: " << op->name() << "\n"; std::cout << "calculate(1, 2): " << op->calculate(1, 2) << "\n"; } }

• File compile_n_run.sh

   #!/bin/bash set -e -x -u ./cleanup.sh echo "=> Compiling now..." CPPFLAGS="-std=c++14 -fPIC -I /home/sehe/custom/boost-di/include/" LDFLAGS="" # Required to compile on sehe's machine: #CPPFLAGS="$CPPFLAGS -I /home/sehe/custom/boost-di/include/" #CPPFLAGS="$CPPFLAGS -isystem /home/sehe/custom/superboost/ "; #LDFLAGS="$LDFLAGS -L /home/sehe/custom/superboost/stage/lib" g++ $CPPFLAGS sum.cpp -shared -o libsum.so $LDFLAGS g++ $CPPFLAGS dot_product.cpp -shared -o libdot_product.so $LDFLAGS # add application libraries LDFLAGS="$LDFLAGS -lboost_filesystem -lboost_system -ldl" g++ $CPPFLAGS application_main.cpp -o application_main $LDFLAGS g++ $CPPFLAGS application_di.cpp -o application_di $LDFLAGS ./application_main . ./application_di . use_sum ./application_di . # uses dot_product

Output

Using compile_n_run.sh :

+ ./cleanup.sh
removed 'application_main'
removed 'libdot_product.so'
removed 'libsum.so'
=> cleaned up!
+ echo '=> Compiling now...'
=> Compiling now...
+ CPPFLAGS='-std=c++14 -fPIC -I /home/sehe/custom/boost-di/include/'
+ LDFLAGS=
+ g++ -std=c++14 -fPIC -I /home/sehe/custom/boost-di/include/ sum.cpp -shared -o libsum.so
+ g++ -std=c++14 -fPIC -I /home/sehe/custom/boost-di/include/ dot_product.cpp -shared -o libdot_product.so
+ LDFLAGS=' -lboost_filesystem -lboost_system -ldl'
+ g++ -std=c++14 -fPIC -I /home/sehe/custom/boost-di/include/ application_main.cpp -o application_main -lboost_filesystem -lboost_system -ldl
+ g++ -std=c++14 -fPIC -I /home/sehe/custom/boost-di/include/ application_di.cpp -o application_di -lboost_filesystem -lboost_system -ldl
+ ./application_main .
[sum_constructor]
[dot_product_constructor]
[sum_constructor]
[sum_constructor]
[dot_product_constructor]

Plugin Name: sum
calculate(1, 2): 3

Plugin Name: dot_product
calculate(1, 2): 5
[~dot_product_destructor]
[~sum_destructor]
[~sum_destructor]
[~dot_product_destructor]
[~sum_destructor]
+ ./application_di . use_sum
[sum_constructor]
name: sum
[~sum_destructor]
+ ./application_di .
[sum_constructor]
[dot_product_constructor]
name: dot_product
[~dot_product_destructor]
[~sum_destructor]

Or more live: