IdentifiableValueCache.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef EVENTCONTAINERS_IDENTIFIABLEVALUECACHE_H
#define EVENTCONTAINERS_IDENTIFIABLEVALUECACHE_H
 
#include <atomic>
#include <vector>
#include <cstdlib>
 
template<class T>
class IdentifiableValueCache{
 
public:
 
   typedef std::true_type thread_safe;
 
   const T& emptyValue() const {
      return m_emptyValue;
   }
 
   //Prevent accidental copying
   IdentifiableValueCache(const IdentifiableValueCache&) = delete;
 
   IdentifiableValueCache(size_t maxSize, T emptyValuein)
      : m_vec(maxSize), m_emptyValue(std::move(emptyValuein))
   {
        for(auto &x : m_vec) x.store(emptyValue(), std::memory_order_relaxed);
   }
 
   void forceReset();
 
   size_t maxSize() const { return m_vec.size(); }
 
   ~IdentifiableValueCache() = default;
 
   T retrieve(size_t i){   return m_vec.at(i).load(); }
 
   T retrieve(size_t i) const {  return i < maxSize() ? static_cast<T>(m_vec[i]) : emptyValue() ; }
 
   bool present(size_t i){  return m_vec.at(i).load() != emptyValue();   }
 
   bool present(size_t i) const {  return  i < maxSize() and m_vec[i] != emptyValue() ? true : false; }
 
   bool setOrDrop(size_t i, const T &value);
 
   std::vector<std::pair<size_t, T>> getAll() const;
 
   const std::vector<std::atomic<T>>& rawReadAccess() const { return m_vec; }
 
private:
   std::vector<std::atomic<T>> m_vec;
   const T m_emptyValue;
};
 
template<class T>
std::vector<std::pair<size_t, T>>
IdentifiableValueCache<T>::getAll() const{
   std::vector<std::pair<size_t, T>> list;
   for(size_t i =0; i<m_vec.size(); i++){
       T item = m_vec[i].load(std::memory_order_relaxed);
       if(item!=m_emptyValue) list.emplace_back(i, std::move(item));
   }
   return list;
}
 
template<class T>
void IdentifiableValueCache<T>::forceReset(){
    for(auto &x : m_vec) x.store(emptyValue(), std::memory_order_relaxed);
}
 
template<class T>
bool IdentifiableValueCache<T>::setOrDrop(size_t i, const T &value){
    T val = emptyValue();
    return m_vec.at(i).compare_exchange_strong(val, value);
}
 
#endif