server.hh

Go to the documentation of this file.

// Copyright (C) 2009, 2010 by Florent Lamiraux, Thomas Moulard, Joseph Mirabel, JRL.
//
// This file is part of the hpp-corbaserver.
//
// This software is provided "as is" without warranty of any kind,
// either expressed or implied, including but not limited to the
// implied warranties of fitness for a particular purpose.
//
// See the COPYING file for more information.

#ifndef HPP_CORBASERVER_SERVER_HH
# define HPP_CORBASERVER_SERVER_HH

# include <omniORB4/CORBA.h>

# include <hpp/corbaserver/fwd.hh>
# include <hpp/corbaserver/config.hh>
# include <hpp/corbaserver/problem-solver-map.hh>

# include <hpp/corba/template/server.hh>

namespace hpp
{
  namespace corbaServer
  {




    class HPP_CORBASERVER_DLLAPI Server
    {
    public:
      Server (core::ProblemSolverPtr_t problemSolver, int argc,
          const char* argv[], bool multiThread = false);

      Server (ProblemSolverMapPtr_t problemSolverMap, int argc,
          const char* argv[], bool multiThread = false);

      ~Server ();

      PortableServer::POA_var poa ()
      {
        return tools_->main_poa();
      }

      CORBA::ORB_var orb()
      {
        return tools_->orb();
      }

      void startCorbaServer ();

      const std::string& mainContextId () const
      {
        return mainContextId_;
      }

      const bool& multiThread () const
      {
        return multiThread_;
      }

      const bool& nameService () const
      {
        return nameService_;
      }

      int processRequest (bool loop);

      void requestShutdown (bool wait);

      bool createContext (const std::string& contextName);

      CORBA::Object_ptr getServer (const std::string& contextName,
          const std::string& pluginName,
          const std::string& objectName);

      bool loadPlugin (const std::string& contextName,
          const std::string& libFilename);

      ProblemSolverMapPtr_t problemSolverMap ();

      core::ProblemSolverPtr_t problemSolver ();

      typedef void* ServantKey;

      PortableServer::Servant getServant (ServantKey servantKey) const;

      void addServantKeyAndServant (ServantKey servantKey, PortableServer::Servant servant);

      void removeServant (PortableServer::Servant servant);

    private:


      void parseArguments (int argc, const char* argv[]);


      corba::Server<Tools>* tools_;

      std::string ORBendPoint;
      std::string mainContextId_;

      bool multiThread_, nameService_;

      ProblemSolverMapPtr_t problemSolverMap_;

      typedef boost::shared_ptr<ServerPlugin> ServerPluginPtr_t;
      typedef std::map<std::string, ServerPluginPtr_t> ServerPluginMap_t;
      struct Context {
        ServerPluginPtr_t main;
        ServerPluginMap_t plugins;
      };
      std::map<std::string, Context> contexts_;

      Context& getContext (const std::string& name);

      typedef std::map <ServantKey, PortableServer::Servant> ServantKeyToServantMap_t;
      typedef std::map <PortableServer::Servant, ServantKey> ServantToServantKeyMap_t;
      ServantKeyToServantMap_t servantKeyToServantMap_;
      ServantToServantKeyMap_t servantToServantKeyMap_;
    };
  } // end of namespace corbaServer.
} // end of namespace hpp.
#endif