ThreadSafeRegistry.h

Go to the documentation of this file.

#ifndef FWCore_Utilities_ThreadSafeRegistry_h
#define FWCore_Utilities_ThreadSafeRegistry_h

#include <map>
#include <vector>
#include <ostream>
#include <mutex>

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

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

#pragma GCC visibility push(default)
namespace edm {
  namespace detail {

    template <typename KEY, typename T>
    class ThreadSafeRegistry {
    public:
      typedef KEY   key_type;
      typedef T     value_type;
      typedef typename std::map<key_type, value_type> collection_type;
      typedef typename collection_type::size_type      size_type;

      typedef typename std::vector<value_type> vector_type;

      static ThreadSafeRegistry* instance();

      bool getMapped(key_type const& k, value_type& result) const;
      
      value_type const* getMapped(key_type const& k) const;

      bool insertMapped(value_type const& v);

      void insertCollection(collection_type const& c);
      void insertCollection(vector_type const& c);

      bool empty() const;

      bool notEmpty() const;

      size_type size() const;

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

    private:
      ThreadSafeRegistry();
      ~ThreadSafeRegistry();

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

      mutable std::mutex mutex_;
      collection_type data_;
    };

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

    template <typename KEY, typename T>
    void 
    ThreadSafeRegistry<KEY,T>::insertCollection(collection_type const& c) {
      for (auto const& item: c ) {
    insertMapped(item.second);
      }
    }

    template <typename KEY, typename T>
    void 
    ThreadSafeRegistry<KEY,T>::insertCollection(vector_type const& c) {
      for (auto const& item: c) {
    insertMapped(item);
      }
    }

    template <typename KEY, typename T>
    inline
    bool
    ThreadSafeRegistry<KEY,T>::empty() const {
      std::lock_guard<std::mutex> guard(mutex_);
      return data_.empty();
    }
    
    template <typename KEY, typename T>
    inline
    bool
    ThreadSafeRegistry<KEY,T>::notEmpty() const {
      return !empty();
    }

    template <typename KEY, typename T>
    inline
    typename ThreadSafeRegistry<KEY,T>::size_type
    ThreadSafeRegistry<KEY,T>::size() const {
      std::lock_guard<std::mutex> guard(mutex_);
      return data_.size();
    }

    template <typename KEY, typename T>
    void
    ThreadSafeRegistry<KEY,T>::print(std::ostream& os) const {
      std::lock_guard<std::mutex> guard(mutex_);
      os << "Registry with " << size() << " entries\n";
      for (auto const& item: data_) {
      os << item.first << " " << item.second << '\n';
      }
    }

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


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

  } // namespace detail
} // namespace edm
#pragma GCC visibility pop
#endif //  FWCore_Utilities_ThreadSafeRegistry_h