ft_containers/reverse_iterator.hpp at main · majermou/ft_containers · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   reverse_iterator.hpp                               :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: majermou <majermou@student.42.fr>          +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2021/10/16 13:48:17 by majermou          #+#    #+#             */
/*   Updated: 2021/10/18 12:28:57 by majermou         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#ifndef REVERSE_ITERATOR_HPP
#define REVERSE_ITERATOR_HPP

#include "iterators_traits.hpp"

template <typename iterator>
class ReverseIterator {
protected:
    iterator                                        current;
    typedef iterators_traits<iterator>              traits_type;
public:
    typedef iterator                                iterator_type;
    typedef typename traits_type::difference_type   difference_type;
    typedef typename traits_type::pointer           pointer;
    typedef typename traits_type::reference         reference;

    ReverseIterator(): current() {}
    explicit ReverseIterator(iterator_type x): current(x) {}
    ReverseIterator(const ReverseIterator& x): current(x.current) {}
    template<typename Iter>
    ReverseIterator(const ReverseIterator<Iter>& x): current(x.base()) {}
    iterator_type   base() const {
        return current;
    }
    reference    operator*() const {
        iterator tmp = current;
        return *--tmp;
    }
    pointer operator->() const {
        return &(operator*());
    }
    ReverseIterator&   operator++(){
        --current;
        return *this;
    }
    ReverseIterator    operator++(int) {
        ReverseIterator    tmp = *this;
        --current;
        return tmp;
    }
    ReverseIterator&   operator--() {
        ++current;
        return *this;
    }
    ReverseIterator    operator--(int) {
        ReverseIterator    tmp = *this;
        ++current;
        return tmp;
    }
    ReverseIterator    operator+(difference_type n) const {
        return ReverseIterator(current - n);
    }
    ReverseIterator&   operator+=(difference_type n) {
        current -= n;
        return *this;
    }
    ReverseIterator    operator-(difference_type n) const {
        return ReverseIterator(current + n);
    }
    ReverseIterator&   operator-=(difference_type n) {
        current += n;
        return *this;
    }
    reference   operator[](difference_type n) const {
        return *(*this + n);
    }
};

template<typename iterator>
inline bool operator==(const ReverseIterator<iterator>& x, const ReverseIterator<iterator>& y) {
    return x.base() == y.base();
}
template<typename iterator>
inline bool operator<(const ReverseIterator<iterator>& x, const ReverseIterator<iterator>& y) {
    return y.base() < x.base();
}
template<typename _Iterator>
inline bool operator!=(const ReverseIterator<_Iterator>& x, const ReverseIterator<_Iterator>& y) {
    return !(x == y);
}
template<typename _Iterator>
inline bool operator>(const ReverseIterator<_Iterator>& x, const ReverseIterator<_Iterator>& y) {
    return y < x;
}
template<typename _Iterator>
inline bool operator<=(const ReverseIterator<_Iterator>& x, const ReverseIterator<_Iterator>& y) {
    return !(y < x);
}
template<typename _Iterator>
inline bool operator>=(const ReverseIterator<_Iterator>& x, const ReverseIterator<_Iterator>& y) {
    return !(x < y);
}

// Comparison of ReverseIterator to const ReverseIterator.
template<typename iteratorL, typename iteratorR>
inline  bool    operator==(const ReverseIterator<iteratorL>& x, const ReverseIterator<iteratorR>& y) {
    return x.base() == y.base();
}
template<typename iteratorL, typename iteratorR>
inline  bool    operator<(const ReverseIterator<iteratorL>& x, const ReverseIterator<iteratorR>& y) {
    return y.base() < x.base();
}
template<typename iteratorL, typename iteratorR>
inline  bool    operator!=(const ReverseIterator<iteratorL>& x, const ReverseIterator<iteratorR>& y) {
    return !(x == y);
}
template<typename iteratorL, typename iteratorR>
inline  bool    operator>(const ReverseIterator<iteratorL>& x, const ReverseIterator<iteratorR>& y) {
    return y < x;
}
template<typename iteratorL, typename iteratorR>
inline  bool    operator<=(const ReverseIterator<iteratorL>& x, const ReverseIterator<iteratorR>& y) {
    return !(y < x);
}
template<typename iteratorL, typename iteratorR>
inline  bool    operator>=(const ReverseIterator<iteratorL>& x, const ReverseIterator<iteratorR>& y) {
    return !(x < y);
}

template<typename iterator>
inline typename ReverseIterator<iterator>::difference_type  operator-(const ReverseIterator<iterator>& x, const ReverseIterator<iterator>& y) {
    return y.base() - x.base();
}
template<typename _IteratorL, typename _IteratorR>
inline typename ReverseIterator<_IteratorL>::difference_type    operator-(const ReverseIterator<_IteratorL>& x, const ReverseIterator<_IteratorR>& y) {
    return y.base() - x.base();
}

template<typename iterator>
inline ReverseIterator<iterator> operator+(typename ReverseIterator<iterator>::difference_type n, const ReverseIterator<iterator>& x) {
    return ReverseIterator<iterator>(x.base() - n);
}

#endif // REVERSE_ITERATOR_HPP