Merge pull request #12 from jmirabel/devel

Use plugin mechanism of hpp-corbaserver.

Author: stonneau

CMakeLists.txt

@@ -32,6 +32,8 @@ SET(CUSTOM_HEADER_DIR hpp/corbaserver/affordance)
 
 SETUP_HPP_PROJECT ()
 
+LIST(APPEND PKG_CONFIG_ADDITIONAL_VARIABLES cmake_plugin)
+
 # Dependencies
 HPP_FINDPYTHON()
 ADD_REQUIRED_DEPENDENCY("hpp-core >= 3")

include/hpp/corbaserver/affordance/server.hh

@@ -12,6 +12,7 @@
 # define HPP_AFFORDANCE_CORBA_SERVER_HH
 
 # include <hpp/corba/template/server.hh>
+# include <hpp/corbaserver/server-plugin.hh>
 # include <hpp/corbaserver/affordance/fwd.hh>
 # include <hpp/corbaserver/affordance/config.hh>
 # include "hpp/corbaserver/problem-solver-map.hh"
@@ -25,21 +26,18 @@ namespace hpp
       class Afford;
     } // namespace impl
 
-    class HPP_AFFORDANCE_CORBA_DLLAPI Server
+    class HPP_AFFORDANCE_CORBA_DLLAPI Server : public corbaServer::ServerPlugin
     {
     public:
-      Server (int argc, const char* argv[], bool multiThread = false,
-	      const std::string& poaName = "child");
+      Server (corbaServer::Server* parent);
 
       /// \brief Shutdown CORBA server
       ~Server ();
-      /// Set planner that will be controlled by server
-      void setProblemSolverMap (hpp::corbaServer::ProblemSolverMapPtr_t psMap);
 
       void startCorbaServer(const std::string& contextId,
-			    const std::string& contextKind,
-			    const std::string& objectId,
-			    const std::string& objectKind);
+			    const std::string& contextKind);
+
+      std::string name () const;
 
     private:
       corba::Server <impl::Afford>* impl_;

src/CMakeLists.txt

@@ -20,6 +20,7 @@ SET(IDL_SOURCES
   affordance
   )
 
+INCLUDE(${HPP_CORBASERVER_CMAKE_PLUGIN})
 OMNIIDL_INCLUDE_DIRECTORIES(
 		${HPP_CORBASERVER_DATAROOTDIR}/idl
 		${CMAKE_SOURCE_DIR}/idl
@@ -51,24 +52,17 @@ INSTALL(
 ADD_CUSTOM_TARGET(generate_idl_cpp DEPENDS ${ALL_IDL_CPP_STUBS})
 ADD_CUSTOM_TARGET(generate_idl_python DEPENDS ${ALL_IDL_PYTHON_STUBS})
 
-ADD_LIBRARY(${LIBRARY_NAME}
-  SHARED
+HPP_ADD_SERVER_PLUGIN(affordance-corba
+  SOURCES
   ${ALL_IDL_CPP_STUBS}
   affordance.impl.hh
   affordance.impl.cc
   server.cc
+  PKG_CONFIG_DEPENDENCIES omniORB4 hpp-corbaserver hpp-affordance hpp-template-corba hpp-util
 )
 
-ADD_DEPENDENCIES (${LIBRARY_NAME} generate_idl_cpp)
-ADD_DEPENDENCIES (${LIBRARY_NAME} generate_idl_python)
-TARGET_LINK_LIBRARIES(${LIBRARY_NAME} hpp-affordance)
-
-PKG_CONFIG_USE_DEPENDENCY(${LIBRARY_NAME} hpp-corbaserver)
-PKG_CONFIG_USE_DEPENDENCY(${LIBRARY_NAME} hpp-affordance)
-PKG_CONFIG_USE_DEPENDENCY(${LIBRARY_NAME} hpp-template-corba)
-PKG_CONFIG_USE_DEPENDENCY(${LIBRARY_NAME} hpp-util)
-
-INSTALL(TARGETS ${LIBRARY_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ADD_DEPENDENCIES (affordance-corba generate_idl_cpp)
+ADD_DEPENDENCIES (affordance-corba generate_idl_python)
 
 PYTHON_INSTALL_ON_SITE(
   hpp/corbaserver/affordance corba.py ${PYTHON_SITELIB}
@@ -123,7 +117,6 @@ ENDFOREACH()
 
 # Standalone corba server
 ADD_EXECUTABLE (hpp-affordance-server hpp-affordance-corba.cc)
-TARGET_LINK_LIBRARIES (hpp-affordance-server ${LIBRARY_NAME} hpp-affordance)
 
 PKG_CONFIG_USE_DEPENDENCY(hpp-affordance-server hpp-corbaserver)
 PKG_CONFIG_USE_DEPENDENCY(hpp-affordance-server hpp-template-corba)

src/affordance.impl.cc

@@ -37,13 +37,6 @@ namespace hpp
 
                 Afford::Afford (const core::ProblemSolverPtr_t& /*problemSolver*/) {}
 
-        void Afford::setProblemSolverMap
-        (hpp::corbaServer::ProblemSolverMapPtr_t psMap)
-        {
-          psMap_ = psMap;
-					resetAffordanceConfig ();
-        }
-
 				void Afford::resetAffordanceConfig() throw (hpp::Error)
 				{
                     problemSolver()->affordanceConfigs.add("Support", vector3_t (0.3,0.3,0.05));

src/affordance.impl.hh

@@ -15,6 +15,7 @@
 # include "hpp/core/problem-solver.hh"
 # include "hpp/corbaserver/problem-solver-map.hh"
 # include "hpp/corbaserver/affordance/fwd.hh"
+# include "hpp/corbaserver/affordance/server.hh"
 
 # include "affordance-idl.hh"
 
@@ -31,9 +32,12 @@ namespace hpp
 
 	      Afford ();
 
-				Afford (const core::ProblemSolverPtr_t& problemSolver);
+				void setServer (Server* server)
+				{
+					server_ = server;
+				}
 
-          void setProblemSolverMap (hpp::corbaServer::ProblemSolverMapPtr_t psMap);
+				Afford (const core::ProblemSolverPtr_t& problemSolver);
 
 				void resetAffordanceConfig() throw (hpp::Error);
 
@@ -85,10 +89,10 @@ namespace hpp
         hpp::Names_t* getAffordanceConfigTypes () throw (hpp::Error);
 
       private:
-          corbaServer::ProblemSolverMapPtr_t psMap_;
+          Server* server_;
           core::ProblemSolverPtr_t problemSolver()
           {
-              return psMap_->selected();
+              return server_->problemSolver();
           }
       }; // class Afford
     } // namespace impl

src/hpp-affordance-corba.cc

@@ -11,36 +11,21 @@
 #include <iostream>
 #include <hpp/util/debug.hh>
 #include "hpp/corbaserver/server.hh"
-#include <hpp/corbaserver/affordance/server.hh>
 #include <hpp/corbaserver/problem-solver-map.hh>
 #include <hpp/core/problem-solver.hh>
-typedef hpp::affordanceCorba::Server AffordanceServer;
+
 typedef hpp::corbaServer::Server CorbaServer;
-typedef hpp::affordanceCorba::ProblemSolverPtr_t ProblemSolverPtr_t;
-typedef hpp::affordanceCorba::ProblemSolver ProblemSolver;
+typedef hpp::core::ProblemSolverPtr_t ProblemSolverPtr_t;
+typedef hpp::core::ProblemSolver ProblemSolver;
 
 int
 main (int argc, const char* argv[])
 {
   ProblemSolverPtr_t problemSolver = ProblemSolver::create ();
   CorbaServer corbaServer (problemSolver, argc,
 			   const_cast<const char**> (argv), true);
-  AffordanceServer affServer (argc, argv, true);
-  affServer.setProblemSolverMap (corbaServer.problemSolverMap());
-
-  try {
-    corbaServer.startCorbaServer ();
-    hppDout (info, "successfully started hpp-corbaserver");
-  } catch (const std::exception& exc) {
-    hppDout (error, "Failed to start hpp-corbaserver");
-  }
-  try {
-    affServer.startCorbaServer ("hpp", "corbaserver",
-				"affordanceCorba", "affordance");
 
-    hppDout (info, "Successfully started corba server for affordance");
-  } catch (const std::exception& exc) {
-    hppDout (error, "failed to start corba server for affordance");
-  }
+  corbaServer.startCorbaServer ();
+  corbaServer.loadPlugin (corbaServer.mainContextId(), "affordance-corba.so");
   corbaServer.processRequest(true);
 }

src/server.cc

@@ -8,35 +8,52 @@
 //
 // See the COPYING file for more information.
 
+#include "hpp/corbaserver/affordance/server.hh"
+
 #include <hpp/util/exception.hh>
 #include <hpp/util/debug.hh>
-#include "hpp/corbaserver/affordance/server.hh"
+#include <hpp/corbaserver/server.hh>
 #include "affordance.impl.hh"
 
 namespace hpp
 {
   namespace affordanceCorba
   {
-    Server::Server (int argc, const char* argv[], bool multiThread,
-		    const std::string& poaName) :
-      impl_ (new corba::Server <impl::Afford>
-	     (argc, argv, multiThread, poaName)) {}
-    Server::~Server () { delete impl_;}
-    void Server::setProblemSolverMap (hpp::corbaServer::ProblemSolverMapPtr_t psMap)
+    Server::Server (corbaServer::Server* server)
+      : corbaServer::ServerPlugin (server),
+      impl_ (NULL)
+    {}
+
+    Server::~Server ()
     {
-      impl_->implementation ().setProblemSolverMap (psMap);
+      if (impl_) delete impl_;
+    }
+
+    std::string Server::name () const
+    {
+      return "affordance";
     }
 
     /// Start corba server
     void Server::startCorbaServer(const std::string& contextId,
-				  const std::string& contextKind,
-				  const std::string& objectId,
-				  const std::string& objectKind)
+				  const std::string& contextKind)
     {
-      if (impl_->startCorbaServer(contextId, contextKind, objectId, objectKind)
-	  != 0) {
-	HPP_THROW_EXCEPTION (hpp::Exception, "Failed to start corba server.");
+      bool mThd = parent()->multiThread();
+      impl_ = new corba::Server <impl::Afford>   (0, NULL, mThd, "child");
+
+      impl_->implementation ().setServer (this);
+
+      if (impl_->startCorbaServer(contextId, contextKind,
+                                  "affordanceCorba", "affordance") != 0) {
+	HPP_THROW_EXCEPTION (hpp::Exception, "Failed to start affordance corba server.");
       }
+
+      // TODO this a very fragile. It works because startCorbaServer is called
+      // after setProblemSolverMap in hpp::corbaServer::Server::getContext
+      // implementation (file hpp-corbaserver/src/server.cc)
+      impl_->implementation().resetAffordanceConfig();
     }
   } // namespace affordanceCorba
 } // namespace hpp
+
+HPP_CORBASERVER_DEFINE_PLUGIN(hpp::affordanceCorba::Server)