overby.me
this repo has no description
1// -*- C++ -*-
2//===---------------------------- stack -----------------------------------===//
3//
4// The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_STACK
12#define _LIBCPP_STACK
13
14/*
15 stack synopsis
16
17namespace std
18{
19
20template <class T, class Container = deque<T>>
21class stack
22{
23public:
24 typedef Container container_type;
25 typedef typename container_type::value_type value_type;
26 typedef typename container_type::reference reference;
27 typedef typename container_type::const_reference const_reference;
28 typedef typename container_type::size_type size_type;
29
30protected:
31 container_type c;
32
33public:
34 stack() = default;
35 ~stack() = default;
36
37 stack(const stack& q) = default;
38 stack(stack&& q) = default;
39
40 stack& operator=(const stack& q) = default;
41 stack& operator=(stack&& q) = default;
42
43 explicit stack(const container_type& c);
44 explicit stack(container_type&& c);
45 template <class Alloc> explicit stack(const Alloc& a);
46 template <class Alloc> stack(const container_type& c, const Alloc& a);
47 template <class Alloc> stack(container_type&& c, const Alloc& a);
48 template <class Alloc> stack(const stack& c, const Alloc& a);
49 template <class Alloc> stack(stack&& c, const Alloc& a);
50
51 bool empty() const;
52 size_type size() const;
53 reference top();
54 const_reference top() const;
55
56 void push(const value_type& x);
57 void push(value_type&& x);
58 template <class... Args> reference emplace(Args&&... args); // reference in C++17
59 void pop();
60
61 void swap(stack& c) noexcept(is_nothrow_swappable_v<Container>)
62};
63
64template <class T, class Container>
65 bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
66template <class T, class Container>
67 bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
68template <class T, class Container>
69 bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
70template <class T, class Container>
71 bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
72template <class T, class Container>
73 bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
74template <class T, class Container>
75 bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
76
77template <class T, class Container>
78 void swap(stack<T, Container>& x, stack<T, Container>& y)
79 noexcept(noexcept(x.swap(y)));
80
81} // std
82
83*/
84
85#include <__config>
86#include <deque>
87
88#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
89#pragma GCC system_header
90#endif
91
92_LIBCPP_BEGIN_NAMESPACE_STD
93
94template <class _Tp, class _Container = deque<_Tp> > class _LIBCPP_TEMPLATE_VIS stack;
95
96template <class _Tp, class _Container>
97_LIBCPP_INLINE_VISIBILITY
98bool
99operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
100
101template <class _Tp, class _Container>
102_LIBCPP_INLINE_VISIBILITY
103bool
104operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
105
106template <class _Tp, class _Container /*= deque<_Tp>*/>
107class _LIBCPP_TEMPLATE_VIS stack
108{
109public:
110 typedef _Container container_type;
111 typedef typename container_type::value_type value_type;
112 typedef typename container_type::reference reference;
113 typedef typename container_type::const_reference const_reference;
114 typedef typename container_type::size_type size_type;
115 static_assert((is_same<_Tp, value_type>::value), "" );
116
117protected:
118 container_type c;
119
120public:
121 _LIBCPP_INLINE_VISIBILITY
122 stack()
123 _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
124 : c() {}
125
126 _LIBCPP_INLINE_VISIBILITY
127 stack(const stack& __q) : c(__q.c) {}
128
129 _LIBCPP_INLINE_VISIBILITY
130 stack& operator=(const stack& __q) {c = __q.c; return *this;}
131
132
133#ifndef _LIBCPP_CXX03_LANG
134 _LIBCPP_INLINE_VISIBILITY
135 stack(stack&& __q)
136 _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
137 : c(_VSTD::move(__q.c)) {}
138
139 _LIBCPP_INLINE_VISIBILITY
140 stack& operator=(stack&& __q)
141 _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
142 {c = _VSTD::move(__q.c); return *this;}
143
144 _LIBCPP_INLINE_VISIBILITY
145 explicit stack(container_type&& __c) : c(_VSTD::move(__c)) {}
146#endif // _LIBCPP_CXX03_LANG
147
148 _LIBCPP_INLINE_VISIBILITY
149 explicit stack(const container_type& __c) : c(__c) {}
150
151 template <class _Alloc>
152 _LIBCPP_INLINE_VISIBILITY
153 explicit stack(const _Alloc& __a,
154 typename enable_if<uses_allocator<container_type,
155 _Alloc>::value>::type* = 0)
156 : c(__a) {}
157 template <class _Alloc>
158 _LIBCPP_INLINE_VISIBILITY
159 stack(const container_type& __c, const _Alloc& __a,
160 typename enable_if<uses_allocator<container_type,
161 _Alloc>::value>::type* = 0)
162 : c(__c, __a) {}
163 template <class _Alloc>
164 _LIBCPP_INLINE_VISIBILITY
165 stack(const stack& __s, const _Alloc& __a,
166 typename enable_if<uses_allocator<container_type,
167 _Alloc>::value>::type* = 0)
168 : c(__s.c, __a) {}
169#ifndef _LIBCPP_CXX03_LANG
170 template <class _Alloc>
171 _LIBCPP_INLINE_VISIBILITY
172 stack(container_type&& __c, const _Alloc& __a,
173 typename enable_if<uses_allocator<container_type,
174 _Alloc>::value>::type* = 0)
175 : c(_VSTD::move(__c), __a) {}
176 template <class _Alloc>
177 _LIBCPP_INLINE_VISIBILITY
178 stack(stack&& __s, const _Alloc& __a,
179 typename enable_if<uses_allocator<container_type,
180 _Alloc>::value>::type* = 0)
181 : c(_VSTD::move(__s.c), __a) {}
182#endif // _LIBCPP_CXX03_LANG
183
184 _LIBCPP_INLINE_VISIBILITY
185 bool empty() const {return c.empty();}
186 _LIBCPP_INLINE_VISIBILITY
187 size_type size() const {return c.size();}
188 _LIBCPP_INLINE_VISIBILITY
189 reference top() {return c.back();}
190 _LIBCPP_INLINE_VISIBILITY
191 const_reference top() const {return c.back();}
192
193 _LIBCPP_INLINE_VISIBILITY
194 void push(const value_type& __v) {c.push_back(__v);}
195#ifndef _LIBCPP_CXX03_LANG
196 _LIBCPP_INLINE_VISIBILITY
197 void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}
198
199 template <class... _Args>
200 _LIBCPP_INLINE_VISIBILITY
201#if _LIBCPP_STD_VER > 14
202 reference emplace(_Args&&... __args)
203 { return c.emplace_back(_VSTD::forward<_Args>(__args)...);}
204#else
205 void emplace(_Args&&... __args)
206 { c.emplace_back(_VSTD::forward<_Args>(__args)...);}
207#endif
208#endif // _LIBCPP_CXX03_LANG
209
210 _LIBCPP_INLINE_VISIBILITY
211 void pop() {c.pop_back();}
212
213 _LIBCPP_INLINE_VISIBILITY
214 void swap(stack& __s)
215 _NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
216 {
217 using _VSTD::swap;
218 swap(c, __s.c);
219 }
220
221 template <class T1, class _C1>
222 friend
223 bool
224 operator==(const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);
225
226 template <class T1, class _C1>
227 friend
228 bool
229 operator< (const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);
230};
231
232template <class _Tp, class _Container>
233inline _LIBCPP_INLINE_VISIBILITY
234bool
235operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
236{
237 return __x.c == __y.c;
238}
239
240template <class _Tp, class _Container>
241inline _LIBCPP_INLINE_VISIBILITY
242bool
243operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
244{
245 return __x.c < __y.c;
246}
247
248template <class _Tp, class _Container>
249inline _LIBCPP_INLINE_VISIBILITY
250bool
251operator!=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
252{
253 return !(__x == __y);
254}
255
256template <class _Tp, class _Container>
257inline _LIBCPP_INLINE_VISIBILITY
258bool
259operator> (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
260{
261 return __y < __x;
262}
263
264template <class _Tp, class _Container>
265inline _LIBCPP_INLINE_VISIBILITY
266bool
267operator>=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
268{
269 return !(__x < __y);
270}
271
272template <class _Tp, class _Container>
273inline _LIBCPP_INLINE_VISIBILITY
274bool
275operator<=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
276{
277 return !(__y < __x);
278}
279
280template <class _Tp, class _Container>
281inline _LIBCPP_INLINE_VISIBILITY
282typename enable_if<
283 __is_swappable<_Container>::value,
284 void
285>::type
286swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y)
287 _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
288{
289 __x.swap(__y);
290}
291
292template <class _Tp, class _Container, class _Alloc>
293struct _LIBCPP_TEMPLATE_VIS uses_allocator<stack<_Tp, _Container>, _Alloc>
294 : public uses_allocator<_Container, _Alloc>
295{
296};
297
298_LIBCPP_END_NAMESPACE_STD
299
300#endif // _LIBCPP_STACK