RangedItr.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef DERIVATIONFRAMEWORKTRIGGER_RANGEDITR_H
#define DERIVATIONFRAMEWORKTRIGGER_RANGEDITR_H
 
 
#include <iterator> //std::distance, iterator_traits
#include <type_traits>
 
namespace DerivationFramework { namespace TriggerMatchingUtils {
template <typename T>
  class RangedItr {
    protected:
      using tr = std::iterator_traits<T>;
      static_assert(std::is_base_of<std::bidirectional_iterator_tag, typename tr::iterator_category>::value, "Templated type must be a random access iterator");
    public:
      // A full implementation of this idea would allow for any input
      // iterator type. For this version, just require at least bidirectional
 
      using iterator_category = std::bidirectional_iterator_tag;
      using value_type      = typename tr::value_type;
      using reference       = typename tr::reference;
      using pointer         = typename tr::pointer;
      using difference_type = typename tr::difference_type;
 
      RangedItr() = default;
 
      RangedItr(const T& begin, const T& end) : 
        RangedItr(begin, end, begin) {}
 
      RangedItr(const T& begin, const T& end, const T& position) :
        m_begin(begin), m_end(end), m_position(position) {}
 
      reference operator*() { return m_position.operator*(); }
      pointer operator->() { return m_position.operator->(); }
 
      RangedItr& operator++() {
        ++m_position;
        return *this;
      }
      RangedItr operator++(int) {
        RangedItr ret = *this;
        ++m_position;
        return ret;
      }
 
      RangedItr& operator--() {
        --m_position;
        return *this;
      }
      RangedItr operator--(int) {
        RangedItr ret = *this;
        --m_position;
        return ret;
      }
 
      bool operator==(const RangedItr& other) {
        return m_begin == other.m_begin &&
                m_end == other.m_end &&
                m_position == other.m_position;
      }
 
      bool operator!=(const RangedItr& other) {
        return !(*this == other);
      }
 
      bool exhausted() const { return m_position == m_end; }
 
      void restart() { m_position = m_begin; }
 
      RangedItr begin() const { return RangedItr(m_begin, m_end, m_begin); }
      RangedItr end() const { return RangedItr(m_begin, m_end, m_end); }
      difference_type size() const { return std::distance(m_begin, m_end); }
 
      operator T() const { return m_position; }
    private:
      T m_begin;
      T m_end;
      T m_position;
 
  }; //> end class RangedItr
} } //> end namespace DerivationFramework::TriggerMatchingUtils
#endif //> !DERIVATIONFRAMEWORKTRIGGER_RANGEDITR_H