feat(kernel/std): implement std::reverse_iterator

Signed-off-by: EnderIce2 <enderice2@protonmail.com>

Kernel/include_std/iterator

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <type_traits>
+
 namespace std
 {
 	struct input_iterator_tag
@@ -54,28 +56,31 @@ namespace std
 		using iterator_category = typename Iter::iterator_category;
 	};
 
-	template <class InputIt>
+	namespace detail
-	constexpr typename std::iterator_traits<InputIt>::difference_type __do_distance(InputIt first, InputIt last, std::input_iterator_tag)
 	{
-		typename std::iterator_traits<InputIt>::difference_type result = 0;
+		template <class It>
-		while (first != last)
+		constexpr typename std::iterator_traits<It>::difference_type do_distance(It first, It last, std::input_iterator_tag)
 		{
-			++first;
+			typename std::iterator_traits<It>::difference_type result = 0;
-			++result;
+			while (first != last)
+			{
+				++first;
+				++result;
+			}
+			return result;
+		}
+
+		template <class It>
+		constexpr typename std::iterator_traits<It>::difference_type do_distance(It first, It last, std::random_access_iterator_tag)
+		{
+			return last - first;
 		}
-		return result;
 	}
 
-	template <class InputIt>
+	template <class It>
-	constexpr typename std::iterator_traits<InputIt>::difference_type __do_distance(InputIt first, InputIt last, std::random_access_iterator_tag)
+	constexpr typename std::iterator_traits<It>::difference_type distance(It first, It last)
 	{
-		return last - first;
+		return detail::do_distance(first, last, typename std::iterator_traits<It>::iterator_category());
-	}
-
-	template <class InputIt>
-	constexpr typename std::iterator_traits<InputIt>::difference_type distance(InputIt first, InputIt last)
-	{
-		return __do_distance(first, last, typename std::iterator_traits<InputIt>::iterator_category());
 	}
 
 	template <class InputIt>
@@ -135,4 +140,118 @@ namespace std
 	};
 
 	inline constexpr default_sentinel_t default_sentinel{};
+
+	template <class T>
+	using iter_value_t = typename std::iterator_traits<T>::value_type;
+
+	template <class T>
+	using iter_difference_t = typename std::iterator_traits<T>::difference_type;
+
+	template <class T>
+	using iter_reference_t = decltype(*std::declval<T &>());
+
+	template <class Iter>
+	class reverse_iterator
+	{
+	public:
+		using iterator_type = Iter;
+		using iterator_concept = std::bidirectional_iterator_tag;
+		using iterator_category = std::iterator_traits<Iter>::iterator_category;
+		using value_type = std::iter_value_t<Iter>;
+		using difference_type = std::iter_difference_t<Iter>;
+		using pointer = std::iterator_traits<Iter>::pointer;
+		using reference = std::iter_reference_t<Iter>;
+
+	protected:
+		Iter current = Iter();
+
+	public:
+		reverse_iterator() = default;
+		constexpr explicit reverse_iterator(Iter x) : current(x) {}
+		// template <class U>
+		// 	requires(!std::is_same_v<U, Iter> && std::convertible_to<const U &, Iter>)
+		// constexpr explicit reverse_iterator(const U &other) : current(other.base())
+		// {
+		// }
+
+		template <class U>
+		reverse_iterator(const reverse_iterator<U> &other) : current(other.base()) {}
+
+		template <class U>
+		reverse_iterator &operator=(const reverse_iterator<U> &other)
+		{
+			current = other.base();
+			return *this;
+		}
+
+		constexpr Iter base() const { return current; }
+
+		constexpr decltype(auto) operator*() const
+		{
+			return *std::prev(current);
+			// Iter tmp = current;
+			// return *--tmp;
+		}
+
+		pointer operator->() const
+		{
+			if constexpr (std::is_pointer_v<Iter>)
+				return current - 1;
+			else
+				return std::prev(current).operator->();
+		}
+
+		constexpr decltype(auto) operator[](difference_type n) const
+		{
+			return current[-n - 1];
+		}
+
+		constexpr reverse_iterator &operator++()
+		{
+			--current;
+			return *this;
+		}
+
+		constexpr reverse_iterator operator++(int)
+		{
+			auto tmp = *this;
+			--current;
+			return tmp;
+		}
+
+		constexpr reverse_iterator &operator--()
+		{
+			++current;
+			return *this;
+		}
+
+		constexpr reverse_iterator operator--(int)
+		{
+			auto tmp = *this;
+			++current;
+			return tmp;
+		}
+
+		constexpr reverse_iterator operator+(difference_type n) const
+		{
+			return reverse_iterator(current - n);
+		}
+
+		constexpr reverse_iterator operator-(difference_type n) const
+		{
+			return reverse_iterator(current + n);
+		}
+
+		constexpr reverse_iterator &operator+=(difference_type n)
+		{
+			current -= n;
+			return *this;
+		}
+
+		constexpr reverse_iterator &operator-=(difference_type n)
+		{
+			current += n;
+			return *this;
+		}
+	};
 }