EIC code displayed by LXR master/​include/​root/​ROOT/​RBinIndexMultiDimRange.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-08-16 09:21:12

 /// \file
 /// \warning This is part of the %ROOT 7 prototype! It will change without notice. It might trigger earthquakes.
 /// Feedback is welcome!
 
 #ifndef ROOT_RBinIndexMultiDimRange
 #define ROOT_RBinIndexMultiDimRange
 
 #include "RBinIndex.hxx"
 #include "RBinIndexRange.hxx"
 
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 #include <utility>
 #include <vector>
 
 namespace ROOT {
 namespace Experimental {
 
 /**
 A multidimensional range of bin indices.
 
 The interface allows convenient iteration over multiple RBinIndexRange. The result is available as vector of RBinIndex.
 
 \warning This is part of the %ROOT 7 prototype! It will change without notice. It might trigger earthquakes.
 Feedback is welcome!
 */
 class RBinIndexMultiDimRange final {
    /// The original ranges
    std::vector<RBinIndexRange> fRanges;
    /// Whether there is an empty range
    bool fHasEmptyRange = false;
 
 public:
    /// Construct an invalid bin index range.
    RBinIndexMultiDimRange() = default;
    /// Construct a multidimensional range of bin indices.
    RBinIndexMultiDimRange(std::vector<RBinIndexRange> ranges) : fRanges(std::move(ranges))
    {
       for (auto &&range : fRanges) {
          if (range.GetBegin() == range.GetEnd()) {
             fHasEmptyRange = true;
          }
       }
    }
 
    const std::vector<RBinIndexRange> &GetRanges() const { return fRanges; }
 
    friend bool operator==(const RBinIndexMultiDimRange &lhs, const RBinIndexMultiDimRange &rhs)
    {
       return lhs.fRanges == rhs.fRanges;
    }
 
    friend bool operator!=(const RBinIndexMultiDimRange &lhs, const RBinIndexMultiDimRange &rhs)
    {
       return !(lhs == rhs);
    }
 
    /// Iterator over RBinIndexMultiDimRange.
    class RIterator final {
       friend class RBinIndexMultiDimRange;
 
       /// The current iterators
       std::vector<RBinIndexRange::RIterator> fIterators;
       /// The current bin indices
       std::vector<RBinIndex> fIndices;
       /// Pointer to the original RBinIndexMultiDimRange
       const RBinIndexMultiDimRange *fMultiDimRange = nullptr;
 
       RIterator(const RBinIndexMultiDimRange &multiDimRange) : fMultiDimRange(&multiDimRange) {}
 
    public:
       using difference_type = std::ptrdiff_t;
       using value_type = std::vector<RBinIndex>;
       using pointer = const std::vector<RBinIndex> *;
       using reference = const std::vector<RBinIndex> &;
       using iterator_category = std::input_iterator_tag;
 
       RIterator() = default;
 
       RIterator &operator++()
       {
          const std::size_t N = fIterators.size();
          std::size_t j = 0;
          for (; j < N; j++) {
             // Reverse iteration order to advance the innermost index first.
             const std::size_t i = N - 1 - j;
 
             // Advance this iterator and get the index by dereferencing.
             // NB: We dereference even if reaching the end. This is fine because we know the implementation of
             // RBinIndexRange, in the worst case the returned RBinIndex will be invalid.
             fIterators[i]++;
             fIndices[i] = *fIterators[i];
             // If we have not reached the end, we are done (with this loop).
             if (fIndices[i] != fMultiDimRange->fRanges[i].GetEnd()) {
                break;
             }
          }
          // If we iterated until j = N, all fIterators and fIndices are at the end.
          if (j == N) {
             // Clear fIterators to compare equal to the empty iterator returned by end().
             fIterators.clear();
          } else {
             // Otherwise we need to wrap around the innermost dimensions.
             for (std::size_t k = 0; k < j; k++) {
                // Reverse the iteration order as above.
                const std::size_t i = N - 1 - k;
                fIterators[i] = fMultiDimRange->fRanges[i].begin();
                fIndices[i] = *fIterators[i];
             }
          }
          return *this;
       }
       RIterator operator++(int)
       {
          RIterator old = *this;
          operator++();
          return old;
       }
 
       const std::vector<RBinIndex> &operator*() const { return fIndices; }
       const std::vector<RBinIndex> *operator->() const { return &fIndices; }
 
       friend bool operator==(const RIterator &lhs, const RIterator &rhs)
       {
          return lhs.fIterators == rhs.fIterators && lhs.fMultiDimRange == rhs.fMultiDimRange;
       }
       friend bool operator!=(const RIterator &lhs, const RIterator &rhs) { return !(lhs == rhs); }
    };
 
    RIterator begin() const
    {
       RIterator it(*this);
       // If there is an empty range, return an empty iterator.
       if (fHasEmptyRange) {
          return it;
       }
 
       for (auto &&range : fRanges) {
          it.fIterators.push_back(range.begin());
          it.fIndices.push_back(*it.fIterators.back());
       }
       return it;
    }
    RIterator end() const { return RIterator(*this); }
 };
 
 } // namespace Experimental
 } // namespace ROOT
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team