Iterator.h

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX 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 this program. If not, see <http://www.gnu.org/licenses/>.
*
* @package    ArmarXCore::core
* @author     Raphael Grimm (raphael dot grimm at kit dot edu)
* @date       2019
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
 
#include <algorithm>
#include <stdexcept>
#include <tuple>
#include <utility>
 
#include <boost/iterator/iterator_facade.hpp>
 
namespace armarx
{
    template <class Ituple, class Rtuple, class Idx>
    class ZipIteratorBase;
 
    template <class Ituple, class Rtuple, std::size_t... Idxs>
    class ZipIteratorBase<Ituple, Rtuple, std::index_sequence<Idxs...>> :
        public boost::iterator_facade<ZipIteratorBase<Ituple, Rtuple, std::index_sequence<Idxs...>>,
                                      Rtuple,
                                      boost::forward_traversal_tag,
                                      Rtuple>
    {
    public:
        using IteratorTuple = Ituple;
        using reference = Rtuple;
        using difference_type = std::ptrdiff_t;
 
    private:
        IteratorTuple _iters;
 
    public:
        ZipIteratorBase(ZipIteratorBase&&) = default;
        ZipIteratorBase(const ZipIteratorBase&) = default;
 
        ZipIteratorBase& operator=(ZipIteratorBase&&) = default;
        ZipIteratorBase& operator=(const ZipIteratorBase&) = default;
 
        ZipIteratorBase(IteratorTuple its) : _iters{std::move(its)}
        {
        }
 
    private:
        friend class boost::iterator_core_access;
 
        // Implementation of Iterator Operations
        // =====================================
        reference
        dereference() const
        {
            return std::forward_as_tuple(*std::get<Idxs>(_iters)...);
        }
 
        bool
        equal(const ZipIteratorBase& other) const
        {
            return _iters == other._iters;
        }
 
        // Advancing a zip iterator means to advance all iterators in the
        // iterator tuple.
        void
        advance(difference_type n)
        {
            ((std::get<Idxs>(_iters) += n), ...);
        }
 
        // Incrementing a zip iterator means to increment all iterators in
        // the iterator tuple.
        void
        increment()
        {
            (++std::get<Idxs>(_iters), ...);
        }
 
        // Decrementing a zip iterator means to decrement all iterators in
        // the iterator tuple.
        void
        decrement()
        {
            (--std::get<Idxs>(_iters), ...);
        }
 
        //    // Distance is calculated using the first iterator in the tuple.
        //    template<typename OtherIteratorTuple>
        //    typename super_t::difference_type distance_to(
        //        const zip_iterator<OtherIteratorTuple>& other
        //    ) const
        //    {
        //        return fusion::at_c<0>(other.get_iterator_tuple()) -
        //               fusion::at_c<0>(this->get_iterator_tuple());
        //    }
    };
 
    template <class It0, class... Its>
    class ZipIterator :
        public ZipIteratorBase<std::tuple<It0, Its...>,
                               std::tuple<typename std::iterator_traits<It0>::reference&&,
                                          typename std::iterator_traits<Its>::reference&&...>,
                               std::make_index_sequence<1 + sizeof...(Its)>>
    {
    public:
        using Base = ZipIteratorBase<std::tuple<It0, Its...>,
                                     std::tuple<typename std::iterator_traits<It0>::reference&&,
                                                typename std::iterator_traits<Its>::reference&&...>,
                                     std::make_index_sequence<1 + sizeof...(Its)>>;
 
        ZipIterator(It0&& it0, Its&&... its) :
            Base({std::forward<It0>(it0), std::forward<Its>(its)...})
        {
        }
 
        using Base::Base;
        using Base::operator=;
    };
} // namespace armarx
 
#include <utility>
 
namespace armarx
{
    template <class It>
    struct IteratorRange
    {
        IteratorRange(It b, It e) : _begin{std::move(b)}, _end{std::move(e)}
        {
        }
 
        It
        begin() const
        {
            return _begin;
        }
 
        It
        end() const
        {
            return _end;
        }
 
    private:
        It _begin;
        It _end;
    };
} // namespace armarx
 
#include <boost/iterator/counting_iterator.hpp>
#include <boost/iterator/zip_iterator.hpp>
 
namespace armarx
{
    template <class Container, class... Containers>
    auto
    MakeIndexedContainer(Container& c, Containers&... cs)
    {
        if constexpr (sizeof...(Containers))
        {
            const auto initlist = {c.size(), cs.size()...};
            const auto [lo, hi] = std::minmax(initlist);
            if (lo != hi)
            {
                throw std::invalid_argument{"All containers have to be of the same size!"};
            }
        }
        return IteratorRange{
            ZipIterator(boost::counting_iterator<std::size_t>(0), c.begin(), cs.begin()...),
            ZipIterator(boost::counting_iterator<std::size_t>(c.size()), c.end(), cs.end()...)};
    }
 
    template <class Container, class... Containers>
    auto
    MakeZippedContainer(Container& c, Containers&... cs)
    {
        if constexpr (sizeof...(Containers))
        {
            const auto initlist = {c.size(), cs.size()...};
            const auto [lo, hi] = std::minmax(initlist);
            if (lo != hi)
            {
                throw std::invalid_argument{"All containers have to be of the same size!"};
            }
        }
        return IteratorRange{ZipIterator(c.begin(), cs.begin()...),
                             ZipIterator(c.end(), cs.end()...)};
    }
 
    template <class Container>
    auto
    MakeReversedRange(Container& c)
    {
        return IteratorRange{c.rbegin(), c.rend()};
    }
} // namespace armarx