root/ROOT/RNTupleRange.hxx

0001 /// \file ROOT/RNTupleRange.hxx
0002 /// \ingroup NTuple
0003 /// \author Jakob Blomer <jblomer@cern.ch>
0004 /// \date 2018-10-05
0005
0006 /*************************************************************************
0007  * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers.               *
0008  * All rights reserved.                                                  *
0009  *                                                                       *
0010  * For the licensing terms see $ROOTSYS/LICENSE.                         *
0011  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
0012  *************************************************************************/
0013
0014 #ifndef ROOT_RNTupleRange
0015 #define ROOT_RNTupleRange
0016
0017 #include <ROOT/RNTupleUtil.hxx>
0018
0019 namespace ROOT {
0020
0021 // clang-format off
0022 /**
0023 \class ROOT::RNTupleGlobalRange
0024 \ingroup NTuple
0025 \brief Used to loop over indexes (entries or collections) between start and end
0026 */
0027 // clang-format on
0028 class RNTupleGlobalRange {
0029 private:
0030    ROOT::NTupleSize_t fStart;
0031    ROOT::NTupleSize_t fEnd;
0032
0033 public:
0034    class RIterator {
0035    private:
0036       ROOT::NTupleSize_t fIndex = ROOT::kInvalidNTupleIndex;
0037
0038    public:
0039       using iterator = RIterator;
0040       using iterator_category = std::forward_iterator_tag;
0041       using value_type = ROOT::NTupleSize_t;
0042       using difference_type = ROOT::NTupleSize_t;
0043       using pointer = ROOT::NTupleSize_t *;
0044       using reference = ROOT::NTupleSize_t &;
0045
0046       RIterator() = default;
0047       explicit RIterator(ROOT::NTupleSize_t index) : fIndex(index) {}
0048       ~RIterator() = default;
0049
0050       iterator operator++(int) /* postfix */
0051       {
0052          auto r = *this;
0053          fIndex++;
0054          return r;
0055       }
0056       iterator &operator++() /* prefix */
0057       {
0058          ++fIndex;
0059          return *this;
0060       }
0061       reference operator*() { return fIndex; }
0062       pointer operator->() { return &fIndex; }
0063       bool operator==(const iterator &rh) const { return fIndex == rh.fIndex; }
0064       bool operator!=(const iterator &rh) const { return fIndex != rh.fIndex; }
0065    };
0066
0067    RNTupleGlobalRange(ROOT::NTupleSize_t start, ROOT::NTupleSize_t end) : fStart(start), fEnd(end) {}
0068    RIterator begin() const { return RIterator(fStart); }
0069    RIterator end() const { return RIterator(fEnd); }
0070    ROOT::NTupleSize_t size() const { return fEnd - fStart; }
0071    bool IsValid() const { return (fStart != ROOT::kInvalidNTupleIndex) && (fEnd != ROOT::kInvalidNTupleIndex); }
0072 };
0073
0074 // clang-format off
0075 /**
0076 \class ROOT::RNTupleLocalRange
0077 \ingroup NTuple
0078 \brief Used to loop over entries of collections in a single cluster
0079 */
0080 // clang-format on
0081 class RNTupleLocalRange {
0082 private:
0083    const ROOT::DescriptorId_t fClusterId;
0084    const ROOT::NTupleSize_t fStart;
0085    const ROOT::NTupleSize_t fEnd;
0086
0087 public:
0088    class RIterator {
0089    private:
0090       RNTupleLocalIndex fLocalIndex;
0091
0092    public:
0093       using iterator = RIterator;
0094       using iterator_category = std::forward_iterator_tag;
0095       using value_type = RNTupleLocalIndex;
0096       using difference_type = RNTupleLocalIndex;
0097       using pointer = RNTupleLocalIndex *;
0098       using reference = RNTupleLocalIndex &;
0099
0100       RIterator() = default;
0101       explicit RIterator(RNTupleLocalIndex localIndex) : fLocalIndex(localIndex) {}
0102       ~RIterator() = default;
0103
0104       iterator operator++(int) /* postfix */
0105       {
0106          auto r = *this;
0107          fLocalIndex++;
0108          return r;
0109       }
0110       iterator &operator++() /* prefix */
0111       {
0112          fLocalIndex++;
0113          return *this;
0114       }
0115       reference operator*() { return fLocalIndex; }
0116       pointer operator->() { return &fLocalIndex; }
0117       bool operator==(const iterator &rh) const { return fLocalIndex == rh.fLocalIndex; }
0118       bool operator!=(const iterator &rh) const { return fLocalIndex != rh.fLocalIndex; }
0119    };
0120
0121    RNTupleLocalRange(ROOT::DescriptorId_t clusterId, ROOT::NTupleSize_t start, ROOT::NTupleSize_t end)
0122       : fClusterId(clusterId), fStart(start), fEnd(end)
0123    {
0124    }
0125    RIterator begin() const { return RIterator(RNTupleLocalIndex(fClusterId, fStart)); }
0126    RIterator end() const { return RIterator(RNTupleLocalIndex(fClusterId, fEnd)); }
0127    ROOT::NTupleSize_t size() const { return fEnd - fStart; }
0128 };
0129
0130 } // namespace ROOT
0131
0132 #endif