Added ReverseIteratorHEADmaster

4 files changed, 200 insertions, 92 deletions

diff --git a/List.hpp b/List.hpp
index 8f13d02..72d24d2 100644
--- a/List.hpp
+++ b/List.hpp
@@ -6,7 +6,7 @@
 /*   By: cacharle <marvin@42.fr>                    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2020/02/01 09:31:07 by cacharle          #+#    #+#             */
-/*   Updated: 2020/04/26 12:50:59 by charles          ###   ########.fr       */
+/*   Updated: 2020/04/27 11:24:58 by charles          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -328,6 +328,25 @@ namespace ft
             m_size = 0;
         }
 
+        void splice(iterator position, List& x)
+        {
+            for (iterator it = x.begin(); it != x.end(); ++it)
+                insert(position, *it);
+            clear(x);
+        }
+
+        void splice(iterator position, List& x, iterator i)
+        {
+            insert(position, *i);
+            x.erase(i);
+        }
+
+        void splice(iterator position, List& x, iterator first, iterator last)
+        {
+            insert(position, first, last);
+            x.erase(first, last);
+        }
+
         void remove(const value_type& val) { remove_if(EqualPredicate(val)); }
 
         template <typename Predicate>
diff --git a/ReverseIterator.hpp b/ReverseIterator.hpp
new file mode 100644
index 0000000..504c0c1
--- /dev/null
+++ b/ReverseIterator.hpp
@@ -0,0 +1,80 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ReverseIterator.hpp                                :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2020/04/27 09:33:16 by charles           #+#    #+#             */
+/*   Updated: 2020/04/27 11:32:22 by charles          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef REVERSEITERATOR_HPP
+# define REVERSEITERATOR_HPP
+
+namespace ft
+{
+    template <typename Iterator>
+    class ReverseIterator
+    {
+    public:
+        typedef Iterator                           iterator_type;
+        typedef typename iterator_type::value_type value_type;
+        typedef int                                difference_type;
+
+        ReverseIterator() : m_it(iterator_type())                {}
+        ReverseIterator(const ReverseIterator& other)            { *this = other; }
+        ReverseIterator& operator=(const ReverseIterator& other) { m_it = other.m_it; return *this; }
+        ~ReverseIterator()                                       {}
+
+        explicit ReverseIterator(iterator_type it) : m_it(it)    {}
+
+        iterator_type base() const                     { return m_it; }
+
+        value_type& operator*()                        { return (m_it--).operator*(); }
+        value_type* operator->()                       { return &(operator*());       }
+
+        ReverseIterator operator+(difference_type n)   { m_it - n; return *this; }
+        ReverseIterator operator-(difference_type n)   { m_it + n; return *this; }
+
+        ReverseIterator& operator++()    { --m_it; return *this;                      }
+        ReverseIterator& operator--()    { --m_it; return *this;                      }
+        ReverseIterator  operator++(int) { ReverseIterator copy(*this); m_it++; return copy; }
+        ReverseIterator  operator--(int) { ReverseIterator copy(*this); m_it--; return copy; }
+
+        ReverseIterator& operator+=(difference_type n) { return m_it -= n; }
+        ReverseIterator& operator-=(difference_type n) { return m_it += n; }
+
+        value_type& operator[](difference_type n)      { return m_it[-n - 1]; }
+
+        bool operator==(const ReverseIterator& other) const { return m_it == other.m_it; }
+        bool operator!=(const ReverseIterator& other) const { return m_it != other.m_it; }
+
+        bool operator<(const ReverseIterator& other)  const { return m_it < other.m_it;  }
+        bool operator>(const ReverseIterator& other)  const { return m_it > other.m_it;  }
+        bool operator<=(const ReverseIterator& other) const { return m_it <= other.m_it; }
+        bool operator>=(const ReverseIterator& other) const { return m_it >= other.m_it; }
+
+    private:
+        iterator_type m_it;
+    };
+}
+
+template <typename Iterator>
+ft::ReverseIterator<Iterator> operator+(
+    typename ft::ReverseIterator<Iterator>::difference_type n,
+    const ft::ReverseIterator<Iterator>& rev_it)
+{
+    return rev_it + n;
+}
+
+template <typename Iterator>
+typename ft::ReverseIterator<Iterator>::difference_type  operator-(
+    const ft::ReverseIterator<Iterator>& lhs,
+    const ft::ReverseIterator<Iterator>& rhs)
+{
+    return lhs.base() - rhs.base();
+}
+
+#endif
diff --git a/Stack.hpp b/Stack.hpp
index 67e6ef8..8cfbdc3 100644
--- a/Stack.hpp
+++ b/Stack.hpp
@@ -6,7 +6,7 @@
 /*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2020/04/25 21:39:53 by charles           #+#    #+#             */
-/*   Updated: 2020/04/25 22:01:12 by charles          ###   ########.fr       */
+/*   Updated: 2020/04/26 14:45:04 by charles          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -22,15 +22,17 @@ namespace ft
 	class Stack : public Vector<T>
 	{
 	public:
-		explicit Stack() : Vector() {}
-        Stack(const Stack& other) : Vector(other) {}
-        Stack& operator=(const Stack& other) { return Vector::operator=(other); }
+        typedef T  value_type;
+
+		explicit Stack() : Vector<T>() {}
+        Stack(const Stack& other) : Vector<T>(other) {}
+        Stack& operator=(const Stack& other) { return Vector<T>::operator=(other); }
         ~Stack() {}
 
-		value_type&       top()                       { return back();  }
-		const value_type& top() const                 { return back();  }
-		void              push(const value_type& val) { push_back(val); }
-		void              pop()                       { pop_back();     }
+		value_type&       top()                       { return Vector<T>::back();  }
+		const value_type& top() const                 { return Vector<T>::back();  }
+		void              push(const value_type& val) { Vector<T>::push_back(val); }
+		void              pop()                       { Vector<T>::pop_back();     }
 	};
 }
 
diff --git a/Vector.hpp b/Vector.hpp
index 0fcfe8a..4a3c537 100644
--- a/Vector.hpp
+++ b/Vector.hpp
@@ -6,7 +6,7 @@
 /*   By: charles <charles.cabergs@gmail.com>        +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2020/04/24 16:19:04 by charles           #+#    #+#             */
-/*   Updated: 2020/04/26 08:40:14 by charles          ###   ########.fr       */
+/*   Updated: 2020/04/27 12:54:08 by charles          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -16,6 +16,7 @@
 # include <climits>
 # include <cstddef>
 # include <stdexcept>
+# include "ReverseIterator.hpp"
 
 # define FT_VECTOR_GROWTH_FACTOR 1.5
 
@@ -25,6 +26,7 @@ namespace ft
 	class Vector
 	{
         typedef Vector<T, Alloc>                         m_type;
+
     public:
 		typedef T                                        value_type;
 		typedef Alloc                                    allocator_type;
@@ -35,6 +37,69 @@ namespace ft
 		typedef ptrdiff_t                                difference_type;
 		typedef size_t                                   size_type;
 
+        class iterator
+        {
+            friend class Vector;
+        public:
+            typedef Vector::value_type      value_type;
+            typedef Vector::difference_type difference_type;
+
+            iterator() : m_ptr(NULL), m_pos(-1) {}
+            iterator(const iterator& other) : m_ptr(other.m_ptr), m_pos(other.m_pos) {}
+            ~iterator() {}
+
+            iterator& operator=(const iterator& other)
+            {
+                if (this == &other)
+                    return *this;
+                m_ptr = other.m_ptr;
+                m_pos = other.m_pos;
+                return *this;
+            }
+
+            value_type& operator*()  { return (*m_ptr)[m_pos];  }
+            value_type* operator->() { return &(*m_ptr)[m_pos]; }
+
+            bool operator==(const iterator& other) const { return m_pos == other.m_pos; }
+            bool operator!=(const iterator& other) const { return !(operator==(other)); }
+
+            bool operator<(const iterator& other)  const { return m_pos < other.m_pos; }
+            bool operator>(const iterator& other)  const { return other < *this;       }
+            bool operator<=(const iterator& other) const { return !(other < *this);    }
+            bool operator>=(const iterator& other) const { return !(*this < other);    }
+
+            iterator& operator++()    { m_pos++; return *this;                      }
+            iterator& operator--()    { m_pos--; return *this;                      }
+            iterator  operator++(int) { iterator copy(*this); m_pos++; return copy; }
+            iterator  operator--(int) { iterator copy(*this); m_pos--; return copy; }
+
+            iterator operator+(int n)        { iterator copy(*this); return copy += n;        }
+            iterator operator-(int n)        { iterator copy(*this); return copy -= n;        }
+            iterator operator+(iterator& it) { iterator copy(*this); return copy += it.m_pos; }
+            iterator operator-(iterator& it) { iterator copy(*this); return copy -= it.m_pos; }
+
+            iterator& operator+=(int n) { m_pos += n; return *this; }
+            iterator& operator-=(int n) { m_pos -= n; return *this; }
+
+            value_type& operator[](size_type n) { return (*m_ptr)[m_pos + n]; }
+
+            // tmp
+            iterator(Vector* ptr, size_type pos) : m_ptr(ptr), m_pos(pos) {}
+        protected:
+
+            Vector*   m_ptr;
+            size_type m_pos;
+        };
+
+        class const_iterator : public iterator
+        {
+            // const value_type& operator*()  { return m_ptr[m_pos]; }
+            // const value_type& operator->() { return m_ptr[m_pos]; }
+        };
+
+        typedef ReverseIterator<iterator>                reverse_iterator;
+        typedef ReverseIterator<const_iterator>          const_reverse_iterator;
+
         explicit Vector(const allocator_type& alloc = allocator_type())
             : m_under(new value_type[0]), m_size(0), m_capacity(0), m_alloc(alloc)
         {}
@@ -83,83 +148,19 @@ namespace ft
                 m_under[i] = x.m_under[i];
         }
 
-        class iterator
-        {
-            friend class Vector;
-        public:
-            iterator() : m_ptr(NULL), m_pos(-1), m_inc(0) {}
-
-            iterator(const iterator& other)
-                : m_ptr(other.m_ptr), m_pos(other.m_pos), m_inc(other.m_inc)
-            {}
-
-            iterator& operator=(const iterator& other)
-            {
-                if (this == &other)
-                    return *this;
-                m_ptr = other.m_ptr;
-                m_pos = other.m_pos;
-                m_inc = other.m_inc;
-                return *this;
-            }
-
-            ~iterator() {}
-
-            value_type& operator*()  { return (*m_ptr)[m_pos];  }
-            value_type* operator->() { return &(*m_ptr)[m_pos]; }
-
-            bool operator==(const iterator& other) const { return m_pos == other.m_pos; }
-            bool operator!=(const iterator& other) const { return !(operator==(other)); }
-
-            bool operator<(const iterator& other)  const { return m_pos < other.m_pos; }
-            bool operator>(const iterator& other)  const { return other < *this;       }
-            bool operator<=(const iterator& other) const { return !(other < *this);    }
-            bool operator>=(const iterator& other) const { return !(*this < other);    }
-
-            iterator& operator++()    { m_pos += m_inc; return *this;                      }
-            iterator& operator--()    { m_pos -= m_inc; return *this;                      }
-            iterator  operator++(int) { iterator copy(*this); m_pos += m_inc; return copy; }
-            iterator  operator--(int) { iterator copy(*this); m_pos -= m_inc; return copy; }
-
-            iterator operator+(int n)        { iterator copy(*this); return copy += m_inc * n;        }
-            iterator operator-(int n)        { iterator copy(*this); return copy -= m_inc * n;        }
-            iterator operator+(iterator& it) { iterator copy(*this); return copy += m_inc * it.m_pos; }
-            iterator operator-(iterator& it) { iterator copy(*this); return copy -= m_inc * it.m_pos; }
+        iterator               begin()        { return iterator(this, 0);                 }
+        iterator               end()          { return iterator(this, m_size);            }
+        const_iterator         begin()  const { return const_iterator(this, 0);           }
+        const_iterator         end()    const { return const_iterator(this, m_size);      }
+        reverse_iterator       rbegin()       { return reverse_iterator(iterator(this, m_size - 1));       }
+        reverse_iterator       rend()         { return reverse_iterator(iterator(this, -1));               }
+        const_reverse_iterator rbegin() const { return reverse_iterator(const_iterator(this, m_size - 1)); }
+        const_reverse_iterator rend()   const { return reverse_iterator(const_iterator(this, -1));         }
 
-            iterator& operator+=(int n) { m_pos += n; return *this; }
-            iterator& operator-=(int n) { m_pos -= n; return *this; }
-
-            value_type& operator[](size_type n) { return (*m_ptr)[m_pos + m_inc * n]; }
-
-            // tmp
-            iterator(Vector* ptr, size_type pos, int inc)
-                : m_ptr(ptr), m_pos(pos), m_inc(inc) {}
-        protected:
-
-            Vector*   m_ptr;
-            size_type m_pos;
-            int       m_inc;
-        };
-
-        class const_iterator : public iterator
-        {
-            // const value_type& operator*()  { return m_ptr[m_pos]; }
-            // const value_type& operator->() { return m_ptr[m_pos]; }
-        };
-
-        iterator       begin()        { return m_type::iterator(this, 0, 1);                 }
-        iterator       end()          { return m_type::iterator(this, m_size, 1);            }
-        iterator       rbegin()       { return m_type::iterator(this, m_size - 1, -1);       }
-        iterator       rend()         { return m_type::iterator(this, -1, -1);               }
-        const_iterator begin()  const { return m_type::const_iterator(this, 0, 1);           }
-        const_iterator end()    const { return m_type::const_iterator(this, m_size, 1);      }
-        const_iterator rbegin() const { return m_type::const_iterator(this, m_size - 1, -1); }
-        const_iterator rend()   const { return m_type::const_iterator(this, -1, -1);         }
-
-        size_type size()     const { return m_size;      }
-        size_type max_size() const { return UINT_MAX;    }
-        size_type capacity() const { return m_capacity;  }
-        bool      empty()    const { return m_size == 0; }
+        size_type              size()     const { return m_size;      }
+        size_type              max_size() const { return UINT_MAX;    }
+        size_type              capacity() const { return m_capacity;  }
+        bool                   empty()    const { return m_size == 0; }
 
         void resize(size_type n, value_type val = value_type())
         {
@@ -253,12 +254,18 @@ namespace ft
 
         iterator insert(iterator position, const value_type& val)
         {
-            m_size++;
-            reserve(m_size);
-            if (position != end())
-                for (iterator it = rbegin(); it != position; ++it)
-                    *it = *(it + 1);
-            *position = val;
+            reverse_iterator rev_position(position);
+
+            if (position == end())
+                push_back(val);
+            else
+            {
+                m_size++;
+                reserve(m_size);
+                for (reverse_iterator it = rbegin(); it != rev_position; ++it)
+                    it[0] = it[1];
+                *position = val;
+            }
             return position;
         }