Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <cstddef>
       7             : #include <type_traits>
       8             : #include <vector>
       9             : 
      10             : #include "DataStructures/DataVector.hpp"
      11             : 
      12             : /// \cond
      13             : namespace PUP {
      14             : class er;
      15             : }  // namespace PUP
      16             : /// \endcond
      17             : 
      18             : /**
      19             :  * \ingroup DataStructuresGroup
      20             :  *
      21             :  * \brief A dynamically sized vector of `DataVector`s. For convenience it can
      22             :  * also be instantiated for fundamental types.
      23             :  *
      24             :  * \details This class is useful when one wants to create a `std::vector<T>`
      25             :  * with a size that is unknown at compile time. It allocates all `DataVector`s
      26             :  * in a single memory chunk rather than allocating each individually. If the
      27             :  * size of the vector is known at compile time, a `TempBuffer` object should be
      28             :  * used instead.
      29             :  *
      30             :  * Currently this can only be used for `DataVector`s, but if needed, it should
      31             :  * be fairly straightforward to generalize to `ComplexDataVector`.
      32             :  */
      33             : template <typename T>
      34           1 : class DynamicBuffer {
      35             :  public:
      36             :   // Only vector type supported is DataVector
      37           0 :   static constexpr bool is_data_vector_type = std::is_same_v<DataVector, T>;
      38             : 
      39           0 :   DynamicBuffer() = default;
      40             : 
      41             :   /*!
      42             :    * Constructs a `DynamicBuffer`. The `number_of_vectors` corresponds to the
      43             :    * number of `DataVector`s which are saved inside, each of which has size
      44             :    * `number_of_grid_points`. `number_of_grid_points` has to be 1 if T is a
      45             :    * fundamental type.
      46             :    */
      47           1 :   DynamicBuffer(size_t number_of_vectors, size_t number_of_grid_points);
      48           0 :   ~DynamicBuffer() = default;
      49           0 :   DynamicBuffer(DynamicBuffer&& other) = default;
      50           0 :   DynamicBuffer& operator=(DynamicBuffer&& other) = default;
      51             : 
      52           0 :   DynamicBuffer(const DynamicBuffer& other);
      53             : 
      54           0 :   DynamicBuffer& operator=(const DynamicBuffer& other);
      55             : 
      56           0 :   T& operator[](size_t index) { return data_[index]; }
      57           0 :   T& at(size_t index) { return data_.at(index); }
      58           0 :   const T& operator[](size_t index) const { return data_[index]; }
      59           0 :   const T& at(size_t index) const { return data_.at(index); }
      60             : 
      61           0 :   auto begin() { return data_.begin(); }
      62           0 :   auto end() { return data_.end(); }
      63           0 :   auto begin() const { return data_.begin(); }
      64           0 :   auto end() const { return data_.end(); }
      65             : 
      66           0 :   size_t size() const { return data_.size(); }
      67             : 
      68             :   // NOLINTNEXTLINE(google-runtime-references)
      69           0 :   void pup(PUP::er& p);
      70             : 
      71             :  private:
      72             :   // sets data references for all `data_` into `buffer_`
      73           0 :   void set_references();
      74             : 
      75             :   template <typename LocalT>
      76             :   // NOLINTNEXTLINE(readability-redundant-declaration)
      77           0 :   friend bool operator==(const DynamicBuffer<LocalT>& lhs,
      78             :                          const DynamicBuffer<LocalT>& rhs);
      79             : 
      80           0 :   size_t number_of_grid_points_;
      81             :   // vector of non-owning DataVectors pointing into `buffer_`. In case of
      82             :   // fundamental type T the data is saved in `data_` directly.
      83           0 :   std::vector<T> data_;
      84             :   // memory buffer for all DataVectors. Unused in case of fundamental type T.
      85           0 :   std::vector<double> buffer_;
      86             : };
      87             : 
      88             : template <typename T>
      89           0 : bool operator!=(const DynamicBuffer<T>& lhs, const DynamicBuffer<T>& rhs);