ORBManager.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef DOIL_ORB_MANAGER_H
#define DOIL_ORB_MANAGER_H

#include <string>
#include <vector>
#include <coil/Mutex.h>
#include <doil/doil.h>
#include <doil/ObjectManager.h>
#include <doil/IORB.h>

namespace doil
{
  class ORBManager
  {
  public:
    static ORBManager* init(coil::Properties prop)
      throw();
    
    static ORBManager& instance()
      throw();

    virtual void shutdown() throw();

    ReturnCode_t addORB(IORB* orb) throw();

    IORB* getORB(const char* name) throw();

    const std::vector<IORB*> getORBs() throw();

    const std::vector<std::string> availableORBs() throw();

    IORB* deleteORB(const char* name) throw();

    //------------------------------------------------------------

    virtual ReturnCodes activateObject(ImplBase* impl,
                                         const char* orbname = "") throw();
    virtual ReturnCodes deactivateObject(ImplBase* impl,
                                           const char* orbname = "") throw();

    virtual ReturnCodes  deactivateObject(const char* name,
                                            const char* orbname = "") throw();

    ReturnCode_t deleteObject(ImplBase* impl) throw();

    ReturnCode_t deleteObject(const char* name) throw();

    const std::vector<ImplBase*> getObjects() throw();

    ImplBase* getObject(const char* name) throw();

  protected:
    //------------------------------------------------------------
    // private functions
    //------------------------------------------------------------
  private:
    ORBManager(){}
    ORBManager(const ORBManager&);
    ORBManager& operator=(const ORBManager&);
    ~ORBManager(){}


    //------------------------------------------------------------
    // private variables
    //------------------------------------------------------------
  private:
    // static data member for singleton
    static ORBManager* manager;
    static coil::Mutex mutex;

    //------------------------------------------------------------
    // ORB map
    //------------------------------------------------------------
    class ORBPred
    {
    public:
      ORBPred(const char* name)
        : m_name(name)
      {
      }
      ORBPred(IORB* orb)
        : m_name(orb->name())
      {
      }
      bool operator()(IORB* orb)
      {
        return m_name == orb->name();
      }
      std::string m_name;
    };

    typedef ObjectManager<const char*, IORB, ORBPred> ORBMap;
    ORBMap m_orbs;
    // end of ORBMap
    //------------------------------------------------------------


    //------------------------------------------------------------
    // impl object map
    //------------------------------------------------------------
    class ImplPred
    {
    public:
      ImplPred(const char* name)
        : m_name(name)
      {
      }
      ImplPred(ImplBase* impl)
        : m_name(impl->name())
      {
      }
      bool operator()(ImplBase* impl)
      {
        return m_name == impl->name();
      }
      std::string m_name;
    };

    typedef ObjectManager<const char*, ImplBase, ImplPred> ImplMap;
    ImplMap m_impls;
  
    //    std::vector<IORB*> m_orbs;
    //    std::vector<ImplBase*> m_impl;
    //    typedef std::vector<IORB*>::iterator OrbIt;
    //    typedef std::vector<ImplBase*>::iterator ImplIt;


    //------------------------------------------------------------
    // functors for IORB operation
    //------------------------------------------------------------

    //------------------------------------------------------------
    // shutdown ORBs
    class orb_shutdown
    {
    public:
      void operator()(IORB* orb)
      {
        orb->shutdown();
      }
    };
    //
//    class find_orb
//    {
//    public:
//      find_orb(const char* name) : m_name(name)
//      {
//      }
//      bool operator()(IORB* orb)
//      {
//        return m_name == orb->name();
//      }
//      std::string m_name;
//    };
    
    class collect_orbs
    {
    public:
      void operator()(IORB* orb)
      {
        orbs_.push_back(orb);
      }
      std::vector<IORB*> orbs_;
    };

    class available_orbs
    {
    public:
      void operator()(IORB* orb)
      {
        orbs_.push_back(orb->name());
      }
      std::vector<std::string> orbs_;
    };

    class activate_impl
    {
    public:
      activate_impl(ImplBase* impl,
                    const char* orbname = "")
        : m_impl(impl), m_orbname(orbname)
      {
      }
      void operator()(IORB* orb)
      {
        if (m_orbname.empty() || m_orbname == orb->name())
          {
            ReturnCode_t ret = orb->activateObject(m_impl);
            retcodes_.push_back(orb->name(), ret);
          }
      }
      ReturnCodes retcodes_;
    private:
      ImplBase* m_impl;
      std::string m_orbname;
    };
    

    class deactivate_impl
    {
    public:
      deactivate_impl(ImplBase* impl, const char* orbname = "")
        : m_impl(impl), m_orbname(orbname)
      {
      }
      void operator()(IORB* orb)
      {
        if (m_orbname.empty() || m_orbname == orb->name())
          {
            ReturnCode_t ret = orb->deactivateObject(m_impl);
            retcodes_.push_back(orb->name(), ret);
          }
      }
      ReturnCodes retcodes_;
    private:
      ImplBase* m_impl;
      std::string m_orbname;
    };
    
    class deactivate_by_name
    {
    public:
      deactivate_by_name(const char* name, const char* orbname = "")
        : m_name(name), m_orbname(orbname)
      {
      }
      void operator()(IORB* orb)
      {
        if (m_orbname.empty() || m_orbname == orb->name())
          {
            ReturnCode_t ret(orb->deactivateObject(m_name.c_str()));
            retcodes_.push_back(orb->name(), ret);
          }
      }
      ReturnCodes retcodes_;
      std::string m_name;
      std::string m_orbname;
    };

    class collect_impl
    {
    public:
      collect_impl()
      {
      }
      void operator()(ImplBase* impl)
      {
        impls_.push_back(impl);
      }
      std::vector<ImplBase*> impls_;
    };
  };
}; // namespace doil
#endif // DOIL_ORB_MANAGER_H