ObjectManager.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_OBJECTMANAGER_H
#define RTC_OBJECTMANAGER_H
 
#include <rtm/RTC.h>
 
#include <mutex>
 
#include <algorithm>
#include <vector>
#include <string>
 
 
template <typename Identifier, typename Object, typename Predicate>
class ObjectManager
{
public:
  using ObjectVector = std::vector<Object*>;
  using ObjectVectorItr = typename ObjectVector::iterator;
  using ObjectVectorConstItr = typename ObjectVector::const_iterator;
  ObjectManager() = default;
 
  ~ObjectManager() = default;
 
  bool registerObject(Object* obj)
  {
    ObjectVectorItr it;
    std::lock_guard<std::mutex> 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.emplace_back(obj);
        return true;
      }
    return false;
  }
 
  Object* unregisterObject(const Identifier& id)
  {
    ObjectVectorItr it;
    std::lock_guard<std::mutex> 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 nullptr;
  }
 
  Object* find(const Identifier& id) const
  {
    ObjectVectorConstItr it;
    std::lock_guard<std::mutex> 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 nullptr;
  }
 
  std::vector<Object*> getObjects() const
  {
    std::lock_guard<std::mutex> guard(m_objects._mutex);
    return m_objects._obj;
  }
 
  template <class Pred>
  Pred for_each(Pred p)
  {
    std::lock_guard<std::mutex> 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
  {
    std::lock_guard<std::mutex> guard(m_objects._mutex);
    return std::for_each(m_objects._obj.begin(), m_objects._obj.end(), p);
  }
 
protected:
  struct Objects
  {
    ~Objects() = default;
    mutable std::mutex _mutex;
    ObjectVector _obj;
  };
  Objects m_objects;
};
#endif  // RTC_OBJECTMANAGER_H