ft_containers/list_iterator.hpp at master · evelon/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
#ifndef LIST_ITERATOR_HPP
# define LIST_ITERATOR_HPP

# include "iterator.hpp"
# include "DoublyLinkedNode.hpp"
# include "template_utils.hpp"


namespace	ft
{
	template	<typename Tp>
	class	list_iterator;

	template	<class Iterator>
	class	reverse_iterator;

	template	<typename Tp>
	class	list_iterator
	{
	private:
		typedef list_iterator<Tp>			iterator_;

	protected:
		typedef DoublyLinkedNode<Tp> 		node;

		template	<typename _Tp>
		void	is_compatible(list_iterator<_Tp> const& iter,
			typename enable_if<is_const_same<_Tp, Tp>::value>::type* = 0) const
			{ (void)iter; };

	public:
		typedef bidirectional_iterator_tag	iterator_category;
		typedef Tp							value_type;
		typedef Tp&							reference;
		typedef Tp*							pointer;
		typedef std::ptrdiff_t				difference_type;

	private:
		template	<typename T, class Alloc>
		friend class list;

		static value_type					default_value_;
		node*								ptrToNode_;

	protected:
		list_iterator(node* nod):
			ptrToNode_(nod) {};

		list_iterator(reverse_iterator<iterator_> const& rit):
			ptrToNode_(rit.ptrToNode_)
		{};

		node*&		getNode_(void)
			{ return (ptrToNode_); };
		reference	reverse_reference(void)
		{
			value_type*	value = this->ptrToNode_->getPrev()->getContent();
			if (value)
				return (*value);
			return (default_value_);
		};

	public:
		list_iterator(void):
			ptrToNode_(NULL) {};
		list_iterator(iterator_ const& iter):
			ptrToNode_(iter.ptrToNode_) {};
		template	<typename _Tp>
		list_iterator(list_iterator<_Tp> const& iter):
			ptrToNode_(((iterator_*)(&iter))->ptrToNode_)
		{
			typename disable_if<is_const_of<Tp, _Tp>::value>::type* dummy;
			(void)dummy;
		};
		virtual ~list_iterator(void) {};
		iterator_&	operator=(iterator_ const& iter)
		{
			this->ptrToNode_ = iter.ptrToNode_;
			return (*this);
		}
		template	<typename _Tp>
		iterator_&	operator=(list_iterator<_Tp> const& iter)
		{
			typename enable_if<is_const_same<_Tp, Tp>::value>::type*	dummy;
			(void)dummy;
			this->ptrToNode_ = ((iterator_*)(&iter))->ptrToNode_;
			return (*this);
		};
		reference	operator*(void)
		{
			value_type*	value = this->ptrToNode_->getContent();
			if (value)
				return (*value);
			return (default_value_);
		};
		template	<typename _Tp>
		bool		operator==(list_iterator<_Tp> const& iter) const
		{
			typename enable_if<is_const_same<_Tp, Tp>::value>::type*	dummy;
			(void)dummy;
			return (this->ptrToNode_ == ((iterator_*)(&iter))->ptrToNode_);
		};
		iterator_&	operator++(void)
		{
			// if (ptrToNode->getContent() != NULL)
				ptrToNode_ = ptrToNode_->getNext();
			return (*this);
		};
		iterator_	operator++(int)
		{
			iterator_	temp = *this;
			// if (ptrToNode->getContent() != NULL)
				ptrToNode_ = ptrToNode_->getNext();
			return (temp);
		};
		iterator_&	operator--(void)
		{
			// if (ptrToNode->getContent() != NULL)
				ptrToNode_ = ptrToNode_->getPrev();
			return (*this);
		};
		iterator_	operator--(int)
		{
			iterator_	temp = *this;
			// if (ptrToNode->getContent() != NULL)
				ptrToNode_ = ptrToNode_->getPrev();
			return (temp);
		};
		pointer		operator->(void) const
			{ return (this->ptrToNode_->getContent()); };
	};

	template	<typename Tp>
	bool		operator==(reverse_iterator<list_iterator<Tp> > const&, list_iterator<Tp> const&)
	{ typename disable_if<is_same<Tp, Tp>::value>::type* dummy; (void)dummy; }

	template	<typename Tp>
	bool		operator==(list_iterator<Tp> const&, reverse_iterator<list_iterator<Tp> > const&)
	{ typename disable_if<is_same<Tp, Tp>::value>::type* dummy; (void)dummy; }

	template	<typename Tp>
	Tp	list_iterator<Tp>::default_value_ = Tp();
}

#endif