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

File indexing completed on 2025-01-18 10:10:51

 /* @(#)root/core/cont:$Id$ */
 // Author: Danilo Piparo November 2015
 
 /*************************************************************************
  * Copyright (C) 1995-2016, Rene Brun and Fons Rademakers.               *
  * All rights reserved.                                                  *
  *                                                                       *
  * For the licensing terms see $ROOTSYS/LICENSE.                         *
  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
  *************************************************************************/
 
 #ifndef ROOT_TSeq
 #define ROOT_TSeq
 
 #include "TError.h"
 #include <iterator>
 #include <type_traits>
 
 /**
 \class ROOT::TSeq
 \brief A pseudo container class which is a generator of indices.
 
 \tparam T Type of the numerical sequence.
 \ingroup Containers
 A pseudo container class which is a generator of indices. The model is the `xrange`
 built-in function of Python.
 Possible usages:
 Loop on a sequence of integers
 ~~~{.cpp}
    for (auto i : TSeqI(10)) {
       cout << "Element " << i << endl;
    }
 ~~~
 Loop on a sequence of integers in steps
 ~~~{.cpp}
    for (auto i : TSeqI(-5, 29, 6)) {
       cout << "Element " << i << endl;
    }
 ~~~
 Loop backwards on a sequence of integers
 ~~~{.cpp}
    for (auto i : TSeqI(50, 30, -3)) {
       cout << "Element " << i << endl;
    }
 ~~~
 Use an stl algorithm, for_each
 ~~~{.cpp}
    TSeqUL ulSeq(2,30,3);
    std::for_each(std::begin(ulSeq),std::end(ulSeq),[](ULong_t i){cout << "For each: " << i <<endl;});
 ~~~
 Random access:
 ~~~{.cpp}
    cout << "Random access: 3rd element is " << ulSeq[2] << endl;
 ~~~
 A function to create sequences inferring the type:
 ~~~{.cpp}
    for (auto i : MakeSeq(1000000000000UL, 1000000000003UL)) {
       cout << "Element " << i << endl;
    }
 ~~~
 
 **/
 
 namespace ROOT {
 
    template<class T>
    class TSeq {
    private:
       void checkIntegralType() {
          static_assert(std::is_integral<T>::value, "Only integral types are supported.");
       }
       const T fBegin;
       const T fEnd;
       const T fStep;
    public:
       using value_type = T;
       using difference_type = typename std::make_signed<T>::type;
 
       TSeq(T theEnd): fBegin(), fEnd(theEnd), fStep(1) {
          checkIntegralType();
       }
       TSeq(T theBegin, T theEnd, T theStep = 1):
         fBegin(theBegin), fEnd(theEnd), fStep(theStep) {
          checkIntegralType();
          R__ASSERT(fStep != 0 && "TSeq does not support steps of size 0.");
       }
 
       class iterator {
       private:
          T fCounter;
          T fStep;
       public:
          using iterator_category = std::random_access_iterator_tag;
          using value_type = T;
          using difference_type = typename std::make_signed<T>::type;
          using pointer = T *;
          using const_pointer = const T *;
          using reference = T &;
 
          iterator(T start, T step): fCounter(start), fStep(step) {}
          T operator*() const {
             return fCounter;
          }
          // equality
          bool operator==(const iterator &other) const {
             return fCounter == other.fCounter;
          }
          // inequality
          bool operator!=(const iterator &other) const {
             return fCounter != other.fCounter;
          }
          // sum with integer
          iterator operator+(difference_type v) const {
             return iterator(fCounter + v * fStep, fStep);
          }
          // difference with integer
          iterator operator-(difference_type v) const {
             return iterator(fCounter - v * fStep, fStep);
          }
          // distance
          difference_type operator-(const iterator &other) const {
             return (fCounter - other.fCounter) / fStep;
          }
          // increments
          iterator &operator++() {
             fCounter += fStep;
             return *this;
          }
          iterator operator++(int) {
             iterator tmp(*this);
             operator++();
             return tmp;
          }
          // decrements
          iterator &operator--() {
             fCounter -= fStep;
             return *this;
          }
          iterator operator--(int) {
             iterator tmp(*this);
             operator--();
             return tmp;
          }
          // compound assignments
          iterator &operator+=(const difference_type& v) {
             *this = *this + v;
             return *this;
          }
          iterator &operator-=(const difference_type& v) {
             *this = *this - v;
             return *this;
          }
          // comparison operators
          bool operator <(const iterator &other) const {
              return (other - *this) > 0;
          }
          bool operator >(const iterator &other) const {
              return other < *this;
          }
          bool operator <=(const iterator &other) const {
              return !(*this > other);
          }
          bool operator >=(const iterator &other) const {
              return !(other > *this);
          }
          // subscript operator
          const T operator[](const difference_type& v) const{
              return *(*this + v);
          }
       };
 
       iterator begin() const {
          return iterator(fBegin, fStep);
       }
       iterator end() const {
          auto isStepMultiple = (fEnd - fBegin) % fStep == 0;
          auto theEnd = isStepMultiple ? fEnd : fStep * (((fEnd - fBegin) / fStep) + 1) + fBegin;
          return iterator(theEnd, fStep);
       }
 
       T const &front() const {
          return fBegin;
       }
 
       T operator[](T s) const {
          return s * fStep + fBegin;
       }
 
       std::size_t size() const {
          return end() - begin();
       }
 
       T step() const {
          return fStep;
       }
 
       bool empty() const {
          return fEnd == fBegin;
       }
 
    };
 
    using TSeqI = TSeq<int>;
    using TSeqU = TSeq<unsigned int>;
    using TSeqL = TSeq<long>;
    using TSeqUL = TSeq<unsigned long>;
 
    template<class T>
    TSeq<T> MakeSeq(T end)
    {
       return TSeq<T>(end);
    }
 
    template<class T>
    TSeq<T> MakeSeq(T begin, T end, T step = 1)
    {
       return TSeq<T>(begin, end, step);
    }
 
 }
 
 #include <sstream>
 
 ////////////////////////////////////////////////////////////////////////////////
 /// Print a TSeq at the prompt:
 
 namespace cling {
    template<class T>
    std::string printValue(ROOT::TSeq<T> *val)
    {
       std::ostringstream ret;
       auto step = val->step();
       ret << "A sequence of values: " << *val->begin() << ((step > 0) ? " <= i < " : " >= i > ") << *val->end();
       if (1 != step)
           ret << " in steps of " <<  step;
       return ret.str();
    }
 }
 
 #endif

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