dual_range.hpp

Go to the documentation of this file.

// This file is a part of NiHu, a C++ BEM template library.
//
// Copyright (C) 2012-2014  Peter Fiala <fiala@hit.bme.hu>
// Copyright (C) 2012-2014  Peter Rucz <rucz@hit.bme.hu>
//
// This program 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.
//
// This program 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/>.
 
#ifndef DUAL_RANGE_HPP_INCLUDED
#define DUAL_RANGE_HPP_INCLUDED
 
#include <utility>
 
namespace NiHu
{
 
namespace iteration
{
    struct diadic {};
    struct diagonal {};
}
 
 
template <class IterationMode, class It1, class It2>
class dual_iterator;
 
 
template <class It1, class It2>
class dual_iterator<iteration::diagonal, It1, It2> :
    public std::pair<It1, It2>
{
    typedef std::pair<It1, It2> base_t;
 
public:
    typedef dual_iterator type;
 
    dual_iterator(It1 it1, It2 it2) :
        base_t(it1, it2)
    {
    }
 
    dual_iterator const &operator++()
    {
        ++base_t::first;
        ++base_t::second;
        return *this;
    }
 
    bool operator!=(dual_iterator<iteration::diagonal, It1, It2> const &other) const
    {
        return base_t::first != other.get_first() ||
            base_t::second != other.get_second();
    }
 
    It1 const &get_first(void) const
    {
        return base_t::first;
    }
 
    It2 const &get_second(void) const
    {
        return base_t::second;
    }
};
 
 
template <class It1, class It2>
class dual_iterator<iteration::diadic, It1, It2> :
    public dual_iterator<iteration::diagonal, It1, It2>
{
public:
    typedef dual_iterator<iteration::diagonal, It1, It2> base_t;
 
    typedef dual_iterator type;
 
    dual_iterator(It1 it1, It2 it2, It2 begin2, It2 end2) :
        base_t(it1, it2), m_begin(begin2), m_end(end2)
    {
    }
 
    dual_iterator const &operator++()
    {
        ++base_t::second;
        if (base_t::second == m_end)
        {
            base_t::second = m_begin;
            ++base_t::first;
        }
        return *this;
    }
 
private:
    It2 m_begin;
    It2 m_end;
};
 
 
template <class IterationMode, class OutIt, class InIt>
class dual_range
{
public:
    typedef dual_iterator<IterationMode, OutIt, InIt> iterator;
 
    dual_range(OutIt obegin, OutIt oend, InIt ibegin, InIt iend) :
        m_obegin(obegin), m_oend(oend), m_ibegin(ibegin), m_iend(iend)
    {
    }
 
    iterator begin(void) const
    {
        return begin_impl(IterationMode());
    }
 
    iterator end(void) const
    {
        return end_impl(IterationMode());
    }
 
private:
    iterator begin_impl(iteration::diadic) const
    {
        if (m_obegin == m_oend || m_ibegin == m_iend)
            return end_impl(iteration::diadic());
        return iterator(m_obegin, m_ibegin, m_ibegin, m_iend);
    }
 
    iterator begin_impl(iteration::diagonal) const
    {
        return iterator(m_obegin, m_ibegin);
    }
 
    iterator end_impl(iteration::diadic) const
    {
        return iterator(m_oend, m_ibegin, m_ibegin, m_iend);
    }
 
    iterator end_impl(iteration::diagonal) const
    {
        return iterator(m_oend, m_iend);
    }
 
    OutIt m_obegin;
    OutIt m_oend;
    InIt m_ibegin;
    InIt m_iend;
};
 
 
 
template <class IterationMode, class OutIt, class InIt>
dual_range<IterationMode, OutIt, InIt>
    create_dual_range(IterationMode, OutIt obegin, OutIt oend, InIt ibegin, InIt iend)
{
    return dual_range<IterationMode, OutIt, InIt>(obegin, oend, ibegin, iend);
}
 
}
 
#endif // DUAL_RANGE_HPP_INCLUDED