root / lab4 / .minix-src / include / c++ / stack @ 14
History | View | Annotate | Download (9.01 KB)
| 1 | 13 | up20180614 | // -*- 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 | |||
| 17 | namespace std |
||
| 18 | {
|
||
| 19 | |||
| 20 | template <class T, class Container = deque<T>> |
||
| 21 | class stack |
||
| 22 | {
|
||
| 23 | public: |
||
| 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 | |||
| 30 | protected: |
||
| 31 | container_type c; |
||
| 32 | |||
| 33 | public: |
||
| 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> void emplace(Args&&... args); |
||
| 59 | void pop(); |
||
| 60 | |||
| 61 | void swap(stack& c) noexcept(noexcept(swap(c, q.c))); |
||
| 62 | }; |
||
| 63 | |||
| 64 | template <class T, class Container> |
||
| 65 | bool operator==(const stack<T, Container>& x, const stack<T, Container>& y); |
||
| 66 | template <class T, class Container> |
||
| 67 | bool operator< (const stack<T, Container>& x, const stack<T, Container>& y); |
||
| 68 | template <class T, class Container> |
||
| 69 | bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y); |
||
| 70 | template <class T, class Container> |
||
| 71 | bool operator> (const stack<T, Container>& x, const stack<T, Container>& y); |
||
| 72 | template <class T, class Container> |
||
| 73 | bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y); |
||
| 74 | template <class T, class Container> |
||
| 75 | bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y); |
||
| 76 | |||
| 77 | template <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 | |||
| 94 | template <class _Tp, class _Container = deque<_Tp> > class _LIBCPP_TYPE_VIS_ONLY stack; |
||
| 95 | |||
| 96 | template <class _Tp, class _Container> |
||
| 97 | _LIBCPP_INLINE_VISIBILITY |
||
| 98 | bool |
||
| 99 | operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y); |
||
| 100 | |||
| 101 | template <class _Tp, class _Container> |
||
| 102 | _LIBCPP_INLINE_VISIBILITY |
||
| 103 | bool |
||
| 104 | operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y); |
||
| 105 | |||
| 106 | template <class _Tp, class _Container /*= deque<_Tp>*/> |
||
| 107 | class _LIBCPP_TYPE_VIS_ONLY stack |
||
| 108 | {
|
||
| 109 | public: |
||
| 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 | |||
| 116 | protected: |
||
| 117 | container_type c; |
||
| 118 | |||
| 119 | public: |
||
| 120 | _LIBCPP_INLINE_VISIBILITY |
||
| 121 | stack() |
||
| 122 | _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value) |
||
| 123 | : c() {}
|
||
| 124 | |||
| 125 | _LIBCPP_INLINE_VISIBILITY |
||
| 126 | stack(const stack& __q) : c(__q.c) {}
|
||
| 127 | |||
| 128 | #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
||
| 129 | _LIBCPP_INLINE_VISIBILITY |
||
| 130 | stack(stack&& __q) |
||
| 131 | _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value) |
||
| 132 | : c(_VSTD::move(__q.c)) {}
|
||
| 133 | #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
||
| 134 | |||
| 135 | _LIBCPP_INLINE_VISIBILITY |
||
| 136 | stack& operator=(const stack& __q) {c = __q.c; return *this;}
|
||
| 137 | |||
| 138 | #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
||
| 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 | #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
||
| 144 | |||
| 145 | _LIBCPP_INLINE_VISIBILITY |
||
| 146 | explicit stack(const container_type& __c) : c(__c) {}
|
||
| 147 | #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
||
| 148 | _LIBCPP_INLINE_VISIBILITY |
||
| 149 | explicit stack(container_type&& __c) : c(_VSTD::move(__c)) {}
|
||
| 150 | #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
||
| 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_HAS_NO_RVALUE_REFERENCES |
||
| 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_HAS_NO_RVALUE_REFERENCES |
||
| 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_HAS_NO_RVALUE_REFERENCES |
||
| 196 | _LIBCPP_INLINE_VISIBILITY |
||
| 197 | void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}
|
||
| 198 | #ifndef _LIBCPP_HAS_NO_VARIADICS |
||
| 199 | template <class... _Args> |
||
| 200 | _LIBCPP_INLINE_VISIBILITY |
||
| 201 | void emplace(_Args&&... __args) |
||
| 202 | {c.emplace_back(_VSTD::forward<_Args>(__args)...);}
|
||
| 203 | #endif // _LIBCPP_HAS_NO_VARIADICS |
||
| 204 | #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
||
| 205 | _LIBCPP_INLINE_VISIBILITY |
||
| 206 | void pop() {c.pop_back();}
|
||
| 207 | |||
| 208 | _LIBCPP_INLINE_VISIBILITY |
||
| 209 | void swap(stack& __s) |
||
| 210 | _NOEXCEPT_(__is_nothrow_swappable<container_type>::value) |
||
| 211 | {
|
||
| 212 | using _VSTD::swap; |
||
| 213 | swap(c, __s.c); |
||
| 214 | } |
||
| 215 | |||
| 216 | template <class T1, class _C1> |
||
| 217 | friend |
||
| 218 | bool |
||
| 219 | operator==(const stack<T1, _C1>& __x, const stack<T1, _C1>& __y); |
||
| 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 | |||
| 227 | template <class _Tp, class _Container> |
||
| 228 | inline _LIBCPP_INLINE_VISIBILITY |
||
| 229 | bool |
||
| 230 | operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) |
||
| 231 | {
|
||
| 232 | return __x.c == __y.c; |
||
| 233 | } |
||
| 234 | |||
| 235 | template <class _Tp, class _Container> |
||
| 236 | inline _LIBCPP_INLINE_VISIBILITY |
||
| 237 | bool |
||
| 238 | operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) |
||
| 239 | {
|
||
| 240 | return __x.c < __y.c; |
||
| 241 | } |
||
| 242 | |||
| 243 | template <class _Tp, class _Container> |
||
| 244 | inline _LIBCPP_INLINE_VISIBILITY |
||
| 245 | bool |
||
| 246 | operator!=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) |
||
| 247 | {
|
||
| 248 | return !(__x == __y); |
||
| 249 | } |
||
| 250 | |||
| 251 | template <class _Tp, class _Container> |
||
| 252 | inline _LIBCPP_INLINE_VISIBILITY |
||
| 253 | bool |
||
| 254 | operator> (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) |
||
| 255 | {
|
||
| 256 | return __y < __x; |
||
| 257 | } |
||
| 258 | |||
| 259 | template <class _Tp, class _Container> |
||
| 260 | inline _LIBCPP_INLINE_VISIBILITY |
||
| 261 | bool |
||
| 262 | operator>=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) |
||
| 263 | {
|
||
| 264 | return !(__x < __y); |
||
| 265 | } |
||
| 266 | |||
| 267 | template <class _Tp, class _Container> |
||
| 268 | inline _LIBCPP_INLINE_VISIBILITY |
||
| 269 | bool |
||
| 270 | operator<=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) |
||
| 271 | {
|
||
| 272 | return !(__y < __x); |
||
| 273 | } |
||
| 274 | |||
| 275 | template <class _Tp, class _Container> |
||
| 276 | inline _LIBCPP_INLINE_VISIBILITY |
||
| 277 | void |
||
| 278 | swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y) |
||
| 279 | _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) |
||
| 280 | {
|
||
| 281 | __x.swap(__y); |
||
| 282 | } |
||
| 283 | |||
| 284 | template <class _Tp, class _Container, class _Alloc> |
||
| 285 | struct _LIBCPP_TYPE_VIS_ONLY uses_allocator<stack<_Tp, _Container>, _Alloc> |
||
| 286 | : public uses_allocator<_Container, _Alloc> |
||
| 287 | {
|
||
| 288 | }; |
||
| 289 | |||
| 290 | _LIBCPP_END_NAMESPACE_STD |
||
| 291 | |||
| 292 | #endif // _LIBCPP_STACK |