experimenting with symbol shadowing

example/tutorial1/my_plugin_sum.cpp

@@ -47,6 +47,13 @@ BOOST_PLUGIN_ALIAS(my_namespace::plugin, plugin)
 //]
 
 
+boost::shared_ptr<my_namespace::my_plugin_sum> create_plugin_impl() {
+    return boost::make_shared<my_namespace::my_plugin_sum>();
+}
+
+
+BOOST_PLUGIN_ALIAS(create_plugin_impl, create_plugin)
+
 // platform dependent initialization sample
 //
 /*

example/tutorial5/load_all.cpp

@@ -0,0 +1,100 @@
+// Copyright 2011-2012 Renato Tegon Forti.
+// Copyright 2014 Renato Tegon Forti, 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)
+
+// For more information, see http://www.boost.org
+
+// -------------------------------------------------------------------------------------
+// This example shows how to use load_self to load symbols direct on executable
+// -------------------------------------------------------------------------------------
+
+//[plugcpp_load_all
+#include "../tutorial4/static_plugin.hpp"
+#include <boost/make_shared.hpp>
+#include <boost/container/map.hpp>
+#include <boost/filesystem.hpp>
+#include <iostream>
+
+namespace pl = boost::plugin;
+
+class plugins_collector {
+    typedef boost::container::map<std::string, pl::shared_library> plugins_t;
+
+    boost::filesystem::path         plugins_directory_;
+    plugins_t                       plugins_;
+
+    void load_all() {
+        namespace fs = ::boost::filesystem;
+        typedef fs::path::string_type string_type;
+        const string_type extension = pl::shared_library::suffix().native();        
+
+        fs::directory_iterator endit;        
+        for (fs::directory_iterator it(plugins_directory_); it != endit; ++it) {
+            if (!fs::is_regular_file(*it)) {
+                continue;
+            }
+
+            const string_type filename = it->path().filename().native();
+            if (filename.find(extension) != filename.size() - extension.size()) {
+                // Does not ends on '.so' or '.dll'
+                continue;
+            }
+
+            // We have a plugin
+            pl::shared_library plugin(it->path());      
+            std::cout << "Loading " << it->path() << "\nNative:" << plugin.native() << '\n';
+            insert_plugin(boost::move(plugin));
+        }
+        
+        std::cout << "Loading self\n";
+        pl::shared_library plugin;
+        plugin.load_self();      
+        insert_plugin(boost::move(plugin));
+    }
+
+    void insert_plugin(BOOST_RV_REF(pl::shared_library) lib) {
+        std::string plugin_name;
+        if (lib.search_symbol("create_plugin")) {
+            plugin_name = pl::alias<boost::shared_ptr<my_plugin_api>()>(lib, "create_plugin")()->name();
+        } else if (lib.search_symbol("plugin")) {
+            plugin_name = pl::alias<my_plugin_api>(lib, "plugin").name();
+        } else {
+            return;
+        }
+
+        if (plugins_.find(plugin_name) == plugins_.cend()) {
+            plugins_[plugin_name] = boost::move(lib);
+        }
+    }
+
+public:
+    plugins_collector(const boost::filesystem::path& plugins_directory)
+        : plugins_directory_(plugins_directory)
+    {
+        load_all();
+    }
+
+    void print_plugins() const {
+        plugins_t::const_iterator const end = plugins_.cend();
+        for (plugins_t::const_iterator it = plugins_.cbegin(); it != end; ++it) {
+            std::cout << it->first << ": " << it->second.native() << '\n';
+        }
+    }
+
+    std::size_t count() const {
+        return plugins_.size();
+    }
+
+    // ...   
+};
+
+int main(int argc, char* argv[]) {
+    plugins_collector plugins(argv[1]);
+
+    std::cout << "\n\nUnique plugins (" << plugins.count() << ") :\n";
+    plugins.print_plugins();
+}
+
+//]

include/boost/plugin/detail/posix/shared_library_impl.hpp

@@ -98,7 +98,7 @@ public:
         // "handle" for the dynamic library. If filename is NULL, then the 
         // returned handle is for the main program.
 
-        handle_ = dlopen(NULL, RTLD_LAZY);
+        handle_ = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL);
 
         if (!handle_) {
             ec = boost::system::error_code(

include/boost/plugin/shared_library_load_mode.hpp

@@ -149,6 +149,7 @@ namespace boost { namespace plugin {
             rtld_now                              = 0,
             rtld_global                           = 0,
             rtld_local                            = 0,
+            rtld_deepbind                         = 0,
 #else
             // windows
             dont_resolve_dll_references           = 0,
@@ -159,10 +160,11 @@ namespace boost { namespace plugin {
             load_with_altered_search_path         = 0,
 
             // posix
-            rtld_lazy                             = RTLD_LAZY,   // 1
-            rtld_now                              = RTLD_NOW,    // 2
-            rtld_global                           = RTLD_GLOBAL, // 3
-            rtld_local                            = RTLD_LOCAL   // 4
+            rtld_lazy                             = RTLD_LAZY,
+            rtld_now                              = RTLD_NOW,
+            rtld_global                           = RTLD_GLOBAL,
+            rtld_local                            = RTLD_LOCAL,
+            rtld_deepbind                         = RTLD_DEEPBIND
 #endif
         };
     };

test/Jamfile.v2

@@ -48,6 +48,11 @@ project
         [ run ../example/tutorial1/tutorial1.cpp : $(TEST_DIR) ]
         [ run ../example/tutorial2/tutorial2.cpp : $(TEST_DIR) ]
         [ run ../example/tutorial3/tutorial3.cpp : $(TEST_DIR) ]
-        [ run ../example/tutorial4/load_self.cpp : : : <library>static_plugin <target-os>linux:<linkflags>"-rdynamic" ]
+        [ run ../example/tutorial4/load_self.cpp 
+                : : : <variant>release <library>static_plugin <target-os>linux:<linkflags>"-rdynamic" 
+        ]
+        [ run ../example/tutorial5/load_all.cpp
+                : $(TEST_DIR) : : <variant>release <library>static_plugin <target-os>linux:<linkflags>"-rdynamic"
+        ]
     ;
 }

test/shared_library_load_test.cpp

@@ -127,6 +127,16 @@ int test_main(int argc, char* argv[])
       BOOST_CHECK(sl != sl2);
       BOOST_CHECK(sl < sl2 || sl2 <sl);
       BOOST_CHECK(!(sl == sl2));
+
+      sl.unload();
+      BOOST_CHECK(sl != sl2);
+      BOOST_CHECK(sl < sl2 || sl2 <sl);
+      BOOST_CHECK(!(sl == sl2));
+    
+      sl2.unload();
+      BOOST_CHECK(sl == sl2);
+      BOOST_CHECK(!(sl < sl2 || sl2 <sl));
+      BOOST_CHECK(!(sl != sl2));
    }
 
    {