foreach.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 <tuple>
#include <utility>
 
#include <extensions/container/tuple.hpp>
 
namespace ext {
 
template < class ... Iterators >
class const_tuple_foreach_iterator {
    ext::tuple < Iterators ... > current;
 
    template < size_t ... I >
    ext::tuple < const typename Iterators::value_type & ... > callDerefOperator ( const std::index_sequence < I ... > & ) const {
        return ext::tie ( * std::get < I > ( current ) ... );
    }
 
    template < size_t ... I >
    void callIncOperator ( const std::index_sequence < I ... > & ) {
        ext::tie ( ++std::get < I > ( current ) ... );
    }
 
    template < size_t ... I >
    void callDecOperator ( const std::index_sequence < I ... > & ) {
        ext::tie ( --std::get < I > ( current ) ... );
    }
 
public:
    explicit const_tuple_foreach_iterator ( Iterators ... it ) : current ( it ... ) {
    }
 
    template < size_t I >
    decltype ( std::get < I > ( current ) ) base ( ) const {
        return std::get < I > ( current );
    }
 
    template < size_t ... I >
    ext::tuple < const typename Iterators::value_type & ... > operator *( ) const {
        return callDerefOperator ( std::index_sequence_for < Iterators ... > { } );
    }
 
    const_tuple_foreach_iterator & operator ++( ) {
        callIncOperator ( std::index_sequence_for < Iterators ... > { } );
        return * this;
    }
 
    const_tuple_foreach_iterator & operator --( ) {
        callDecOperator ( std::index_sequence_for < Iterators ... > { } );
        return * this;
    }
 
    const_tuple_foreach_iterator operator ++( int ) {
        const_tuple_foreach_iterator temp = * this;
 
        ++( * this );
        return temp;
    }
 
    const_tuple_foreach_iterator operator --( int ) {
        const_tuple_foreach_iterator temp = * this;
 
        --( * this );
        return temp;
    }
 
    bool operator ==( const const_tuple_foreach_iterator < Iterators ... > & other ) const {
        return this->current == other.current;
    }
 
    bool operator !=( const const_tuple_foreach_iterator < Iterators ... > & other ) const {
        return !( * this == other );
    }
 
};
 
template < class ... Iterators >
const_tuple_foreach_iterator < Iterators ... > make_tuple_foreach_iterator ( Iterators ... its ) {
    return const_tuple_foreach_iterator < Iterators ... > ( its ... );
}
 
template < class ... Types >
class const_tuple_foreach {
 
    const ext::tuple < const Types & ... > data;
 
    template < size_t ... I >
    const_tuple_foreach_iterator < typename Types::const_iterator ... > callBegin ( const std::index_sequence < I ... > & ) const {
        return make_tuple_foreach_iterator ( std::get < I > ( data ).cbegin ( ) ... );
    }
 
    template < size_t ... I >
    const_tuple_foreach_iterator < typename Types::const_iterator ... > callEnd ( const std::index_sequence < I ... > & ) const {
        return make_tuple_foreach_iterator ( std::get < I > ( data ).cend ( ) ... );
    }
 
public:
    const_tuple_foreach ( const Types & ... args ) : data ( args ... ) { }
 
    const_tuple_foreach_iterator < typename Types::const_iterator ... > begin ( ) const {
        return callBegin ( std::index_sequence_for < Types ... > { } );
    }
 
    const_tuple_foreach_iterator < typename Types::const_iterator ... > end ( ) const {
        return callEnd ( std::index_sequence_for < Types ... > { } );
    }
 
};
 
template < class ... Types >
const_tuple_foreach < Types ... > make_tuple_foreach ( const Types & ... args ) {
    return const_tuple_foreach < Types ... > ( args ... );
}
 
template < class IntegralType >
class virtual_pointer_to_integer {
    IntegralType m_data;
 
public:
    typedef IntegralType value_type;
 
    typedef std::ptrdiff_t difference_type;
 
    typedef IntegralType * pointer;
 
    typedef IntegralType reference;
 
    typedef std::bidirectional_iterator_tag iterator_category;
 
    virtual_pointer_to_integer ( IntegralType data ) : m_data ( data ) {
    }
 
    IntegralType operator * ( ) const {
        return m_data;
    }
 
    virtual_pointer_to_integer & operator ++( ) {
        m_data ++;
        return * this;
    }
 
    virtual_pointer_to_integer & operator --( ) {
        m_data --;
        return * this;
    }
 
    virtual_pointer_to_integer operator ++( int ) {
        virtual_pointer_to_integer temp = * this;
 
        ++( * this );
        return temp;
    }
 
    virtual_pointer_to_integer operator --( int ) {
        virtual_pointer_to_integer temp = * this;
 
        --( * this );
        return temp;
    }
 
    bool operator ==( const virtual_pointer_to_integer < IntegralType > & other ) const {
        return this->m_data == other.m_data;
    }
 
    bool operator !=( const virtual_pointer_to_integer < IntegralType > & other ) const {
        return !( * this == other );
    }
};
 
template < class IntegralType >
class sequence {
    IntegralType m_first;
 
    IntegralType m_last;
 
public:
    sequence ( IntegralType first, IntegralType last ) : m_first ( first ), m_last ( last ) {
    }
 
    sequence ( IntegralType size ) : m_first ( 0 ), m_last ( size ) {
    }
 
    virtual_pointer_to_integer < IntegralType > begin ( ) {
        return virtual_pointer_to_integer < IntegralType > ( m_first );
    }
 
    virtual_pointer_to_integer < IntegralType > end ( ) {
        return virtual_pointer_to_integer < IntegralType > ( m_last );
    }
};
 
} /* namespace ext */