Range.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/Kernel.h>
#include <GaudiKernel/detected.h>
#include <algorithm>
#include <utility>
 
namespace Gaudi {
  namespace details {
    GAUDI_API void rangeException( const long index, const size_t size );
 
    template <class CONTAINER>
    struct container {
      template <typename T>
      using _has_container_t = typename T::Container;
      using Container        = Gaudi::cpp17::detected_or_t<CONTAINER, _has_container_t, CONTAINER>;
    };
  } // namespace details
 
  struct RangeBase_ {};
 
  template <class CONTAINER, class ITERATOR = typename CONTAINER::const_iterator>
  class Range_ : public RangeBase_ {
    // FIXME: prepare for removal of ITERATOR argument: check whether the default is _always_ used
    static_assert( std::is_same_v<ITERATOR, typename CONTAINER::const_iterator> );
 
  public:
    using Container      = typename Gaudi::details::container<CONTAINER>::Container;
    using const_iterator = typename CONTAINER::const_iterator;
    using iterator       = const_iterator;
    using Base           = std::pair<iterator, iterator>;
 
  private:
    typedef typename std::iterator_traits<iterator> iter_traits;
 
  public:
    typedef typename iter_traits::value_type value_type;
    typedef typename iter_traits::reference  reference;
    typedef typename iter_traits::reference  const_reference;
 
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<iterator> const_reverse_iterator;
 
    Range_() = default;
    template <typename InputIterator>
    Range_( InputIterator first, InputIterator last ) : m_base( first, last ) {}
    Range_( const Base& base ) : m_base( base ) {}
    Range_( const Container& cont ) : m_base( cont.begin(), cont.end() ) {}
    /* constructor of empty range/sequence
     * @param ibegin  iterator to begin of empty sequence
     */
    Range_( iterator ibegin ) : m_base( ibegin, ibegin ) {}
 
    ~Range_() = default;
 
    bool empty() const { return m_base.second == m_base.first; }
    size_t size() const { return std::distance( m_base.first, m_base.second ); }
    iterator begin() const { return m_base.first; }
    iterator end() const { return m_base.second; }
    iterator cbegin() const { return m_base.first; }
    iterator cend() const { return m_base.second; }
    reverse_iterator rbegin() const { return reverse_iterator( end() ); }
    reverse_iterator rend() const { return reverse_iterator( begin() ); }
    const_reference front() const { return *begin(); }
    const_reference back() const { return *std::prev( end() ); }
 
    Range_ slice( long index1, long index2 ) const {
      // trivial cases
      if ( empty() || index1 == index2 ) { return Range_(); }
      // adjust indices
      if ( index1 < 0 ) { index1 += size(); }
      if ( index2 < 0 ) { index2 += size(); }
      // check
      if ( index1 < 0 ) { return Range_(); }
      if ( index2 < index1 ) { return Range_(); }
 
      if ( index1 > (long)size() ) { return Range_(); }
      if ( index2 > (long)size() ) { index2 = size(); }
 
      // construct the slice
      return Range_( std::next( begin(), index1 ), std::next( begin(), index2 ) );
    }
 
    inline const_reference operator()( const size_t index ) const { return *std::next( begin(), index ); }
    inline const_reference operator[]( const long index ) const { return ( *this )( index ); }
    inline const_reference at( const long index ) const {
      if ( index < 0 || index >= (long)size() ) { Gaudi::details::rangeException( index, size() ); }
      return ( *this )( index );
    }
 
    template <class C, class I>
    bool operator<( const Range_<C, I>& right ) const {
      return std::lexicographical_compare( begin(), end(), right.begin(), right.end() );
    }
    template <class ANOTHERCONTAINER>
    bool operator<( const ANOTHERCONTAINER& right ) const {
      return std::lexicographical_compare( begin(), end(), right.begin(), right.end() );
    }
 
    bool operator==( const Range_& right ) const {
      if ( &right == this ) { return true; }
      return right.size() == size() && std::equal( begin(), end(), right.begin() );
    }
    template <class ANOTHERCONTAINER>
    bool operator==( const ANOTHERCONTAINER& right ) const {
      return right.size() == size() && std::equal( begin(), end(), right.begin() );
    }
 
    bool operator!() const { return empty(); }
    explicit operator bool() const { return !empty(); }
 
    operator const Base&() const { return base(); }
    inline const Base& base() const { return m_base; }
 
  private:
    Base m_base; 
  };
 
  template <class CONTAINER>
  inline Range_<CONTAINER> range( const CONTAINER& cnt ) {
    return Range_<CONTAINER>( cnt.begin(), cnt.end() );
  }
} // namespace Gaudi