SmartRanges.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_SMARTRANGES_H
#define GAUDIKERNEL_SMARTRANGES_H 1
// ============================================================================
// STD&STL
// ============================================================================
#include <cassert>
#include <limits>
// ============================================================================
// Gaudikernel
// ============================================================================
// #include "GaudiKernel/Range.h"
#include "Range.h"
// ============================================================================
// boost
// ============================================================================
#include "boost/iterator/iterator_facade.hpp"
#include "boost/iterator/filter_iterator.hpp"
#include "boost/iterator/transform_iterator.hpp"
// ============================================================================
// ============================================================================
namespace Gaudi
{
  // ==========================================================================
  namespace details
  {
    // ========================================================================
    template <class ITERATOR, class MASK>
    class masked_iterator
      : public boost::iterator_facade<masked_iterator<ITERATOR,MASK>,
                                      typename std::iterator_traits<ITERATOR>::value_type,
                                      boost::forward_traversal_tag,
                                      typename std::iterator_traits<ITERATOR>::reference,
                                      typename std::iterator_traits<ITERATOR>::difference_type>
    {
    public:
      // ========================================================================
      // masked_iterator() = default ;
      masked_iterator ( const MASK& mask , ITERATOR b )
        : m_iterator ( b    )
        , m_mask     ( mask )
        , m_index    ( mask.find_first() )
      {
        if ( MASK::npos != m_index ) { std::advance ( m_iterator , m_index ) ; }
      }
      // ========================================================================
      masked_iterator ( MASK&& mask , ITERATOR b )
        : m_iterator ( b )
        , m_mask     ( mask )
        , m_index    ( mask.find_first() )
      {
        if ( MASK::npos != m_index ) { std::advance ( m_iterator , m_index ) ; }
      }
      // ========================================================================
      masked_iterator ()
        : m_iterator ()
        , m_mask     ()
        , m_index    ( MASK::npos )
      {}
      // ========================================================================
    private:
      // ========================================================================
      friend class boost::iterator_core_access ;
      void increment()
      {
        const size_t m = m_mask.find_next( m_index  ) ;
        if ( m != MASK::npos )  { std::advance ( m_iterator , m - m_index ) ; }
        m_index = m ;
      }
      // ========================================================================
      typename std::iterator_traits<ITERATOR>::reference
      dereference  () const { return *m_iterator ; }
      // ========================================================================
      bool equal( const masked_iterator& other ) const
      { return m_index == other.m_index ; }
      // ========================================================================
    private:
      // ========================================================================
      ITERATOR m_iterator ;
      MASK     m_mask     ;
      size_t   m_index    ;
      // ========================================================================
    };
    // ==========================================================================
    template <class ITERATOR, class INDICES>
    class index_iterator :
      public boost::iterator_facade<index_iterator<ITERATOR,INDICES>,
                                    typename std::iterator_traits<ITERATOR>::value_type,
                                    boost::forward_traversal_tag,
                                    typename std::iterator_traits<ITERATOR>::reference,
                                    typename std::iterator_traits<ITERATOR>::difference_type>
    {
    public:
      // ========================================================================
      index_iterator ( const INDICES& indices , ITERATOR b , ITERATOR e )
        : m_begin    ( b )
        , m_size     ( std::distance ( b , e ) )
        , m_indices  ( indices )
        , m_index    ( 0 )
      {}
      // ========================================================================
      index_iterator (  INDICES&& indices , ITERATOR b , ITERATOR e )
        : m_begin    ( b )
        , m_size     ( std::distance ( b , e ) )
        , m_indices  ( indices )
        , m_index    ( 0 )
      {}
      // ========================================================================
      index_iterator ()
        : m_begin    (   )
        , m_size     ( 0 )
        , m_indices  (   )
        , m_index    ( 0 )
      {}
      // ========================================================================
    private:
      // ========================================================================
      friend class boost::iterator_core_access ;
      void increment()
      {
        if ( m_index < m_indices.size() )
        {
          // 1. advance
          ++m_index ;
          // 2. advance further, if out of range
          if ( m_size <= m_indices[m_index] ) { increment () ; }
        }
      }
      typename std::iterator_traits<ITERATOR>::reference dereference  () const
      {
        ITERATOR it = m_begin ;
        if ( m_index < m_indices.size() )
        { it = std::next ( m_begin , m_indices[ m_index ] ) ; }
        return *it;
      }
      // ========================================================================
      bool equal( const index_iterator& other ) const
      {
        if  ( m_index == other.m_index && m_indices.size() == other.m_indices.size() ) { return true ; }
        return  // special stuff to catch "end"
          (       m_index ==       m_indices.size() ) &&
          ( other.m_index == other.m_indices.size() ) ;
      }
      // ========================================================================
    private:
      // ========================================================================
      ITERATOR    m_begin    ;
      std::size_t m_size     ;
      INDICES     m_indices  ;
      std::size_t m_index    ;
      // ======================================================================
    };
    // =======================================================================
  } // end of namespace Gaudi::details
  // =========================================================================
  template <class PREDICATE,class CONTAINER>
  inline
  Gaudi::Range_<typename Gaudi::details::container<CONTAINER>::Container,
                boost::filter_iterator<PREDICATE,typename Gaudi::details::container<CONTAINER>::Iterator> >
  make_filter_range ( PREDICATE p , const CONTAINER& c )
  {
    typedef  boost::filter_iterator<PREDICATE,typename Gaudi::details::container<CONTAINER>::Iterator> ITER ;
    return { ITER( p , c.begin() ) , ITER ( p , c.end  () ) } ;
  }
  // ==========================================================================
  template <class FUNCTOR,class CONTAINER>
  inline
  Gaudi::Range_<typename Gaudi::details::container<CONTAINER>::Container,
                boost::transform_iterator<FUNCTOR,typename Gaudi::details::container<CONTAINER>::Iterator> >
  make_transform_range ( FUNCTOR f , const CONTAINER& c )
  {
    typedef boost::transform_iterator<FUNCTOR,typename Gaudi::details::container<CONTAINER>::Iterator> ITER ;
    return { ITER ( c.begin() , f ) , ITER ( c.end  () , f ) } ;
  }
  // ==========================================================================
  template<class MASK, class CONTAINER>
  inline
  Gaudi::Range_<typename Gaudi::details::container<CONTAINER>::Container,
                Gaudi::details::masked_iterator<typename Gaudi::details::container<CONTAINER>::Iterator,MASK> >
  make_mask_range ( MASK m , const CONTAINER& c )
  {
    typedef Gaudi::details::masked_iterator<typename Gaudi::details::container<CONTAINER>::Iterator,MASK> ITER ;
    if ( m.size() > c.size() ) { m.resize( c.size() ) ; }
    return { ITER ( std::move(m) , c.begin() ) , ITER () } ;
  }
  // ============================================================================
  template<class INDICES, class CONTAINER>
  inline
  Gaudi::Range_<typename Gaudi::details::container<CONTAINER>::Container,
         Gaudi::details::index_iterator<typename Gaudi::details::container<CONTAINER>::Iterator,INDICES>>
  make_index_range ( INDICES m , const CONTAINER& c )
  {
    static_assert(  std::is_convertible<typename INDICES::value_type,std::size_t>::value  ,"index type is not convertible") ;
    static_assert(  std::numeric_limits<typename INDICES::value_type>::is_specialized     ,"index type is not specialized") ;
    static_assert( !std::numeric_limits<typename INDICES::value_type>::is_signed          ,"index type must be unsigned"  ) ;
    typedef Gaudi::details::index_iterator<typename Gaudi::details::container<CONTAINER>::Iterator,INDICES> ITER ;
    return { ITER ( std::move(m) , c.begin() , c.end() ) , ITER () } ;
  }
  // =========================================================================
}
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIKERNEL_SMARTRANGES_H
// ============================================================================