rtm/ObjectManager.h

Go to the documentation of this file.

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

#include <rtm/RTC.h>

#include <vector>
#include <string>
#include <algorithm>

#include <coil/Mutex.h>
#include <coil/Guard.h>

template <typename Identifier, typename Object, typename Predicate>
class ObjectManager
{
public:
  typedef std::vector<Object*>                  ObjectVector;
  typedef typename ObjectVector::iterator       ObjectVectorItr;
  typedef typename ObjectVector::const_iterator ObjectVectorConstItr;
  typedef coil::Mutex Mutex;
  typedef coil::Guard<coil::Mutex> Guard;
  ObjectManager(){};
  
  ~ObjectManager(void){};
  
  bool registerObject(Object* obj)
  {
    ObjectVectorItr it;
    Guard guard(m_objects._mutex);
    
    it = std::find_if(m_objects._obj.begin(), m_objects._obj.end(),
                      Predicate(obj));
    if (it == m_objects._obj.end())
      {
        m_objects._obj.push_back(obj);
        return true;
      }
    return false;
  }
  
  Object* unregisterObject(const Identifier& id)
  {
    ObjectVectorItr it;
    Guard guard(m_objects._mutex);
    
    it = std::find_if(m_objects._obj.begin(), m_objects._obj.end(),
                      Predicate(id));
    if (it != m_objects._obj.end())
      {
        Object* obj(*it);
        m_objects._obj.erase(it);
        return obj;
      }
    return NULL;;
  }
  
  Object* find(const Identifier& id) const
  {
    ObjectVectorConstItr it;
    Guard guard(m_objects._mutex);
    it = std::find_if(m_objects._obj.begin(), m_objects._obj.end(),
                      Predicate(id));
    if (it != m_objects._obj.end())
      {
        return *it;
      }
    return NULL;
  }
  
  std::vector<Object*> getObjects() const
  {
    Guard guard(m_objects._mutex);
    return m_objects._obj;
  }
  
  template <class Pred>
  Pred for_each(Pred p)
  {
    Guard guard(m_objects._mutex);
    return std::for_each(m_objects._obj.begin(), m_objects._obj.end(), p);
  }
  
  template <class Pred>
  Pred for_each(Pred p) const
  {
    Guard guard(m_objects._mutex);
    return std::for_each(m_objects._obj.begin(), m_objects._obj.end(), p);
  }
  
protected:
  struct Objects
  {
    mutable Mutex _mutex;
    ObjectVector _obj;
  };
  Objects m_objects;
};
#endif // RTC_OBJECTMANAGER_H