edm/details/host_container.hpp

0001 /** TRACCC library, part of the ACTS project (R&D line)
0002  *
0003  * (c) 2021-2022 CERN for the benefit of the ACTS project
0004  *
0005  * Mozilla Public License Version 2.0
0006  */
0007
0008 #pragma once
0009
0010 // Project include(s).
0011 #include "traccc/definitions/qualifiers.hpp"
0012 #include "traccc/edm/details/container_base.hpp"
0013
0014 // VecMem include(s).
0015 #include <vecmem/containers/jagged_vector.hpp>
0016 #include <vecmem/containers/vector.hpp>
0017
0018 // System include(s).
0019 #include <cassert>
0020
0021 namespace traccc {
0022
0023 /// Host container describing objects in a given event
0024 template <typename header_t, typename item_t>
0025 class host_container : public container_base<header_t, item_t, vecmem::vector,
0026                                              vecmem::jagged_vector> {
0027  public:
0028   /// Base class type
0029   using base_type =
0030       container_base<header_t, item_t, vecmem::vector, vecmem::jagged_vector>;
0031
0032   /// Inherit all of the base class's constructors
0033   using base_type::base_type;
0034
0035   /**
0036    * @brief Bounds-checking mutable element accessor.
0037    */
0038   TRACCC_HOST
0039   typename base_type::element_view at(typename base_type::size_type i) {
0040     return {this->m_headers.at(i), this->m_items.at(i)};
0041   }
0042
0043   /**
0044    * @brief Bounds-checking immutable element accessor.
0045    */
0046   TRACCC_HOST
0047   typename base_type::const_element_view at(
0048       typename base_type::size_type i) const {
0049     return {this->m_headers.at(i), this->m_items.at(i)};
0050   }
0051
0052   /**
0053    * @brief Bounds-checking mutable item vector element accessor.
0054    */
0055   TRACCC_HOST
0056   typename base_type::item_type& at(const typename base_type::link_type& link) {
0057     return this->m_items.at(link.first).at(link.second);
0058   }
0059
0060   /**
0061    * @brief Bounds-checking immutable item vector element accessor.
0062    */
0063   TRACCC_HOST
0064   const typename base_type::item_type& at(
0065       const typename base_type::link_type& link) const {
0066     return this->m_items.at(link.first).at(link.second);
0067   }
0068
0069   /**
0070    * @brief Mutable element accessor.
0071    */
0072   TRACCC_HOST
0073   typename base_type::element_view operator[](typename base_type::size_type i) {
0074     return {this->m_headers[i], this->m_items[i]};
0075   }
0076
0077   /**
0078    * @brief Immutable element accessor.
0079    */
0080   TRACCC_HOST
0081   typename base_type::const_element_view operator[](
0082       typename base_type::size_type i) const {
0083     return {this->m_headers[i], this->m_items[i]};
0084   }
0085
0086   /**
0087    * @brief Mutable item vector element accessor.
0088    */
0089   TRACCC_HOST
0090   typename base_type::item_type& operator[](
0091       const typename base_type::link_type& link) {
0092     return this->m_items[link.first][link.second];
0093   }
0094
0095   /**
0096    * @brief Immutable item vector element accessor.
0097    */
0098   TRACCC_HOST
0099   const typename base_type::item_type& operator[](
0100       const typename base_type::link_type& link) const {
0101     return this->m_items[link.first][link.second];
0102   }
0103
0104   /**
0105    * @brief Return the size of the container.
0106    *
0107    * In principle, the size of the two internal vectors should always be
0108    * equal, but we can assert this at runtime for debug builds.
0109    */
0110   TRACCC_HOST
0111   typename base_type::size_type size(void) const {
0112     assert(this->m_headers.size() == this->m_items.size());
0113     return this->m_headers.size();
0114   }
0115
0116   /**
0117    * @brief Reserve space in both vectors.
0118    */
0119   TRACCC_HOST
0120   void reserve(typename base_type::size_type s) {
0121     this->m_headers.reserve(s);
0122     this->m_items.reserve(s);
0123   }
0124
0125   /**
0126    * @brief Resize space in both vectors.
0127    */
0128   TRACCC_HOST
0129   void resize(typename base_type::size_type s) {
0130     this->m_headers.resize(s);
0131     this->m_items.resize(s);
0132   }
0133
0134   /**
0135    * @brief Push a header and a vector into the container.
0136    */
0137   template <typename h_prime, typename v_prime>
0138   TRACCC_HOST void push_back(h_prime&& new_header, v_prime&& new_items) {
0139     this->m_headers.push_back(std::forward<h_prime>(new_header));
0140     this->m_items.push_back(std::forward<v_prime>(new_items));
0141   }
0142
0143   /**
0144    * @breif Get number of items of jagged vector
0145    */
0146   TRACCC_HOST
0147   typename base_type::size_type total_size() const {
0148     typename base_type::size_type ret = 0;
0149     for (const typename base_type::item_vector::value_type& item :
0150          this->m_items) {
0151       ret += item.size();
0152     }
0153     return ret;
0154   }
0155
0156 };  // class host_container
0157
0158 }  // namespace traccc