iterator_intf.h

Go to the documentation of this file.

 
#ifndef _ADTF_UCOM_ANT_ITERATOR_INTERFACE_INCLUDES_HEADER_
#define _ADTF_UCOM_ANT_ITERATOR_INTERFACE_INCLUDES_HEADER_
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
//forward declarations for usage in POD types
template<typename> class IForwardIterator;
template<typename> class IBidirectionalIterator;
template<typename> class IRandomAccessIterator;
 
template<typename T>
struct pointer_iterator {};
 
template<typename T>
struct forward_iterator
{
    //necessary types for iterators in general
    typedef T                               value_type;             
    typedef forward_iterator<T>             self_type;              
    typedef T*                              pointer;                
    typedef const T*                        const_pointer;          
    typedef T&                              reference;              
    typedef const T&                        const_reference;        
    typedef std::forward_iterator_tag       iterator_category;      
    typedef std::ptrdiff_t                  difference_type;        
 
    self_type operator++()                  { m_pCur = m_pIt->Next(); return *this;  }
 
    self_type operator++(int32_t)            { self_type oTmp = *this; ++(*this); return oTmp; }
 
    pointer operator->()                    { return m_pCur; }
 
    const_pointer operator->() const        { return m_pCur; }
 
    reference operator*()                   { return *m_pCur; }
 
    const_reference operator*() const       { return *m_pCur; }
 
private:
    typedef typename std::conditional<
        std::is_const<value_type>::value,
        const IForwardIterator<T>*,
        IForwardIterator<T>*>::type         iterator_interface_pointer;
 
    //friend access
    template<typename, template<typename> class> friend struct iterator_adapter;
 
    iterator_interface_pointer  m_pIt;  
    pointer                     m_pCur; 
};//struct input_iterator_adapter<T>
 
template<typename T>
inline bool operator< (const forward_iterator<T>& oLHS, const forward_iterator<T>& oRHS) noexcept
{
    return oLHS.operator->() < oRHS.operator->();
}
 
template<typename T>
inline bool operator> (const forward_iterator<T>& oLHS, const forward_iterator<T>& oRHS) noexcept
{
    return oRHS < oLHS;
}
 
template<typename T>
inline bool operator<= (const forward_iterator<T>& oLHS, const forward_iterator<T>& oRHS) noexcept
{
    return !(oLHS > oRHS);
}
 
template<typename T>
inline bool operator>= (const forward_iterator<T>& oLHS, const forward_iterator<T>& oRHS) noexcept
{
    return !(oLHS < oRHS);
}
 
template<typename T>
inline bool operator== (const forward_iterator<T>& oLHS, const forward_iterator<T>& oRHS) noexcept
{
    return !(oLHS < oRHS) && !(oLHS > oRHS);
}
 
template<typename T>
inline bool operator!= (const forward_iterator<T>& oLHS, const forward_iterator<T>& oRHS) noexcept
{
    return !(oLHS == oRHS);
}
 
template<typename T, template<typename> class IteratorType = forward_iterator>
struct iterator_adapter
{
    //needed types for adapter/containers
    typedef T                                           value_type;     
    typedef iterator_adapter<value_type, IteratorType>  self_type;      
    typedef IteratorType<const value_type>              const_iterator; 
    typedef typename std::conditional <
        std::is_const<value_type>::value,
        const_iterator,
        IteratorType < value_type >>::type              iterator;       
 
    iterator begin() const        { return m_oBegin; }
 
    iterator end() const          { return m_oEnd; }
 
    const_iterator cbegin() const { return begin(); }
 
    const_iterator cend() const   { return end(); }
 
private:
    //friend class access for assignment
    template<typename, template<typename> class> friend class cForwardIterator;
 
    template<typename IteratorInterfaceType>
    static self_type create(IteratorInterfaceType& o_oIterator)
    {   //create both iterators which are members of iterator_adapter
        iterator_adapter oTmpContainer;
        oTmpContainer.m_oBegin.m_pIt  = &o_oIterator;
        oTmpContainer.m_oBegin.m_pCur = o_oIterator.Begin();
        oTmpContainer.m_oEnd.m_pIt    = &o_oIterator;
        oTmpContainer.m_oEnd.m_pCur   = o_oIterator.End();
        return oTmpContainer;
    }
 
    iterator m_oBegin; 
    iterator m_oEnd;   
};//struct iterator_adapter
 
template<typename T>
struct iterator_adapter<T, pointer_iterator>
{
    typedef T                                              value_type;     
    typedef iterator_adapter<value_type, pointer_iterator> self_type;      
    typedef const value_type*                              const_iterator; 
    typedef typename std::conditional <
        std::is_const<value_type>::value,
        const_iterator,
        value_type*> ::type                                iterator;       
 
    iterator begin() const          { return m_oBegin; }
 
    iterator end() const            { return m_oEnd; }
 
    const_iterator cbegin() const   { return begin(); }
 
    const_iterator cend() const     { return end(); }
 
    static self_type create(iterator i_oBegin, iterator i_oEnd)
    {   //create both iterators which are members of iterator_adapter
        iterator_adapter oTmpContainer;
        oTmpContainer.m_oBegin = i_oBegin;
        oTmpContainer.m_oEnd = i_oEnd;
        return oTmpContainer;
    }
 
private:
    iterator m_oBegin; 
    iterator m_oEnd;   
};//struct iterator_adapter
 
template<typename T>
class IForwardIterator
{
public:
    virtual T* Next() const = 0;  //mutable must be used
 
protected:
    ~IForwardIterator() = default;
};//class IForwardIterator
 
template<typename T>
class IBidirectionalIterator : public IForwardIterator<T>
{
public:
    virtual T* Previous() const = 0; //mutable must be used
 
protected:
    ~IBidirectionalIterator() = default;
};//class IBidirectionalIterator
 
template<typename T>
class IRandomAccessIterator : public IBidirectionalIterator<T>
{
public:
    virtual T* Forward(size_t i_nIncrement) const = 0;  //mutable must be used
 
    virtual T* Backward(size_t i_nDecrement) const = 0; //mutable must be used
 
protected:
    ~IRandomAccessIterator() = default;
};//class IRandomAccessIterator
 
}//ns ant
 
template<typename T>
using IForwardIterator = ant::IForwardIterator<T>;
 
template<typename T>
using IBidirectionalIterator = ant::IBidirectionalIterator<T>;
 
template<typename T>
using IRandomAccessIterator = ant::IRandomAccessIterator<T>;
 
template<typename T, template<typename> class IteratorType = ant::forward_iterator>
using iterator_adapter = ant::iterator_adapter<T, IteratorType>;
 
template<typename T>
using pointer_iterator = ant::pointer_iterator<T>;
 
template<typename T>
using forward_iterator = ant::forward_iterator<T>;
 
}//ns ucom
}//ns adtf
 
#endif // _ADTF_UCOM_ANT_ITERATOR_INTERFACE_INCLUDES_HEADER_