Range.h

Go to the documentation of this file.

#ifndef GAUDI_RANGE_H
#define GAUDI_RANGE_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <algorithm>
#include <utility>
#include <vector>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/Kernel.h"
// ============================================================================
// ============================================================================
namespace Gaudi
{
  // ==========================================================================
  namespace details
  {
    // ========================================================================
    GAUDI_API void rangeException( const long index, const size_t size );
    // ========================================================================
    template <typename T>
    struct _has_typename_container_ {
    private:
      template <typename T1>
      static typename T1::Container test( int );
      template <typename>
      static void test( ... );

    public:
      enum { value = !std::is_void<decltype( test<T>( 0 ) )>::value };
    };
    template <class CONTAINER, bool>
    struct _container;
    template <class CONTAINER>
    struct _container<CONTAINER, true> {
      typedef typename CONTAINER::Container Container;
    };
    template <class CONTAINER>
    struct _container<CONTAINER, false> {
      typedef CONTAINER Container;
    };
    // ==========================================================================
    template <class CONTAINER>
    struct container {
      typedef typename details::_container<CONTAINER, details::_has_typename_container_<CONTAINER>::value>::Container
          Container;
      typedef typename CONTAINER::const_iterator Iterator;
    };
    // =========================================================================
  } // the end of namespace Gaudi::details
  // ==========================================================================
  struct RangeBase_ {
  };
  // ==========================================================================
  template <class CONTAINER, class ITERATOR = typename Gaudi::details::container<CONTAINER>::Iterator>
  class Range_ : public RangeBase_
  {
  public:
    // ========================================================================
    typedef std::pair<ITERATOR, ITERATOR> Base;
    // ========================================================================
  public:
    // ========================================================================
    typedef typename Gaudi::details::container<CONTAINER>::Container Container;
    //
    typedef ITERATOR iterator;
    typedef ITERATOR const_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;
    // ========================================================================
  public:
    // ========================================================================
    Range_() = default;
    Range_( iterator ibegin, iterator iend ) : m_base( ibegin, iend ) {}
    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_();
      } // RETURN
      // adjust indices
      if ( index1 < 0 ) {
        index1 += size();
      }
      if ( index2 < 0 ) {
        index2 += size();
      }
      // check
      if ( index1 < 0 ) {
        return Range_();
      } // RETURN
      if ( index2 < index1 ) {
        return Range_();
      } // RETURN

      if ( index1 > (long)size() ) {
        return Range_();
      } // RETURN
      if ( index2 > (long)size() ) {
        index2 = size();
      }

      // construct the slice
      return Range_( std::next( begin(), index1 ), std::next( begin(), index2 ) ); // RETURN
    }
    // ========================================================================
    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 );
    }
    // ========================================================================
  public:
    // ========================================================================
    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() );
    }
    // ========================================================================
  public:
    // ========================================================================
    bool operator==( const Range_& right ) const
    {
      if ( &right == this ) {
        return true;
      } // RETURN
      return right.size() == size() && std::equal( begin(), end(), right.begin() );
    }
    template <class CNT, class IT>
    bool operator==( const Range_<CNT, IT>& right ) const
    {
      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() );
    }
    // ========================================================================
  public:
    // ========================================================================
    bool operator!() const { return empty(); }
    explicit operator bool() const { return !empty(); }
    // ========================================================================
  public:
    // ========================================================================
    operator const Base&() const { return base(); }
    inline const Base& base() const { return m_base; }
    // ========================================================================
  private:
    // ========================================================================
    // the base itself
    Base m_base; 
    // ========================================================================
  }; // end of class Range_
  // ==========================================================================
  template <class CONTAINER>
  inline Range_<CONTAINER> range( const CONTAINER& cnt )
  {
    return Range_<CONTAINER>( cnt.begin(), cnt.end() );
  }
  // ==========================================================================
} // end of namespace Gaudi
// ============================================================================
// The END
// ============================================================================
#endif // GAUDI_RANGE_H
// ============================================================================