Range.h

Go to the documentation of this file.

#ifndef GAUDI_RANGE_H
#define GAUDI_RANGE_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <utility>
#include <vector>
#include <algorithm>
// ============================================================================
// 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
// ============================================================================