Iterators.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <iosfwd>
#include <iterator>
#include <utility>
 
namespace ogdf {
 
template<typename IT>
class Range {
    IT m_begin;
    IT m_end;
 
public:
    Range() { }
 
    explicit Range(IT begin) : m_begin(begin) { }
 
    Range(IT begin, IT end) : m_begin(begin), m_end(end) { }
 
    IT begin() const { return m_begin; }
 
    IT end() const { return m_end; }
};
 
template<typename IT1, typename IT2>
class ZipIterator {
    IT1 m_iter1;
    IT2 m_iter2;
 
public:
    // iterator traits
    using iterator_category = std::input_iterator_tag;
    using value_type = typename std::pair<typename IT1::value_type, typename IT2::value_type>;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type*;
    using reference = value_type&;
 
    explicit ZipIterator() { }
 
    explicit ZipIterator(const IT1& mIter1, const IT2& mIter2)
        : m_iter1(mIter1), m_iter2(mIter2) { }
 
    bool operator==(const ZipIterator<IT1, IT2>& rhs) const {
        return m_iter1 == rhs.m_iter1 && m_iter2 == rhs.m_iter2;
    }
 
    bool operator!=(const ZipIterator<IT1, IT2>& rhs) const { return !(rhs == *this); }
 
    value_type operator*() { return std::make_pair(*m_iter1, *m_iter2); }
 
    bool checkOnlyOneEnded(const IT1& mEnd1, const IT2& mEnd2) {
        bool e1 = m_iter1 == mEnd1;
        bool e2 = m_iter2 == mEnd2;
        return e1 ^ e2;
    }
 
    ZipIterator<IT1, IT2>& operator++() {
        ++m_iter1;
        ++m_iter2;
        return *this;
    }
 
    ZipIterator<IT1, IT2> operator++(int) {
        ZipIterator<IT1, IT2> before = *this;
        ++m_iter1;
        ++m_iter2;
        return before;
    }
};
 
}