#pragma once

#include "matrix_iterator.hpp"

// Matrix row iterator

template <typename Element>
MatrixRowIterator<Element>::MatrixRowIterator(ColumnPtr column_ptr) noexcept
	: _column_ptr(column_ptr)
{
}

template <typename Element>
auto MatrixRowIterator<Element>::operator++() noexcept -> MatrixRowIterator<Element> &
{
	++_column_ptr;

	return *this;
}

template <typename Element>
auto MatrixRowIterator<Element>::operator++(int) noexcept -> MatrixRowIterator<Element>
{
	auto copy = *this;

	++(*this);

	return copy;
}

template <typename Element>
auto MatrixRowIterator<Element>::operator*() const noexcept -> Element &
{
	return *_column_ptr;
}

template <typename Element>
auto MatrixRowIterator<Element>::operator==(const MatrixRowIterator &rhs) const noexcept
	-> bool
{
	return _column_ptr == rhs._column_ptr;
}

template <typename Element>
auto MatrixRowIterator<Element>::operator!=(const MatrixRowIterator &rhs) const noexcept
	-> bool
{
	return _column_ptr != rhs._column_ptr;
}

// Matrix row

template <typename Element>
MatrixRow<Element>::MatrixRow(RowPtr row_ptr, const uint32_t &column_cnt) noexcept
	: _row_ptr(row_ptr), _column_cnt(column_cnt)
{
}

template <typename Element>
auto MatrixRow<Element>::begin() const noexcept -> MatrixRowIterator<Element>
{
	return MatrixRowIterator<Element>(_row_ptr);
}

template <typename Element>
auto MatrixRow<Element>::end() const noexcept -> MatrixRowIterator<Element>
{
	return MatrixRowIterator<Element>(_row_ptr + _column_cnt);
}

// Matrix iterator

template <typename Element>
MatrixIterator<Element>::MatrixIterator(
	RowPtr row_ptr,
	const uint32_t &column_cnt) noexcept
	: _row_ptr(row_ptr), _column_cnt(column_cnt)
{
}

template <typename Element>
auto MatrixIterator<Element>::operator++() noexcept -> MatrixIterator<Element> &
{
	++_row_ptr;

	return *this;
}

template <typename Element>
auto MatrixIterator<Element>::operator++(int) noexcept -> MatrixIterator<Element>
{
	auto copy = *this;

	++(*this);

	return copy;
}

template <typename Element>
auto MatrixIterator<Element>::operator*() const noexcept -> MatrixRow<Element>
{
	return MatrixRow(*_row_ptr, _column_cnt);
}

template <typename Element>
auto MatrixIterator<Element>::operator==(const MatrixIterator &rhs) const noexcept -> bool
{
	return _row_ptr == rhs._row_ptr;
}

template <typename Element>
auto MatrixIterator<Element>::operator!=(const MatrixIterator &rhs) const noexcept -> bool
{
	return _row_ptr != rhs._row_ptr;
}