Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines IndexIterator.
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <cstddef>
      10             : 
      11             : #include "DataStructures/Index.hpp"
      12             : 
      13             : /// \ingroup DataStructuresGroup
      14             : /// IndexIterator iterates over a unique set of Index.
      15             : ///
      16             : /// \example
      17             : /// \snippet Test_IndexIterator.cpp index_iterator_example
      18             : ///
      19             : /// Each integer of the Index will vary from 0 to extents[d] - 1,
      20             : /// with the lowest dimension varying the fastest.
      21             : template <std::size_t Dim>
      22           1 : class IndexIterator {
      23             :  public:
      24             :   /// Construct from an Index
      25           1 :   explicit IndexIterator(Index<Dim> extents);
      26             :   /// It does not make sense to default construct an IndexIterator
      27           1 :   IndexIterator() = delete;
      28             :   /// \cond HIDDEN_SYMBOLS
      29             :   ~IndexIterator() = default;
      30             :   /// @{
      31             :   /// No copy or move semantics
      32             :   IndexIterator(const IndexIterator<Dim>&) = delete;
      33             :   IndexIterator(IndexIterator<Dim>&&) = delete;
      34             :   IndexIterator<Dim>& operator=(const IndexIterator<Dim>&) = delete;
      35             :   IndexIterator<Dim>& operator=(IndexIterator<Dim>&&) = delete;
      36             :   /// @}
      37             :   /// \endcond
      38             : 
      39             :   /// Returns false if the end of the Index iteration is reached
      40           1 :   explicit operator bool() const { return valid_; }
      41             : 
      42             :   /// Advance to next Index.
      43           1 :   IndexIterator<Dim>& operator++();
      44             : 
      45           0 :   const Index<Dim>& operator*() const { return index_; }
      46           0 :   const Index<Dim>* operator->() const { return &index_; }
      47             : 
      48             :   /// Returns an index representing the (i, j, ...)th values that the iterator
      49             :   /// currently represents
      50           1 :   const Index<Dim>& operator()() const { return index_; }
      51             : 
      52             :   /// Get the collapsed index into a 1D array of the data corresponding to the
      53             :   /// current Index of the IndexIterator. Note that the first dimension of the
      54             :   /// Index varies fastest when computing the collapsed index.
      55           1 :   size_t collapsed_index() const { return collapsed_index_; }
      56             : 
      57             :  private:
      58           0 :   const Index<Dim> extents_{};
      59           0 :   Index<Dim> index_{};
      60           0 :   size_t collapsed_index_{0};
      61           0 :   bool valid_{false};
      62             : };