ContainerList.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
  */
#ifndef CONTAINERLIST_H
#define CONTAINERLIST_H
 
#include <span>
#include <vector>
#include <atomic>
#include <mutex>
 
template <typename T_Container>
struct DynamicContainerListHelper;

template <typename T_Container>
class ContainerList
{
private:
   using T_ContainerPtr = T_Container *;
   using ContainerPtrList = T_ContainerPtr *;
public:
   friend struct DynamicContainerListHelper<T_Container>;

   ContainerList(unsigned int expected_max_container)
   {
      m_container.emplace_back(expected_max_container); // create expected_max_container containers
      // and create and populate the container list.
      m_containerList = fillContainerList( 0u,
                                           m_container.back(),
                                           expected_max_container <=1
                                           ? std::span<T_ContainerPtr>(&m_singleElementContainerList,1u)
                                           : std::span<T_ContainerPtr>(m_containerListHistory.emplace_back(expected_max_container) ));
   }

   std::size_t size() const { return m_containerList.size(); }
   T_Container &operator[](unsigned int idx) {
      assert( idx < m_containerList.size() && m_containerList[idx]);
      return *(m_containerList[idx]);
   }

   const T_Container &operator[](unsigned int idx) const {
      assert( idx < m_containerList.size() && m_containerList[idx]);
      return *(m_containerList[idx]);
   }
 
private:
   static std::span<T_ContainerPtr> fillContainerList( unsigned int begin_idx,
                                                       std::vector<T_Container> &container,
                                                       std::span<T_ContainerPtr> container_list) {
      unsigned int end_idx=begin_idx+container.size();
      assert( end_idx <= container_list.size());
      for (unsigned int idx=begin_idx; idx < end_idx; ++idx) {
         container_list[idx]=&container[idx-begin_idx];
      }
      return container_list;
   }
 

   T_Container                                              *m_singleElementContainerList{};
   std::span<T_ContainerPtr>                                 m_containerList;

   std::vector< std::vector<T_Container> >    m_container;
   std::vector< std::vector<T_ContainerPtr> > m_containerListHistory;
};

template <typename T_Container>
struct DynamicContainerListHelper {
   using T_ContainerPtr = T_Container *;

   struct ContainerPtr {
      friend struct DynamicContainerListHelper;
   protected:
      ContainerPtr(T_Container *ptr, unsigned int container_idx) : m_container(ptr),m_containerIdx(container_idx) {}
   public:
      ContainerPtr(const ContainerPtr &a) = default;
      ContainerPtr(ContainerPtr &&a) = default;
 
      ContainerPtr &operator=(const ContainerPtr &a) = default;
      ContainerPtr &operator=(ContainerPtr &&a) = default;
 
      T_Container &operator*() { assert( m_container != nullptr); return *m_container; }
      const T_Container &operator*() const { assert( m_container != nullptr); return *m_container; }
      T_Container *operator->() { assert( m_container != nullptr); return m_container; }
      const T_Container *operator->() const { assert( m_container != nullptr); return m_container; }

      unsigned int containerId() const {
         return m_containerIdx;
      }
 
   private:
      T_Container *m_container;
      unsigned int m_containerIdx;
   };

   void addLargerContainerList(unsigned int container_idx, ContainerList<T_Container> &container_list) {
      std::lock_guard<std::mutex> container_list_lock(m_containerListMutex);
      if (container_idx >= container_list.m_containerList.size()) {
         // create new container list with min_elements extra elements i.e. grow in chunks
         static constexpr std::size_t min_elments = (sizeof(T_ContainerPtr)>=32u ? 1ul : 64ul/sizeof(T_ContainerPtr)-1);
         const std::size_t new_size=(m_used+min_elments+1) & (~(min_elments));
         unsigned int n=new_size - container_list.m_containerList.size();
         // add a new container_list and add new empty containers
         container_list.m_container.emplace_back( n );
         container_list.m_containerListHistory.emplace_back( new_size );
         std::vector<T_ContainerPtr> &new_container_list = container_list.m_containerListHistory.back();
         std::vector<T_Container> &extra_container = container_list.m_container.back();
         assert(new_container_list.size()>=container_list.m_containerList.size());
         // copy pointers from original container list to new container list
         std::copy(container_list.m_containerList.begin(),container_list.m_containerList.end(),new_container_list.begin());
         // set pointers of new container_list
         container_list.m_containerList = ContainerList<T_Container>::fillContainerList(container_list.m_containerList.size(),
                                                                                        extra_container,
                                                                                        std::span(new_container_list) );
      }
   }

   ContainerPtr getNewContainer(ContainerList<T_Container> &container_list) {
      unsigned int container_idx = m_used++;
      if (container_idx >= container_list.m_containerList.size()) {
         addLargerContainerList(container_idx, container_list);
      }
      return ContainerPtr(container_list.m_containerList[container_idx],container_idx);
   }
 
   std::mutex                m_containerListMutex;
   std::atomic<unsigned int> m_used{};
};
 
#endif