---

ThreadSafeRegistry.h

Go to the documentation of this file.

#ifndef FWCoreUtilities_ThreadSafeRegistry_h
#define FWCoreUtilities_ThreadSafeRegistry_h

#include <map>
#include "boost/thread.hpp"

// ----------------------------------------------------------------------
// $Id: ThreadSafeRegistry.h,v 1.5 2007/02/21 16:21:28 paterno Exp $

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

namespace edm
{
  namespace detail
  {
    struct empty { };

    template <class KEY, class T, class E=empty>
    class ThreadSafeRegistry
    {
    public:
      typedef KEY   key_type;
      typedef T     mapped_type;
      typedef E     extra_type;
      typedef typename std::map<key_type, mapped_type> collection_type;
      typedef typename collection_type::size_type      size_type;

      typedef typename collection_type::const_iterator const_iterator;

      static ThreadSafeRegistry* instance();

      bool getMapped(key_type const& k, mapped_type& result) const;


      bool insertMapped(mapped_type const& v);

      bool empty() const;

      bool notEmpty() const;

      size_type size() const;

      const_iterator begin() const;
      const_iterator end() const;

      void print(std::ostream& os) const;

      collection_type& data();
      collection_type const& data() const;

      extra_type& extra();
      extra_type const& extra() const;      

    private:
      ThreadSafeRegistry();
      ~ThreadSafeRegistry();

      // The following two are not implemented.
      ThreadSafeRegistry(ThreadSafeRegistry<KEY,T,E> const&); 
    
      ThreadSafeRegistry<KEY,T,E>& 
      operator= (ThreadSafeRegistry<KEY,T,E> const&);

      collection_type data_;
      extra_type      extra_;

      static ThreadSafeRegistry* instance_;

      static boost::mutex registry_mutex;
    };

    template <class KEY, class T, class E>
    inline
    std::ostream&
    operator<< (std::ostream& os, ThreadSafeRegistry<KEY,T,E> const& reg)
    {
      reg.print(os);
      return os;
    }

    // ----------------------------------------------------------------------
    // Declarations of static data for classes instantiated from the
    // class template.

    template <class KEY, class T, class E>
    ThreadSafeRegistry<KEY,T,E>* ThreadSafeRegistry<KEY,T,E>::instance_ = 0;

    template <class KEY, class T, class E>
    boost::mutex ThreadSafeRegistry<KEY,T,E>::registry_mutex;

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

    template <class KEY, class T, class E>
    ThreadSafeRegistry<KEY,T,E>*
    ThreadSafeRegistry<KEY,T,E>::instance()
    {
      if (instance_ == 0)
        {
          boost::mutex::scoped_lock lock(registry_mutex);
          if (instance_ == 0)
            {
              static ThreadSafeRegistry<KEY,T,E> me;
              instance_ = &me;
            }
        }
      return instance_;      
    }

    template <class KEY, class T, class E>
    bool 
    ThreadSafeRegistry<KEY,T,E>::getMapped(key_type const& k, 
                                         mapped_type& result) const
    {
      bool found;
      const_iterator i;
      {
        // This scope limits the lifetime of the lock to the shorted
        // required interval.
        boost::mutex::scoped_lock lock(registry_mutex);
        i = data_.find(k);
        found = (i != data_.end());
      }
      if (found) result = i->second;
      return found;
    }

    template <class KEY, class T, class E>
    bool 
    ThreadSafeRegistry<KEY,T,E>::insertMapped(mapped_type const& v)
    {
      bool newly_added = false;
      boost::mutex::scoped_lock lock(registry_mutex);

      key_type id = v.id();
      if (data_.find(id) == data_.end())
        {
          data_[id] = v;
          newly_added = true;
        }
      return newly_added;
    }

    template <class KEY, class T, class E>
    inline
    bool
    ThreadSafeRegistry<KEY,T,E>::empty() const
    {
      return data_.empty();
    }
    
    template <class KEY, class T, class E>
    inline
    bool
    ThreadSafeRegistry<KEY,T,E>::notEmpty() const
    {
      return !empty();
    }

    template <class KEY, class T, class E>
    inline
    typename ThreadSafeRegistry<KEY,T,E>::size_type
    ThreadSafeRegistry<KEY,T,E>::size() const
    {
      return data_.size();
    }

    template <class KEY, class T, class E>
    inline
    typename ThreadSafeRegistry<KEY,T,E>::const_iterator
    ThreadSafeRegistry<KEY,T,E>::begin() const
    {
      return data_.begin();
    }

    template <class KEY, class T, class E>
    inline
    typename ThreadSafeRegistry<KEY,T,E>::const_iterator
    ThreadSafeRegistry<KEY,T,E>::end() const
    {
      return data_.end();
    }
    
    template <class KEY, class T, class E>
    void
    ThreadSafeRegistry<KEY,T,E>::print(std::ostream& os) const
    {
      os << "Registry with " << size() << " entries\n";
      for (const_iterator i=begin(), e=end(); i!=e; ++i)
        {
          os << i->first << " " << i->second << '\n';
        }
    }

    template <class KEY, class T, class E>
    inline
    typename ThreadSafeRegistry<KEY,T,E>::collection_type&
    ThreadSafeRegistry<KEY,T,E>::data()
    {
      return data_;
    }

    template <class KEY, class T, class E>
    inline
    typename ThreadSafeRegistry<KEY,T,E>::extra_type&
    ThreadSafeRegistry<KEY,T,E>::extra()
    {
      return extra_;
    }

    template <class KEY, class T, class E>
    inline
    typename ThreadSafeRegistry<KEY,T,E>::extra_type const&
    ThreadSafeRegistry<KEY,T,E>::extra() const
    {
      return extra_;
    }

    template <class KEY, class T, class E>
    inline
    typename ThreadSafeRegistry<KEY,T,E>::collection_type const&
    ThreadSafeRegistry<KEY,T,E>::data() const
    {
      return data_;
    }

    template <class KEY, class T, class E> 
    ThreadSafeRegistry<KEY,T,E>::ThreadSafeRegistry() : 
      data_()
    { }


    template <class KEY, class T, class E> 
    ThreadSafeRegistry<KEY,T,E>::~ThreadSafeRegistry() 
    { }

  } // namespace detail
} // namespace edm

#endif //  FWCoreUtilities_ThreadSafeRegistry_h

---