#include <boost/iterator/iterator_facade.hpp>
#include <boost/fusion/include/vector.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/reference.hpp>
#include <boost/range/value_type.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/mpl/if.hpp>
#include <boost/foreach.hpp>

template<class T1, class T2>
struct minimum_traversal :
    boost::mpl::if_<boost::is_convertible<T1, T2>, T2, T1>
{};

template<class Range1, class Range2>
class product_iterator;

template<class Range1, class Range2>
struct product_iterator_base {
    typedef boost::iterator_facade<
        product_iterator<Range1, Range2>,
        boost::fusion::vector2<
            typename boost::range_value<Range1>::type,
            typename boost::range_value<Range2>::type
        >,
        typename minimum_traversal<
            typename boost::iterator_traversal<typename boost::range_iterator<Range1>::type>::type,
            typename boost::iterator_traversal<typename boost::range_iterator<Range2>::type>::type
        >::type
        ,
        boost::fusion::vector2<
            typename boost::range_reference<Range1>::type,
            typename boost::range_reference<Range2>::type
        >
    > type;
};

template<class Range1, class Range2>
class product_iterator : public product_iterator_base<Range1, Range2>::type {
    typedef typename product_iterator_base<Range1, Range2>::type base;
public:
    product_iterator(typename boost::range_iterator<Range1>::type i1, Range2& r2, typename boost::range_iterator<Range2>::type i2)
        : iter1(i1), begin2(r2.begin()), iter2(i2), end2(r2.end()) {}
    template<class R1, class R2>
    product_iterator(const product_iterator<R1, R2>& other)
        : iter1(other.iter1), begin2(other.begin2), iter2(other.iter2), end2(other.end2) {}
private:
    friend class boost::iterator_core_access;
    typename base::reference dereference() const {
        return(reference(*iter1, *iter2));
    }
    void increment() {
        ++iter2;
        if(iter2 == end2) {
            iter2 = begin2;
            ++iter1;
        }
    }
    void advance(typename base::difference_type n) {
        typename boost::range_difference<Range2>::type total = std::distance(begin2, end2);
        typename boost::range_difference<Range2>::type remaining = std::distance(iter2, end2);
        if(remaining <= total % n) {
            iter2 = begin2;
            ++iter1;
            n -= remaining;
        }
        std::advance(iter1, n / total);
        std::advance(iter2, n % total);
    }
    bool equal(const product_iterator& other) const {
        return(iter1 == other.iter1 && iter2 == other.iter2);
    }
    typename boost::range_iterator<Range1>::type iter1;
    typename boost::range_iterator<Range2>::type begin2, iter2, end2;
};

template<class T>
class container_holder {
public:
    typedef T const_type;
    container_holder(T& t) : impl(boost::addressof(t)) {}
    T& get() const {
        return(*impl);
    }
private:
    T* impl;
};

template<class T>
class view_holder {
public:
    typedef const T const_type;
    view_holder(T& t) : impl(t) {}
    T& get() {
        return(impl);
    }
    const T& get() const {
        return(impl);
    }
private:
    T impl;
};

template<class T>
struct select_holder {
    typedef typename boost::mpl::if_<boost::foreach::is_lightweight_proxy<T>,
        view_holder<T>,
        container_holder<T>
    >::type type;
};

template<class Range1, class Range2>
class product_view {
    typedef typename select_holder<Range1>::type r1_type;
    typedef typename select_holder<Range2>::type r2_type;
public:
    product_view(Range1& r1, Range2& r2) : r1(r1), r2(r2) {}
    typedef product_iterator<Range1, Range2> iterator;
    typedef product_iterator<typename r1_type::const_type, typename r2_type::const_type> const_iterator;
    iterator begin() {
        return(iterator(r1.get().begin(), r2.get(), r2.get().begin()));
    }
    iterator end() {
        return(iterator(r1.get().end(), r2.get(), r2.get().begin()));
    }
    const_iterator begin() const {
        return(iterator(r1.get().begin(), r2.get(), r2.get().begin()));
    }
    const_iterator end() const {
        return(iterator(r1.get().end(), r2.get(), r2.get().begin()));
    }
private:
    r1_type r1;
    r2_type r2;
};

template<class Range1, class Range2>
product_view<Range1, Range2> make_product_view(Range1& r1, Range2& r2) {
    return(product_view<Range1, Range2>(r1, r2));
}

template<class Range1, class Range2>
product_view<const Range1, Range2> make_product_view(const Range1& r1, Range2& r2) {
    return(product_view<const Range1, Range2>(r1, r2));
}

template<class Range1, class Range2>
product_view<Range1, const Range2> make_product_view(Range1& r1, const Range2& r2) {
    return(product_view<Range1, const Range2>(r1, r2));
}

template<class Range1, class Range2>
product_view<const Range1, const Range2> make_product_view(const Range1& r1, const Range2& r2) {
    return(product_view<const Range1, const Range2>(r1, r2));
}

namespace boost {
namespace foreach {

template<class Range1, class Range2>
struct is_lightweight_proxy<product_view<Range1, Range2> > : boost::mpl::true_ {};

}
}

#include <boost/assign.hpp>
#include <vector>
#include <iostream>
#include <boost/fusion/include/io.hpp>

int main() {
    using namespace boost::assign;
    std::vector<int> v1;
    v1 += 1, 2, 3, 4;
    std::vector<int> v2;
    v2 += 5, 6, 7, 8;
    std::vector<int> v3;
    v3 += 9, 10, 11, 12;
    typedef boost::fusion::vector2<boost::fusion::vector2<int, int>, int> element_type;
    BOOST_FOREACH(element_type x, make_product_view(make_product_view(v1, v2), v3)) {
        std::cout << x << std::endl;
    }
}