iteradapt.hpp

Go to the documentation of this file.

/*****************************************************************************

    iteradapt.hpp -- Iterator utilities declaration and implementation.

    WARNING. Implementation of 'Iterpair' is temporary limited.

    Copyright (C) Sergey S. Lyalin, 2005

    16.04.2005

*****************************************************************************/

#ifndef _ARAGELI_UTILS_iteradapt_hpp_
#define _ARAGELI_UTILS_iteradapt_hpp_

#include "config.hpp"

#include <iterator>


namespace Arageli
{


// Iterator adapter with base iterator type TB and adaptation functor type F
// Functor F must operate with reference on base element type of base iterator.
// T -- is value type for new iterator type
template <typename T, typename TB, typename F>
class apply_iterator :
    public std::iterator
    <
        typename std::iterator_traits<TB>::iterator_category,
        T,
        typename std::iterator_traits<TB>::difference_type,
        T*,
        T&
    >
{
    typedef std::iterator_traits<TB> Iterbase;

    template <typename T1, typename TB1, typename F1>
    friend class apply_iterator;

public:

    typedef TB base_iterator;
    typedef F function;

    apply_iterator () {}

    template <typename T1, typename TB1, typename F1>
    apply_iterator (const apply_iterator<T1, TB1, F1>& x)
    : fu(x.fu), iter(x.iter) {}
    
    explicit apply_iterator (const base_iterator& iter_a, const function& fu_a = function())
    : iter(iter_a), fu(fu_a) {}
    
    explicit apply_iterator (const function& fu_a) : fu(fu_a) {}

    const base_iterator& base () const { return iter; }
    base_iterator& base () { return iter; }
    const function& adapter () const { return fu; }
    function& adapter () { return fu; }

    T* operator-> () const { return &fu(*iter); }
    T& operator* () const { return fu(*iter); }

    apply_iterator& operator++ () { ++iter; return *this; }
    apply_iterator& operator-- () { --iter; return *this; }
    
    apply_iterator operator++ (int)
    {
        apply_iterator t = *this;
        operator++();
        return t;
    }
    
    apply_iterator operator-- (int)
    {
        apply_iterator t = *this;
        operator--();
        return t;
    }
    
    apply_iterator& operator+= (typename Iterbase::difference_type n)
    { iter += n; return *this; }
    
    apply_iterator& operator-= (typename Iterbase::difference_type n)
    { iter += n; return *this; }
    
    T& operator[] (typename Iterbase::difference_type n) const
    { return fu(iter[n]); }
    
private:

    function fu;
    base_iterator iter;

};


template <typename T, typename TB, typename F>
apply_iterator<T, TB, F> operator+
(apply_iterator<T, TB, F> x, typename apply_iterator<T, TB, F>::difference_type n)
{ return x += n; }


template <typename T, typename TB, typename F>
apply_iterator<T, TB, F> operator-
(apply_iterator<T, TB, F> x, typename apply_iterator<T, TB, F>::difference_type n)
{ return x -= n; }


template <typename T, typename TB, typename F>
inline typename std::iterator_traits<TB>::difference_type operator-
(const apply_iterator<T, TB, F>& a, const apply_iterator<T, TB, F>& b)
{ return a.base() - b.base(); }


#define _ARAGELI_ITERADAPT_CMP_OPER(OPER)           \
    template <typename T, typename TB, typename F>  \
    inline bool operator OPER                       \
    (                                               \
        const apply_iterator<T, TB, F>& a,          \
        const apply_iterator<T, TB, F>& b           \
    )                                               \
    { return a.base() OPER b.base(); }


_ARAGELI_ITERADAPT_CMP_OPER(==)
_ARAGELI_ITERADAPT_CMP_OPER(!=)
_ARAGELI_ITERADAPT_CMP_OPER(<)
_ARAGELI_ITERADAPT_CMP_OPER(>)
_ARAGELI_ITERADAPT_CMP_OPER(<=)
_ARAGELI_ITERADAPT_CMP_OPER(>=)




template <typename T1, typename T2>
struct Min_iterator_traits;


// Iterator pair incapsulates two iterators and represented virtual sequence as
// element sequence generated by functor F object. Suppose TB2 iterator is
// more 'flexible' iterator then TB1 iterator. That's if some operation is applicable
// for type TB1 then one is applicable for type TB2. This nonsymmetrical situation is
// temporary.
template <typename T, typename TB1, typename TB2, typename F>
class Iterpair :
    public std::iterator
    <
        //typename Min_iterator_traits<TB1, TB2>::iterator_category,
        typename std::iterator_traits<TB1>::iterator_category,
        T,
        //typename Min_iterator_traits<TB1, TB2>::difference_type,
        typename std::iterator_traits<TB1>::difference_type,
        T*,
        T&
    >
{
    //typedef Min_iterator_traits<TB1, TB2> Iterbase;
    typedef std::iterator_traits<TB1> Iterbase;

public:

    typedef TB1 Base_first;
    typedef TB2 Base_second;
    typedef F function; // REMARK: may be some other name is better for this type

    Iterpair () {}
    Iterpair
    (
        const Base_first& iterf_a,
        const Base_second& iters_a,
        const function& fu_a = function()
    )
    :   iterf(iterf_a),
        iters(iters_a),
        fu(fu_a)
    {}

    Iterpair (const function& fu_a) : fu(fu_a) {}

    const Base_first& base_first () const { return iterf; }
    Base_first& base_first () { return iterf; }
    const Base_second& base_second () const { return iters; }
    Base_second& base_second () { return iters; }

    // WARNING! Why name is `unitor'? Recall the renaming history.
    const function& unitor () const { return fu; }
    function& unitor () { return fu; }

    T* operator-> () const { return &fu(*iterf, *iters); }  // may be problems
    typename F::result_type operator* () const { return fu(*iterf, *iters); }

    Iterpair& operator++ () { ++iterf; ++iters; return *this; }
    Iterpair& operator-- () { --iterf; --iters; return *this; }
    
    Iterpair& operator+= (typename Iterbase::difference_type n)
    { iterf += n; iters += n; return *this; }
    
    Iterpair& operator-= (typename Iterbase::difference_type n)
    { iterf += n; iters += n; return *this; }
    
    typename F::result_type operator[] (typename Iterbase::difference_type n) const
    { return fu(iterf[n], iters[n]); }
    
    Iterpair operator+ (typename Iterbase::difference_type n)
    { return Iterpair(iterf + n, iters + n, fu); }
    
    Iterpair operator- (typename Iterbase::difference_type n)
    { return Iterpair(iterf - n, iters - n, fu); }

private:

    function fu;
    Base_first iterf;
    Base_second iters;

};


template <typename T, typename TB1, typename TB2, typename F>
inline typename std::iterator_traits<TB1>::difference_type operator-
(const Iterpair<T, TB1, TB2, F>& a, const Iterpair<T, TB1, TB2, F>& b)
{ return a.base_first() - b.base_first(); }


template <typename T, typename TB1, typename TB2, typename F>
inline bool operator== (const Iterpair<T, TB1, TB2, F>& a, const Iterpair<T, TB1, TB2, F>& b)
{ return a.base_first() == b.base_first(); }

template <typename T, typename TB1, typename TB2, typename F>
inline bool operator!= (const Iterpair<T, TB1, TB2, F>& a, const Iterpair<T, TB1, TB2, F>& b)
{ return a.base_first() != b.base_first(); }

template <typename T, typename TB1, typename TB2, typename F>
inline bool operator< (const Iterpair<T, TB1, TB2, F>& a, const Iterpair<T, TB1, TB2, F>& b)
{ return a.base_first() < b.base_first(); }

template <typename T, typename TB1, typename TB2, typename F>
inline bool operator> (const Iterpair<T, TB1, TB2, F>& a, const Iterpair<T, TB1, TB2, F>& b)
{ return a.base_first() > b.base_first(); }

template <typename T, typename TB1, typename TB2, typename F>
inline bool operator<= (const Iterpair<T, TB1, TB2, F>& a, const Iterpair<T, TB1, TB2, F>& b)
{ return a.base_first() == b.base_first(); }

template <typename T, typename TB1, typename TB2, typename F>
inline bool operator>= (const Iterpair<T, TB1, TB2, F>& a, const Iterpair<T, TB1, TB2, F>& b)
{ return a.base_first() >= b.base_first(); }


// -------------------------------------------------------

//template <typename Iter_base>
//class slice_iterator :
//  public std::iterator
//  <
//      typename std::iterator_traits<Iter_base>::iterator_category,
//      typename std::iterator_traits<Iter_base>::value_type,
//      typename std::iterator_traits<Iter_base>::difference_type,
//      typename std::iterator_traits<Iter_base>::pointer,
//      typename std::iterator_traits<Iter_base>::reference
//  >
//{
//public:
//  typedef typename std::iterator_traits<Iter_base>::value_type value_type;
//  typedef typename std::iterator_traits<Iter_base>::value_type difference_type;
//
//
//};


} // namespace Arageli


#endif // #ifndef _ARAGELI_UTILS_iteradapt_hpp_

---