zip.hh

Go to the documentation of this file.

#ifndef UTOPIA_CORE_ZIP_HH
#define UTOPIA_CORE_ZIP_HH
 
#include <iterator>
#include <tuple>
#include <type_traits>
#include <iterator>
#include <iostream>
 
#include <boost/hana/ext/std/tuple.hpp>
#include <boost/hana/transform.hpp>
#include <boost/hana/for_each.hpp>
 
#include "type_traits.hh"
 
namespace Utopia
{
 
 
namespace Itertools
{
 
 
template <typename... Iters>
class ZipIterator
{
private:
    using Tuple = std::tuple<Iters...>;
 
    using RefTuple = std::tuple<decltype(*std::declval<Iters>())...>;
 
    using PtrTuple = std::tuple<typename std::iterator_traits<Iters>::pointer...>;
 
    Tuple _iterators;
 
    using This = ZipIterator<Iters...>;
 
public:
    using value_type = std::tuple<typename std::iterator_traits<Iters>::value_type...>;
    using difference_type = int;
    using pointer = PtrTuple;
    using reference = RefTuple;
    using iterator_category =
        std::common_type_t<typename std::iterator_traits<Iters>::iterator_category...>;
 
 
    ZipIterator& operator++()
    {
        boost::hana::for_each(_iterators, [](auto&& iter) { ++iter; });
        return *this;
    }
 
 
    template<typename category = iterator_category,
             typename std::enable_if_t<
                std::is_base_of_v<std::bidirectional_iterator_tag,
                                  category>, int> = 0>
    ZipIterator& operator--()
    {
        boost::hana::for_each(_iterators, [](auto&& iter) { --iter; });
        return *this;
    }
 
 
    ZipIterator operator++(int)
    {
        This copy(*this);
        boost::hana::for_each(_iterators, [](auto&& iter) { iter++; });
        return copy;
    }
 
 
    template<typename category = iterator_category,
             typename std::enable_if_t<
                std::is_base_of_v<std::bidirectional_iterator_tag,
                                  category>, int> = 0>
    ZipIterator operator--(int)
    {
        This copy(*this);
        boost::hana::for_each(_iterators, [](auto&& iter) { iter--; });
        return copy;
    }
 
 
    template<typename category = iterator_category,
             typename std::enable_if_t<
                std::is_base_of_v<std::random_access_iterator_tag,
                                  category>, int> = 0>
    ZipIterator operator+(const difference_type n) const
    {
        This copy(*this);
        return copy += n;
    }
 
 
    template<typename category = iterator_category,
             typename std::enable_if_t<
                std::is_base_of_v<std::random_access_iterator_tag,
                                  category>, int> = 0>
    ZipIterator operator-(const difference_type n) const
    {
        This copy(*this);
        return copy -= n;
    }
 
 
    template<typename category = iterator_category,
             typename std::enable_if_t<
                std::is_base_of_v<std::random_access_iterator_tag,
                                  category>, int> = 0>
    difference_type operator-(const ZipIterator& other) const
    {
        return std::get<0>(_iterators) - std::get<0>(other._iterators);
    }
 
 
    template<typename category = iterator_category,
             typename std::enable_if_t<
                std::is_base_of_v<std::random_access_iterator_tag,
                                  category>, int> = 0>
    ZipIterator& operator+=(const difference_type n)
    {
        boost::hana::for_each(_iterators, [&n](auto&& iter) { iter += n; });
        return *this;
    }
 
 
    template<typename category = iterator_category,
             typename std::enable_if_t<
                std::is_base_of_v<std::random_access_iterator_tag,
                                  category>, int> = 0>
    ZipIterator& operator-=(const difference_type n)
    {
        boost::hana::for_each(_iterators, [&n](auto&& iter) { iter -= n; });
        return *this;
    }
 
 
    const reference operator*() const
    {
        return boost::hana::transform(
            _iterators,
            [](auto&& iter) { return std::ref(*iter); });
    }
 
 
    reference operator*()
    {
        return boost::hana::transform(
            _iterators,
            [](auto&& iter) { return std::ref(*iter); });
    }
 
 
    const pointer operator->() const
    {
        return boost::hana::transform(
            _iterators,
            [](auto&& iter) { return &(*iter); });
    }
 
 
    pointer operator->()
    {
        return boost::hana::transform(
            _iterators,
            [](auto&& iter) { return &(*iter); });
    }
 
    ZipIterator() = default;
 
 
    ZipIterator(const ZipIterator& other) = default;
 
 
    ZipIterator(ZipIterator&& other) = default;
 
 
    ZipIterator& operator=(ZipIterator&& other) = default;
 
 
    ZipIterator& operator=(const ZipIterator& other)= default;
 
 
    ZipIterator(Iters... iters)
        : _iterators(std::make_tuple(iters...))
    {
    }
 
 
    template <typename... Iterators>
    ZipIterator(std::tuple<Iterators...> iters) : _iterators(iters)
    {
    }
 
 
    template<typename... It>
    bool operator==(const ZipIterator<It...>& other) const
    {
        return _iterators == other._iterators;
    }
 
 
    template<typename... It>
    bool operator!=(const ZipIterator<It...>& other) const
    {
        return _iterators != other._iterators;
    }
 
 
    template<typename category = iterator_category,
             typename std::enable_if_t<
                std::is_base_of_v<std::random_access_iterator_tag,
                                  category>, int> = 0>
    bool operator<(const ZipIterator& other) const
    {
        return _iterators < other._iterators;
    }
 
 
    template<typename category = iterator_category,
             typename std::enable_if_t<
                std::is_base_of_v<std::random_access_iterator_tag,
                                  category>, int> = 0>
    bool operator<=(const ZipIterator& other) const
    {
        return _iterators <= other._iterators;
    }
 
 
    template<typename category = iterator_category,
             typename std::enable_if_t<
                std::is_base_of_v<std::random_access_iterator_tag,
                                  category>, int> = 0>
    bool operator>(const ZipIterator& other) const
    {
        return _iterators > other._iterators;
    }
 
 
    template<typename category = iterator_category,
             typename std::enable_if_t<
                std::is_base_of_v<std::random_access_iterator_tag,
                                  category>, int> = 0>
    bool operator>=(const ZipIterator& other) const
    {
        return _iterators >= other._iterators;
    }
 
 
    template<typename category = iterator_category,
             typename std::enable_if_t<
                std::is_base_of_v<std::random_access_iterator_tag,
                                  category>, int> = 0>
    reference operator[](const difference_type n) const
    {
        return *(*this + n);
    }
 
    ~ZipIterator() = default;
 
 
    friend std::ostream& operator<< (std::ostream& ostr,
                                     const ZipIterator& right
    )
    {
        // using  Utopia::Utils::operator<<;
        ostr << "->" << *right;
        return ostr;
    }
};
 
template <typename... Iterators>
ZipIterator(std::tuple<Iterators...> iters)->ZipIterator<Iterators...>;
 
// iterator adaptors
 
 
template <typename Adaptor, typename... Containers>
auto adapt_zip(Adaptor&& adaptor, Containers&... containers)
{
    return ZipIterator(adaptor(containers)...);
}
 
 
template <typename... Containers>
class zip
{
protected:
    using Tuple = std::tuple<std::reference_wrapper<Containers>...>;
    Tuple _containers;
 
public:
    auto begin()
    {
        return ZipIterator(boost::hana::transform(
            _containers, [](auto& cont) { return cont.get().begin(); }));
    }
 
    auto end()
    {
        return ZipIterator(boost::hana::transform(
            _containers, [](auto& cont) { return cont.get().end(); }));
    }
 
    auto cbegin()
    {
        return ZipIterator(boost::hana::transform(
            _containers, [](auto& cont) { return cont.get().cbegin(); }));
    }
 
    auto cend()
    {
        return ZipIterator(boost::hana::transform(
            _containers, [](auto& cont) { return cont.get().cend(); }));
    }
 
    auto rbegin()
    {
        return ZipIterator(boost::hana::transform(
            _containers, [](auto& cont) { return cont.get().rbegin(); }));
    }
 
    auto rend()
    {
        return ZipIterator(boost::hana::transform(
            _containers, [](auto& cont) { return cont.get().rend(); }));
    }
 
    zip(const zip& other) = delete;
 
    zip& operator=(const zip& other) = delete;
 
    zip& operator=(zip&& other) = default;
 
    zip(zip&& other) = default;
 
    ~zip() = default;
 
 
    zip(Containers&... conts) : _containers(conts...)
    {
    }
};
 
template <typename... Containers>
auto begin(zip<Containers...>& zipper)
{
    return zipper.begin();
}
 
template <typename... Containers>
auto end(zip<Containers...>& zipper)
{
    return zipper.end();
}
 
template <typename... Containers>
auto cbegin(zip<Containers...>& zipper)
{
    return zipper.cbegin();
}
 
template <typename... Containers>
auto cend(zip<Containers...>& zipper)
{
    return zipper.cend();
}
 
template <typename... Containers>
auto rbegin(zip<Containers...>& zipper)
{
    return zipper.rbegin();
}
 
template <typename... Containers>
auto rend(zip<Containers...>& zipper)
{
    return zipper.rend();
}
 
} // namespace Itertools
} // namespace Utopia
 
#endif // UTOPIA_CORE_ZIP_HH