#include <boost/range.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <iostream>

namespace ublas = boost::numeric::ublas;

template<typename matrix_t>
struct row_iterator {
};

template<typename T>
struct row_iterator<ublas::matrix<T> > {
  typedef ublas::matrix<T> matrix_t;
  typedef ublas::matrix_row<matrix_t> row_t;
  typedef int difference_type;
  typedef row_iterator type;

  row_iterator (matrix_t & _m, int _r) :
    m (_m), r (_r) {}

  void operator++ () { ++r; }

  row_t operator* () { return row_t (m, r); }

  difference_type operator-(row_iterator const& other) {
    return r - other.r;
  }

  bool operator != (row_iterator const& other) { return *this - other != 0; }

  matrix_t & m;
  int r;

};


template<typename T>
typename row_iterator<ublas::matrix<T> >::type row_begin (ublas::matrix<T>& m) {
  return typename row_iterator<ublas::matrix<T> >::type (m, 0);
}

template<typename T>
typename row_iterator<ublas::matrix<T> >::type row_end (ublas::matrix<T>& m) {
  return typename row_iterator<ublas::matrix<T> >::type (m, m.size1());
}

template<typename range_2d_t>
int F (range_2d_t & rng) {
  typename row_iterator<range_2d_t>::type ri = row_begin (rng);
  for (; ri != row_end (rng); ++ri) {
    typedef typename row_iterator<range_2d_t>::row_t row_t;
    row_t r = *ri;
    typename boost::range_const_iterator<row_t>::type i = boost::begin (r);
    for (; i != boost::end (r); ++i)
      std::cout << *i << '\n';
  }

}

int main() {
  ublas::matrix<int> m (2, 2, 0);
  for (int r = 0; r < m.size1(); ++r) {
    for (int c = 0; c < m.size2(); ++c) {
      m (r, c) = r*m.size2()+c;
    }
  }
  F (m);
}