IdentifiableValueContainer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef EVENTCONTAINERS_IDENTIFIABLEVALUECONTAINER_H
#define EVENTCONTAINERS_IDENTIFIABLEVALUECONTAINER_H
 
#include "EventContainers/IdentifiableValueCache.h"
#include "CxxUtils/checker_macros.h"
#include <set>
 
class IdentifiableValueContainerBase {};
 
 
/*
*  This class is the view specific container that can link to the IdentifiableValueCache
*  It allows you to link to an external cache and keep a mask to track the items in your specific view
*/
 
template<class T>
class IdentifiableValueContainer : IdentifiableValueContainerBase{
 
public:
  typedef T value_type;
  typedef IdentifiableValueCache<T> Cache;
 
   //Prevent accidental copying
   IdentifiableValueContainer(const IdentifiableValueContainer<T>&) = delete;
   IdentifiableValueContainer& operator=(const IdentifiableValueContainer&) = delete;
 
   ~IdentifiableValueContainer()  { if(m_own) delete m_cache; }
 
   IdentifiableValueContainer(size_t maxSize, T defaultValue) : m_own(true)
   {
       m_cache = new IdentifiableValueCache<T>(maxSize, std::move(defaultValue));
   }
 
   IdentifiableValueContainer(IdentifiableValueCache<T> *ptr) : 
   m_cache(ptr), m_own(false)
   {}
 
 
   const T& emptyValue() const { return m_cache->emptyValue(); }
 
 
   bool present(size_t i) const;
 
   bool setOrDrop(size_t i, const T &value);
 
   size_t maxSize() const { return m_cache->maxSize(); }
 
   size_t numberSet() const;
 
   bool tryAddFromCache(size_t i);
 
   T retrieve(size_t i) const;
 
   std::vector<std::pair<size_t, T>> getAll() const;
 
   const std::vector<std::atomic<T>>& wholeEventReadAccess() const { return m_cache->rawReadAccess(); }
 
   const Cache* cache() const { return m_cache; }
 
   const std::set<size_t>& getMask() const { return m_mask; }
private:
   std::set<size_t> m_mask;
   Cache *m_cache;
   bool m_own;
};
 
template< class T >
bool IdentifiableValueContainer<T>::present(size_t i) const
{
   return m_mask.count(i);
}
 
template< class T >
std::vector<std::pair<size_t, T>> IdentifiableValueContainer<T>::getAll() const{
   std::vector<std::pair<size_t, T>> list;
   list.reserve(m_mask.size());
   const auto& raw = m_cache->rawReadAccess();
   for(size_t i : m_mask){
       list.emplace_back(i, raw[i].load(std::memory_order_relaxed));
   }
   return list;
}
 
template< class T >
T IdentifiableValueContainer<T>::retrieve(size_t i) const{
     Cache* cache ATLAS_THREAD_SAFE = m_cache;
     auto r = cache->retrieve(i);
     //Should be quicker to establish empty cache than empty mask with a std::set
     //So the cache is checked first
     if(r!= cache->emptyValue() && present(i)) return r;
     else return cache->emptyValue();
}
 
template< class T >
bool IdentifiableValueContainer<T>::tryAddFromCache(size_t i){
   if(i >= maxSize()) return false;
   bool b = m_cache->present(i);
   if(b) m_mask.emplace(i);
   return b;
}
 
 
 
template< class T >
size_t IdentifiableValueContainer<T>::numberSet() const{
     return m_mask.size();
}
 
template< class T >
bool IdentifiableValueContainer<T>::setOrDrop(size_t i, const T &value){
   bool b = m_cache->setOrDrop(i, value);
   m_mask.emplace(i);
   return b;
}
 
#endif