iterator.hpp

Go to the documentation of this file.

 
/*
 * This file is part of Algorithms library toolkit.
 * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
 
 * Algorithms library toolkit is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 
 * Algorithms library toolkit is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 
 * You should have received a copy of the GNU General Public License
 * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <iterator>
#include <functional>
 
namespace ext {
 
template <class Iterator>
class set_move_iterator {
    Iterator current;
 
public:
    typedef Iterator iterator_type;
 
    using iterator_category = typename std::iterator_traits < Iterator >::iterator_category;
 
    typedef typename std::iterator_traits<Iterator>::value_type        value_type;
 
    typedef value_type&& reference;
 
    typedef value_type* pointer;
 
    using difference_type = std::ptrdiff_t;
 
    explicit set_move_iterator (Iterator it) : current(it) {
    }
 
    iterator_type base() const {
        return current;
    }
 
    pointer operator->() const {
        return & ( this->operator * ( ) );
    }
 
    reference operator*() const {
        return std::move(const_cast<value_type&>(*current));
    }
 
    set_move_iterator& operator++() {
        ++current;
        return *this;
    }
 
    set_move_iterator& operator--() {
        --current;
        return *this;
    }
 
    set_move_iterator operator++(int) {
        set_move_iterator temp = *this;
        ++current;
        return temp;
    }
 
    set_move_iterator operator--(int) {
        set_move_iterator temp = *this;
        --current;
        return temp;
    }
 
    bool operator== (const set_move_iterator<Iterator>& other) const {
        return this->current == other.current;
    }
 
};
 
template<class Iterator>
set_move_iterator<Iterator> make_set_move_iterator (Iterator it) {
    return set_move_iterator<Iterator>(it);
}
 
template < class Iterator, class KeyType, class ValueType >
class map_move_iterator {
    static_assert ( ! std::is_const_v < std::remove_reference_t < KeyType > >, "KeyType of move iterator must not be const" );
 
    Iterator current;
 
public:
    typedef Iterator iterator_type;
 
    using iterator_category = typename std::iterator_traits < Iterator >::iterator_category;
 
    typedef typename std::pair < KeyType, ValueType > value_type;
 
    typedef value_type&& reference;
 
    typedef value_type* pointer;
 
    using difference_type = std::ptrdiff_t;
 
    explicit map_move_iterator (Iterator it) : current(it) {
    }
 
    iterator_type base() const {
        return current;
    }
 
    pointer operator->() const {
        return & ( this->operator * ( ) );
    }
 
    reference operator*() const {
        return std::move(reinterpret_cast < value_type & >(*current));
    }
 
    map_move_iterator& operator++() {
        ++current;
        return *this;
    }
 
    map_move_iterator& operator--() {
        --current;
        return *this;
    }
 
    map_move_iterator operator++(int) {
        map_move_iterator temp = *this;
        ++current;
        return temp;
    }
 
    map_move_iterator operator--(int) {
        map_move_iterator temp = *this;
        --current;
        return temp;
    }
 
    bool operator== (const map_move_iterator<Iterator, KeyType, ValueType>& other) const {
        return this->current == other.current;
    }
 
};
 
template < class T, class R, class Iterator>
map_move_iterator<Iterator, T, R> make_map_move_iterator (Iterator it) {
    return map_move_iterator<Iterator, T, R>(it);
}
 
template < class T >
class value_mover {
    T m_Container;
public:
    explicit value_mover ( T && param ) : m_Container ( std::move ( param ) ) {}
 
    auto begin ( ) {
        return std::move ( m_Container ).begin ( );
    }
 
    auto end ( ) {
        return std::move ( m_Container ).end ( );
    }
};
 
template < class T >
class reference_mover {
    T && m_Container;
public:
    explicit reference_mover ( T && param ) : m_Container ( std::move ( param ) ) {}
 
    auto begin ( ) {
        return std::move ( m_Container ).begin ( );
    }
 
    auto end ( ) {
        return std::move ( m_Container ).end ( );
    }
};
 
template < class T >
reference_mover < T > make_mover ( T & param ) {
    return reference_mover < T > ( std::move ( param ) );
}
 
template < class T >
value_mover < T > make_mover ( T && param ) {
    return value_mover < T > ( std::forward < T > ( param ) );
}
 
template < class T >
class reverser {
    T && m_Container;
 
public:
    explicit reverser ( T && container ) : m_Container ( std::forward < T && > ( container ) ) {
    }
 
    auto begin ( ) const {
        return m_Container.rbegin ( );
    }
 
    auto end ( ) const {
        return m_Container.rend ( );
    }
 
};
 
template < class T >
reverser < T > make_reverse ( T && container ) {
    return reverser < T > ( container );
}
 
template < class Iterator >
class dereferencing_iterator {
    Iterator m_base;
 
public:
    using pointer = typename std::iterator_traits < Iterator >::value_type;
 
    using value_type = typename std::conditional < std::is_const < typename std::remove_reference < typename std::iterator_traits < Iterator >::reference >::type >::value, typename std::add_const < typename std::remove_pointer < pointer >::type >::type, typename std::remove_pointer < pointer >::type >::type;
 
    using difference_type = std::ptrdiff_t;
 
    using reference = value_type &;
 
    using iterator_category = typename std::iterator_traits < Iterator >::iterator_category;
 
    explicit dereferencing_iterator ( Iterator base ) : m_base ( base ) {
    }
 
    template < class Iter >
    dereferencing_iterator ( const dereferencing_iterator < Iter > & iter ) : m_base ( iter.base ( ) ) {
    }
 
    reference operator * ( ) const {
        return * * m_base;
    }
 
    pointer operator -> ( ) const {
        return * m_base;
    }
 
    dereferencing_iterator < Iterator > & operator ++ ( ) {
        ++ m_base;
        return * this;
    }
 
    dereferencing_iterator < Iterator > operator ++ ( int ) {
        auto tmp = * this;
        ++ m_base;
        return tmp;
    }
 
    dereferencing_iterator < Iterator > & operator -- ( ) {
        -- m_base;
        return * this;
    }
 
    dereferencing_iterator < Iterator > operator -- ( int ) {
        auto tmp = * this;
        -- m_base;
        return tmp;
    }
 
    dereferencing_iterator < Iterator > & operator += ( int distance ) {
        m_base += distance;
        return *this;
    }
 
    dereferencing_iterator < Iterator > operator + ( int distance ) const {
        auto res = * this;
        res += distance;
        return res;
    }
 
    dereferencing_iterator < Iterator > & operator -= ( int distance ) {
        m_base -= distance;
        return *this;
    }
 
    dereferencing_iterator < Iterator > operator - ( int distance ) const {
        auto res = * this;
        res -= distance;
        return res;
    }
 
    reference operator [ ] ( int index ) const {
        return * ( m_base [ index ] );
    }
 
    difference_type operator - ( const dereferencing_iterator < Iterator > & other ) const {
        return m_base - other.m_base;
    }
 
    bool operator == ( const dereferencing_iterator < Iterator > & other ) const {
        return this->m_base == other.m_base;
    }
 
    auto operator <=> ( const dereferencing_iterator < Iterator > & other ) const {
        return this->m_base < other.m_base;
    }
 
    Iterator base ( ) const {
        return m_base;
    }
 
};
 
template < class Iterator >
dereferencing_iterator < Iterator > dereferencer ( Iterator iter ) {
    return dereferencing_iterator < Iterator > ( iter );
}
 
template < typename InputIterator, typename Distance >
inline constexpr void retractInternal ( InputIterator & i, Distance n, std::input_iterator_tag ) {
    assert ( n <= 0 );
    while ( n ++ )
        ++ i;
}
 
template < typename BidirectionalIterator, typename Distance >
inline constexpr void retractInternal ( BidirectionalIterator & i, Distance n, std::bidirectional_iterator_tag ) {
    if ( n > 0)
        while ( n -- )
            -- i;
    else
        while ( n ++ )
            ++ i;
}
 
template < typename RandomAccessIterator, typename Distance >
inline constexpr void retractInternal ( RandomAccessIterator & i, Distance n, std::random_access_iterator_tag ) {
    i -= n;
}
 
template < typename Iterator, typename Distance >
inline constexpr void retract ( Iterator & i, Distance n ) {
    typename std::iterator_traits < Iterator >::difference_type d = n;
    retractInternal ( i, d, typename std::iterator_traits < Iterator >::iterator_category ( ) );
}
 
template < class Container >
auto begin ( Container && cont ) -> decltype ( std::forward ( cont ).begin ( ) ) {
    return std::forward ( cont ).begin ( );
}
 
template < class Container >
auto end ( Container && cont ) -> decltype ( std::forward ( cont ).end ( ) ) {
    return std::forward ( cont ).end ( );
}
 
template < class T >
class callback_iterator {
    T m_callback;
 
public:
    using difference_type = void;
    using value_type = void;
    using pointer = void;
    using reference = void;
    using iterator_category = std::output_iterator_tag;
 
    explicit callback_iterator ( T callback ) : m_callback ( std::move ( callback ) ) {
    }
 
    template < class R >
    callback_iterator & operator = ( R && value ) {
        m_callback ( std::forward < R > ( value ) );
        return * this;
    }
 
    callback_iterator &operator * ( ) {
        return * this;
    }
 
    callback_iterator &operator ++ ( ) {
        return * this;
    }
 
    callback_iterator operator ++ ( int ) {
        return * this;
    }
};
 
template < class T >
callback_iterator < T > make_callback_iterator ( T callback ) {
    return callback_iterator < T > ( callback );
}
 
template < typename map_type >
class key_iterator : public map_type::const_iterator {
public:
    explicit key_iterator ( const typename map_type::const_iterator & other ) : map_type::const_iterator ( other ) {
    }
 
    const typename map_type::value_type::first_type & operator * ( ) const {
        return map_type::const_iterator::operator * ( ).first;
    }
 
    const typename map_type::value_type::first_type * operator -> ( ) const {
        return & ( map_type::const_iterator::operator * ( ).first );
    }
};
 
template < typename map_type >
key_iterator < map_type > key_begin ( const map_type & m ) {
    return key_iterator < map_type > ( m.begin ( ) );
}
 
template < typename map_type >
key_iterator < map_type > key_end ( const map_type & m ) {
    return key_iterator < map_type > ( m.end ( ) );
}
 
template < typename map_type >
class value_iterator : public map_type::const_iterator {
public:
    explicit value_iterator ( const typename map_type::const_iterator & other ) : map_type::const_iterator ( other ) {
    }
 
    const typename map_type::value_type::first_type & operator * ( ) const {
        return map_type::const_iterator::operator * ( ).second;
    }
 
    const typename map_type::value_type::first_type * operator -> ( ) const {
        return & ( map_type::const_iterator::operator * ( ).second );
    }
};
 
template < typename map_type >
value_iterator < map_type > value_begin ( const map_type & m ) {
    return value_iterator < map_type > ( m.begin ( ) );
}
 
template < typename map_type >
value_iterator < map_type > value_end ( const map_type & m ) {
    return value_iterator < map_type > ( m.end ( ) );
}
 
} /* namespace ext */