ft_containers/stack.hpp at master · ajuncosa/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
#pragma once
#include "vector.hpp"

namespace ft
{
	template <class T, class Container = ft::vector<T> >
	class stack
	{
		public:
			typedef T value_type;
			typedef Container container_type;
			typedef size_t size_type;

			explicit stack(const container_type& ctnr = container_type()) : c(ctnr) {}

			stack(const stack &other) : c(other.c) {}

			stack &operator=(const stack &other)
			{
				if (this != &other)
					this->c = other.c;
				return *this;
			}

			~stack() {}

			bool empty() const
			{
				return this->c.empty();
			}

			size_type size() const
			{
				return this->c.size();
			}

			value_type& top()
			{
				return this->c.back();
			}

			const value_type& top() const
			{
				return this->c.back();
			}

			void push(const value_type& val)
			{
				this->c.push_back(val);
			}

			void pop()
			{
				this->c.pop_back();
			}

		protected:
			container_type	c;

		private:
			template <class U, class Cntr>
			friend bool operator==(const stack<U, Cntr>& lhs, const stack<U, Cntr>& rhs);

			template <class U, class Cntr>
			friend bool operator!=(const stack<U, Cntr>& lhs, const stack<U, Cntr>& rhs);

			template <class U, class Cntr>
			friend bool operator<(const stack<U, Cntr>& lhs, const stack<U, Cntr>& rhs);

			template <class U, class Cntr>
			friend bool operator<=(const stack<U, Cntr>& lhs, const stack<U, Cntr>& rhs);

			template <class U, class Cntr>
			friend bool operator>(const stack<U, Cntr>& lhs, const stack<U, Cntr>& rhs);

			template <class U, class Cntr>
			friend bool operator>=(const stack<U, Cntr>& lhs, const stack<U, Cntr>& rhs);
	};

	template <class T, class Container>
  	bool operator==(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
	{
		return lhs.c == rhs.c;
	}

	template <class T, class Container>
	bool operator!=(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
	{
		return lhs.c != rhs.c;
	}

	template <class T, class Container>
	bool operator<(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
	{
		return lhs.c < rhs.c;
	}

	template <class T, class Container>
	bool operator<=(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
	{
		return lhs.c <= rhs.c;
	}

	template <class T, class Container>
	bool operator>(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
	{
		return lhs.c > rhs.c;
	}

	template <class T, class Container>
	bool operator>=(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
	{
		return lhs.c >= rhs.c;
	}
}