fix reverse_iterator

support STL container: some algorithms

sprout/iterator/adaptor.hpp

@@ -7,6 +7,9 @@
 #include <sprout/iterator/replace_iterator.hpp>
 #include <sprout/iterator/replace_if_iterator.hpp>
 #include <sprout/iterator/filter_iterator.hpp>
+#include <sprout/iterator/remove_iterator.hpp>
+#include <sprout/iterator/remove_if_iterator.hpp>
+#include <sprout/iterator/while_iterator.hpp>
 #include <sprout/iterator/step_iterator.hpp>
 #include <sprout/iterator/indexed_iterator.hpp>
 #include <sprout/iterator/valued_iterator.hpp>

sprout/iterator/remake_iterator.hpp

@@ -178,14 +178,14 @@ namespace sprout {
 		SPROUT_CONSTEXPR remake_iterator next() const {
 			return remake_iterator(
 				sprout::next(current), (is_in_copying() ? sprout::next(current2) : current2),
-				fst, last,
+				fst, lst,
 				begin_off - 1, end_off - 1
 				);
 		}
 		SPROUT_CONSTEXPR remake_iterator prev() const {
 			return remake_iterator(
 				sprout::prev(current), (begin_off < 0 && end_off >= 0 ? sprout::prev(current2) : current2),
-				fst, last,
+				fst, lst,
 				begin_off + 1, end_off + 1
 				);
 		}

sprout/iterator/remove_if_iterator.hpp

@@ -0,0 +1,39 @@
+#ifndef SPROUT_ITERATOR_REMOVE_IF_ITERATOR_HPP
+#define SPROUT_ITERATOR_REMOVE_IF_ITERATOR_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/iterator/filter_iterator.hpp>
+
+namespace sprout {
+	//
+	// remove_if_filter
+	//
+	template<typename Predicate>
+	class remove_if_filter {
+	public:
+		typedef bool result_type;
+	private:
+		Predicate pred_;
+	public:
+		SPROUT_CONSTEXPR remove_if_filter(Predicate pred)
+			: pred_(pred)
+		{}
+		template<typename U>
+		SPROUT_CONSTEXPR bool operator()(U const& value) const {
+			return !pred_(value);
+		}
+	};
+
+	//
+	// make_remove_if_iterator
+	//
+	template<typename Predicate, typename Iterator>
+	inline SPROUT_CONSTEXPR sprout::filter_iterator<sprout::remove_if_filter<Predicate>, Iterator>
+	make_remove_if_iterator(Predicate pred, Iterator it, Iterator last = Iterator()) {
+		return sprout::filter_iterator<sprout::remove_if_filter<Predicate>, Iterator>(
+			sprout::remove_if_filter<Predicate>(pred), it, last
+			);
+	}
+}	// namespace sprout
+
+#endif	// SPROUT_ITERATOR_REMOVE_IF_ITERATOR_HPP

sprout/iterator/remove_iterator.hpp

@@ -0,0 +1,39 @@
+#ifndef SPROUT_ITERATOR_REMOVE_ITERATOR_HPP
+#define SPROUT_ITERATOR_REMOVE_ITERATOR_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/iterator/filter_iterator.hpp>
+
+namespace sprout {
+	//
+	// remove_filter
+	//
+	template<typename T>
+	class remove_filter {
+	public:
+		typedef bool result_type;
+	private:
+		T value_;
+	public:
+		SPROUT_CONSTEXPR remove_filter(T const& value)
+			: value_(value)
+		{}
+		template<typename U>
+		SPROUT_CONSTEXPR bool operator()(U const& value) const {
+			return value != value_;
+		}
+	};
+
+	//
+	// make_remove_iterator
+	//
+	template<typename T, typename Iterator>
+	inline SPROUT_CONSTEXPR sprout::filter_iterator<sprout::remove_filter<T>, Iterator>
+	make_remove_iterator(T const& value, Iterator it, Iterator last = Iterator()) {
+		return sprout::filter_iterator<sprout::remove_filter<T>, Iterator>(
+			sprout::remove_filter<T>(value), it, last
+			);
+	}
+}	// namespace sprout
+
+#endif	// SPROUT_ITERATOR_REMOVE_ITERATOR_HPP

sprout/iterator/replace_if_iterator.hpp

@@ -12,7 +12,7 @@ namespace sprout {
 	class replace_value_if {
 	public:
 		typedef Predicate predicate_type;
-		typedef T const& result_type;
+		typedef T result_type;
 		typedef T const& argument_type;
 	private:
 		Predicate pred_;

sprout/iterator/replace_iterator.hpp

@@ -11,7 +11,7 @@ namespace sprout {
 	template<typename T>
 	class replace_value {
 	public:
-		typedef T const& result_type;
+		typedef T result_type;
 		typedef T const& argument_type;
 	private:
 		T old_;

sprout/iterator/reverse_iterator.hpp

@@ -32,22 +32,17 @@ namespace sprout {
 		typedef typename std::iterator_traits<iterator_type>::reference reference;
 	protected:
 		iterator_type current;
-	private:
-		iterator_type deref_tmp;
 	public:
 		reverse_iterator() = default;
 		SPROUT_CONSTEXPR reverse_iterator(reverse_iterator const& other)
 			: current(other.current)
-			, deref_tmp(other.deref_tmp)
 		{}
 		explicit SPROUT_CONSTEXPR reverse_iterator(iterator_type it)
 			: current(it)
-			, deref_tmp(sprout::prev(it))
 		{}
 		template<typename U>
 		SPROUT_CONSTEXPR reverse_iterator(reverse_iterator<U> const& it)
 			: current(it.base())
-			, deref_tmp(sprout::prev(it.base()))
 		{}
 		template<typename U>
 		reverse_iterator& operator=(reverse_iterator<U> const& it) {
@@ -59,31 +54,27 @@ namespace sprout {
 			return current;
 		}
 		SPROUT_CONSTEXPR reference operator*() const {
-			return *deref_tmp;
+			return *sprout::prev(current);
 		}
 		SPROUT_CONSTEXPR pointer operator->() const {
-			return &*deref_tmp;
+			return &*(*this);
 		}
 		reverse_iterator& operator++() {
 			--current;
-			--deref_tmp;
 			return *this;
 		}
 		reverse_iterator operator++(int) {
 			reverse_iterator result(*this);
 			--current;
-			--deref_tmp;
 			return result;
 		}
 		reverse_iterator& operator--() {
 			++current;
-			++deref_tmp;
 			return *this;
 		}
 		reverse_iterator operator--(int) {
 			reverse_iterator temp(*this);
 			++current;
-			++deref_tmp;
 			return temp;
 		}
 		SPROUT_CONSTEXPR reverse_iterator operator+(difference_type n) const {
@@ -103,7 +94,7 @@ namespace sprout {
 			return *this;
 		}
 		SPROUT_CONSTEXPR reference operator[](difference_type n) const {
-			return *(deref_tmp - n);
+			return *(current - (n + 1));
 		}
 		SPROUT_CONSTEXPR reverse_iterator next() const {
 			return reverse_iterator(sprout::prev(current));
@@ -114,11 +105,9 @@ namespace sprout {
 		void swap(reverse_iterator& other)
 		SPROUT_NOEXCEPT_EXPR(
 			SPROUT_NOEXCEPT_EXPR(swap(current, other.current))
-			&& SPROUT_NOEXCEPT_EXPR(swap(deref_tmp, other.deref_tmp))
 			)
 		{
 			swap(current, other.current);
-			swap(deref_tmp, other.deref_tmp);
 		}
 	};
 
@@ -155,7 +144,7 @@ namespace sprout {
 	template<typename Iterator1, typename Iterator2>
 	inline SPROUT_CONSTEXPR decltype(std::declval<Iterator1>() - std::declval<Iterator2>())
 	operator-(sprout::reverse_iterator<Iterator1> const& lhs, sprout::reverse_iterator<Iterator2> const& rhs) {
-		return lhs.base() - rhs.base();
+		return rhs.base() - lhs.base();
 	}
 	template<typename Iterator>
 	inline SPROUT_CONSTEXPR sprout::reverse_iterator<Iterator>

sprout/iterator/while_iterator.hpp

@@ -0,0 +1,208 @@
+#ifndef SPROUT_ITERATOR_WHILE_ITERATOR_HPP
+#define SPROUT_ITERATOR_WHILE_ITERATOR_HPP
+
+#include <iterator>
+#include <utility>
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/iterator/next.hpp>
+#include <sprout/iterator/prev.hpp>
+#include <sprout/utility/swap.hpp>
+
+namespace sprout {
+	//
+	// while_iterator
+	//
+	template<typename Predicate, typename Iterator>
+	class while_iterator
+		: public std::iterator<
+			typename std::conditional<
+				std::is_convertible<typename std::iterator_traits<Iterator>::iterator_category, std::random_access_iterator_tag>::value,
+				std::bidirectional_iterator_tag,
+				typename std::iterator_traits<Iterator>::iterator_category
+			>::type,
+			typename std::iterator_traits<Iterator>::value_type,
+			typename std::iterator_traits<Iterator>::difference_type,
+			typename std::iterator_traits<Iterator>::pointer,
+			typename std::iterator_traits<Iterator>::reference
+		>
+	{
+	public:
+		typedef Predicate predicate_type;
+		typedef Iterator iterator_type;
+		typedef typename std::conditional<
+			std::is_convertible<typename std::iterator_traits<Iterator>::iterator_category, std::random_access_iterator_tag>::value,
+			std::bidirectional_iterator_tag,
+			typename std::iterator_traits<Iterator>::iterator_category
+		>::type iterator_category;
+		typedef typename std::iterator_traits<Iterator>::value_type value_type;
+		typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
+		typedef typename std::iterator_traits<Iterator>::pointer pointer;
+		typedef typename std::iterator_traits<Iterator>::reference reference;
+	private:
+		struct private_constructor_tag {};
+	private:
+		static SPROUT_CONSTEXPR iterator_type find_next(iterator_type first, iterator_type last, Predicate pred) {
+			return first == last || pred(*first) ? first
+				: last
+				;
+		}
+		static SPROUT_CONSTEXPR iterator_type find_prev(iterator_type first, Predicate pred) {
+			return pred(*first) ? first
+				: find_prev(sprout::prev(first), pred)
+				;
+		}
+	protected:
+		iterator_type current;
+		iterator_type last;
+		Predicate pred;
+	private:
+		void satisfy_predicate() {
+			if (!pred(*current)) {
+				current = last;
+			}
+		}
+		void satisfy_predicate_backward() {
+			while (!pred(*current)) {
+				--current;
+			}
+		}
+		SPROUT_CONSTEXPR while_iterator(Predicate pred, iterator_type it, iterator_type last, private_constructor_tag)
+			: current(it)
+			, last(last)
+			, pred(pred)
+		{}
+	public:
+		while_iterator() = default;
+		while_iterator(while_iterator const&) = default;
+		SPROUT_CONSTEXPR while_iterator(Predicate pred, iterator_type it, iterator_type last = iterator_type())
+			: current(find_next(it, last, pred))
+			, last(last)
+			, pred(pred)
+		{}
+		template<typename U>
+		SPROUT_CONSTEXPR while_iterator(while_iterator<Predicate, U> const& it)
+			: current(it.current)
+			, last(it.last)
+			, pred(it.pred)
+		{}
+		template<typename U>
+		while_iterator& operator=(while_iterator<Predicate, U> const& it) {
+			while_iterator temp(it);
+			temp.swap(*this);
+			return *this;
+		}
+		SPROUT_CONSTEXPR iterator_type base() const {
+			return current;
+		}
+		SPROUT_CONSTEXPR iterator_type end() const {
+			return last;
+		}
+		SPROUT_CONSTEXPR Predicate predicate() const {
+			return pred;
+		}
+		SPROUT_CONSTEXPR reference operator*() const {
+			return *current;
+		}
+		SPROUT_CONSTEXPR pointer operator->() const {
+			return &*current;
+		}
+
+		while_iterator& operator++() {
+			++current;
+			satisfy_predicate();
+			return *this;
+		}
+		while_iterator operator++(int) {
+			while_iterator result(*this);
+			++current;
+			satisfy_predicate();
+			return result;
+		}
+		while_iterator& operator--() {
+			--current;
+			satisfy_predicate_backward();
+			return *this;
+		}
+		while_iterator operator--(int) {
+			while_iterator temp(*this);
+			--current;
+			satisfy_predicate_backward();
+			return temp;
+		}
+		SPROUT_CONSTEXPR while_iterator next() const {
+			return while_iterator(pred, find_next(sprout::next(current), last, pred), last, private_constructor_tag());
+		}
+		SPROUT_CONSTEXPR while_iterator prev() const {
+			return while_iterator(pred, find_prev(sprout::prev(current), pred), last, private_constructor_tag());
+		}
+		void swap(while_iterator& other)
+		SPROUT_NOEXCEPT_EXPR(
+			SPROUT_NOEXCEPT_EXPR(sprout::swap(current, other.current))
+			&& SPROUT_NOEXCEPT_EXPR(sprout::swap(last, other.last))
+			&& SPROUT_NOEXCEPT_EXPR(sprout::swap(pred, other.pred))
+			)
+		{
+			sprout::swap(current, other.current);
+			sprout::swap(last, other.last);
+			sprout::swap(pred, other.pred);
+		}
+	};
+
+	template<typename Predicate, typename Iterator1, typename Iterator2>
+	inline SPROUT_CONSTEXPR bool operator==(
+		sprout::while_iterator<Predicate, Iterator1> const& lhs,
+		sprout::while_iterator<Predicate, Iterator2> const& rhs
+		)
+	{
+		return lhs.base() == rhs.base();
+	}
+	template<typename Predicate, typename Iterator1, typename Iterator2>
+	inline SPROUT_CONSTEXPR bool operator!=(
+		sprout::while_iterator<Predicate, Iterator1> const& lhs,
+		sprout::while_iterator<Predicate, Iterator2> const& rhs
+		)
+	{
+		return !(lhs == rhs);
+	}
+
+	//
+	// make_while_iterator
+	//
+	template<typename Predicate, typename Iterator>
+	inline SPROUT_CONSTEXPR sprout::while_iterator<Predicate, Iterator>
+	make_while_iterator(Predicate pred, Iterator it, Iterator last = Iterator()) {
+		return sprout::while_iterator<Predicate, Iterator>(pred, it, last);
+	}
+
+	//
+	// swap
+	//
+	template<typename Predicate, typename Iterator>
+	inline void
+	swap(sprout::while_iterator<Predicate, Iterator>& lhs, sprout::while_iterator<Predicate, Iterator>& rhs)
+	SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
+	{
+		lhs.swap(rhs);
+	}
+
+	//
+	// iterator_next
+	//
+	template<typename Predicate, typename Iterator>
+	inline SPROUT_CONSTEXPR sprout::while_iterator<Predicate, Iterator>
+	iterator_next(sprout::while_iterator<Predicate, Iterator> const& it) {
+		return it.next();
+	}
+
+	//
+	// iterator_prev
+	//
+	template<typename Predicate, typename Iterator>
+	inline SPROUT_CONSTEXPR sprout::while_iterator<Predicate, Iterator>
+	iterator_prev(sprout::while_iterator<Predicate, Iterator> const& it) {
+		return it.prev();
+	}
+}	// namespace sprout
+
+#endif	// SPROUT_ITERATOR_WHILE_ITERATOR_HPP