cpp_containers/queue.hpp at main · FunckingCat/cpp_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
/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   queue.hpp                                          :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: davidzh <davidzh@student.42.fr>            +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2020/07/17 15:31:12 by tyamcha           #+#    #+#             */
/*   Updated: 2022/09/11 19:43:07 by davidzh          ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#ifndef QUEUE_HPP
# define QUEUE_HPP

# include <deque>

namespace ft
{
	template<typename _Tp, typename _Sequence = std::deque<_Tp> >
		class queue
		{
			typedef typename _Sequence::value_type _Sequence_value_type;

			template<typename _Tp1, typename _Seq1>
				friend bool
				operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);

			template<typename _Tp1, typename _Seq1>
				friend bool
				operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);

			public:
				typedef typename _Sequence::value_type			value_type;
				typedef typename _Sequence::reference			reference;
				typedef typename _Sequence::const_reference		const_reference;
				typedef typename _Sequence::size_type			size_type;
				typedef _Sequence								container_type;

			protected:
				_Sequence c;

			public:
				explicit
				queue(const _Sequence& c = _Sequence())
				: c(c)
				{}

				bool
				empty (void) const
				{
					return (c.empty());
				}

				size_type
				size (void) const
				{
					return (c.size());
				}

				reference
				front (void)
				{
					return (c.front());
				}

				const_reference
				front (void) const
				{
					return (c.front());
				}

				reference
				back (void)
				{
					return (c.back());
				}

				const_reference
				back (void) const
				{
					return (c.back());
				}

				void
				push(const value_type& x)
				{
					c.push_back(x);
				}

				void
				pop (void)
				{
					c.pop_front();
				}
		};

	template<typename _Tp, typename _Seq>
		inline bool
		operator==(const queue<_Tp, _Seq>& x, const queue<_Tp, _Seq>& y)
		{
			return (x.c == y.c);
		}

	template<typename _Tp, typename _Seq>
		inline bool
		operator<(const queue<_Tp, _Seq>& x, const queue<_Tp, _Seq>& y)
		{
			return (x.c < y.c);
		}

	template<typename _Tp, typename _Seq>
		inline bool
		operator!=(const queue<_Tp, _Seq>& x, const queue<_Tp, _Seq>& y)
		{
			return (!(x == y));
		}

	template<typename _Tp, typename _Seq>
		inline bool
		operator>(const queue<_Tp, _Seq>& x, const queue<_Tp, _Seq>& y)
		{
			return (y < x);
		}

	template<typename _Tp, typename _Seq>
		inline bool
		operator<=(const queue<_Tp, _Seq>& x, const queue<_Tp, _Seq>& y)
		{
			return (!(y < x));
		}

	template<typename _Tp, typename _Seq>
		inline bool
		operator>=(const queue<_Tp, _Seq>& x, const queue<_Tp, _Seq>& y)
		{
			return (!(x < y));
		}
}

#endif