//  Copyright (c) 2012
//  Oswin Krause
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BOOST_UBLAS_MATRIX_VECTOR_RANGE_HPP
#define BOOST_UBLAS_MATRIX_VECTOR_RANGE_HPP

#include <boost/numeric/ublas/matrix_proxy.hpp>//for matrix_row, matrix_column and matrix_expression
#include <boost/numeric/ublas/vector.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/utility/enable_if.hpp>

namespace boost { namespace numeric { namespace ublas {

namespace detail{
/// \brief Iterator which represents a matrix as a range of row/column-vectors
///
/// The scond argument is the reference to a matrix_row/matrix_column.
/// Whatever type used, it must offer a constructor Reference(sequence,i) 
/// which constructs a reference to the i-th proxy-element
/// This iterator is invalidated when the underlying matrix is resized.
template<class Matrix, class Reference>
struct matrix_vector_iterator: public boost::iterator_facade<
	matrix_vector_iterator<Matrix,Reference>,
	typename vector_temporary_traits<Reference>::type,
	boost::random_access_traversal_tag,
	Reference
>{
public:
	matrix_vector_iterator(){}

	///\brief constructs a matrix_vector_iterator as pointing to the i-th proxy
	matrix_vector_iterator(Matrix& matrix, std::size_t position)
	: matrix_(&matrix),position_(position) {}

	template<class M, class R>
	matrix_vector_iterator(matrix_vector_iterator<M,R> const& other)
	: matrix_(other.matrix_),position_(other.position_) {}

private:
	friend class boost::iterator_core_access;
	template <class M,class R> friend class matrix_vector_iterator;

	void increment() {
		++position_;
	}
	void decrement() {
		--position_;
	}

	void advance(std::ptrdiff_t n){
		position_ += n;
	}

	template<class M,class R>
	std::ptrdiff_t distance_to(matrix_vector_iterator<M,R> const& other) const{
		BOOST_UBLAS_CHECK (matrix_ == other.matrix_, external_logic ());
		return (std::ptrdiff_t)other.position_ - (std::ptrdiff_t)position_;
	}

	template<class M,class R>
	bool equal(matrix_vector_iterator<M,R> const& other) const{
		BOOST_UBLAS_CHECK (matrix_ == other.matrix_, external_logic ());
		return (position_ == other.position_);
	}
	Reference dereference() const {
		return Reference(*matrix_,position_);
	}
	
	Matrix* matrix_;//no matrix_closure here to ensure easy usage
	std::size_t position_;
};

}

///\brief Represents a Matrix as range of row vectors. 
template<class Matrix>
class matrix_row_range 
: public boost::iterator_range<detail::matrix_vector_iterator<Matrix,matrix_row<Matrix> > >{
private:
	typedef detail::matrix_vector_iterator<Matrix,matrix_row<Matrix> > iterator_type;
	typedef boost::iterator_range<iterator_type> base_type;
public:
	matrix_row_range(Matrix& matrix)
	:base_type(iterator_type(matrix,0),iterator_type(matrix,matrix.size1())){}
};

///\brief convenience function to create matrix_row_ranges.
template<class Matrix>
matrix_row_range<Matrix> make_row_range(matrix_expression<Matrix>& matrix){
	return matrix_row_range<Matrix>(matrix());
}

///\brief convenience function to create matrix_row_ranges.
template<class Matrix>
matrix_row_range<Matrix const> make_row_range(matrix_expression<Matrix> const& matrix){
	return matrix_row_range<Matrix const>(matrix());
}

///\brief Represents a Matrix as range of column vectors. 
template<class Matrix >
class matrix_column_range 
: public boost::iterator_range<detail::matrix_vector_iterator<Matrix,matrix_column<Matrix> > >{
private:
	typedef detail::matrix_vector_iterator<Matrix,matrix_column<Matrix> > iterator_type;
	typedef boost::iterator_range<iterator_type> base_type;
public:
	matrix_column_range(Matrix& matrix)
	:base_type(iterator_type(matrix,0),iterator_type(matrix,matrix.size2())){}
};

///\brief convenience function to create matrix_row_ranges.
template<class Matrix>
matrix_column_range<Matrix> make_column_range(matrix_expression<Matrix>& matrix){
	return matrix_column_range<Matrix>(matrix());
}

///\brief convenience function to create matrix_row_ranges.
template<class Matrix>
matrix_column_range<Matrix const> make_column_range(matrix_expression<Matrix> const& matrix){
	return matrix_column_range<Matrix const>(matrix());
}

}}}
#endif