codekingpro/portable-devtools
114k
1// -*- C++ -*-2//===---------------------------- stack -----------------------------------===//3//4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCUDACXX_STACK11#define _LIBCUDACXX_STACK12 13/*14 stack synopsis15 16namespace std17{18 19template <class T, class Container = deque<T>>20class stack21{22public:23 typedef Container container_type;24 typedef typename container_type::value_type value_type;25 typedef typename container_type::reference reference;26 typedef typename container_type::const_reference const_reference;27 typedef typename container_type::size_type size_type;28 29protected:30 container_type c;31 32public:33 stack() = default;34 ~stack() = default;35 36 stack(const stack& q) = default;37 stack(stack&& q) = default;38 39 stack& operator=(const stack& q) = default;40 stack& operator=(stack&& q) = default;41 42 explicit stack(const container_type& c);43 explicit stack(container_type&& c);44 template <class Alloc> explicit stack(const Alloc& a);45 template <class Alloc> stack(const container_type& c, const Alloc& a);46 template <class Alloc> stack(container_type&& c, const Alloc& a);47 template <class Alloc> stack(const stack& c, const Alloc& a);48 template <class Alloc> stack(stack&& c, const Alloc& a);49 50 bool empty() const;51 size_type size() const;52 reference top();53 const_reference top() const;54 55 void push(const value_type& x);56 void push(value_type&& x);57 template <class... Args> reference emplace(Args&&... args); // reference in C++1758 void pop();59 60 void swap(stack& c) noexcept(is_nothrow_swappable_v<Container>)61};62 63template<class Container>64 stack(Container) -> stack<typename Container::value_type, Container>; // C++1765 66template<class Container, class Allocator>67 stack(Container, Allocator) -> stack<typename Container::value_type, Container>; // C++1768 69template <class T, class Container>70 bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);71template <class T, class Container>72 bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);73template <class T, class Container>74 bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);75template <class T, class Container>76 bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);77template <class T, class Container>78 bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);79template <class T, class Container>80 bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);81 82template <class T, class Container>83 void swap(stack<T, Container>& x, stack<T, Container>& y)84 noexcept(noexcept(x.swap(y)));85 86} // std87 88*/89 90#include <__config>91#include <deque>92 93#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)94# pragma GCC system_header95#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)96# pragma clang system_header97#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)98# pragma system_header99#endif // no system header100 101_LIBCUDACXX_BEGIN_NAMESPACE_STD102 103template <class _Tp, class _Container = deque<_Tp> > class _LIBCUDACXX_TEMPLATE_VIS stack;104 105template <class _Tp, class _Container>106_LIBCUDACXX_INLINE_VISIBILITY107bool108operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);109 110template <class _Tp, class _Container>111_LIBCUDACXX_INLINE_VISIBILITY112bool113operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);114 115template <class _Tp, class _Container /*= deque<_Tp>*/>116class _LIBCUDACXX_TEMPLATE_VIS stack117{118public:119 typedef _Container container_type;120 typedef typename container_type::value_type value_type;121 typedef typename container_type::reference reference;122 typedef typename container_type::const_reference const_reference;123 typedef typename container_type::size_type size_type;124 static_assert((is_same<_Tp, value_type>::value), "" );125 126protected:127 container_type c;128 129public:130 _LIBCUDACXX_INLINE_VISIBILITY131 stack()132 noexcept(is_nothrow_default_constructible<container_type>::value)133 : c() {}134 135 _LIBCUDACXX_INLINE_VISIBILITY136 stack(const stack& __q) : c(__q.c) {}137 138 _LIBCUDACXX_INLINE_VISIBILITY139 stack& operator=(const stack& __q) {c = __q.c; return *this;}140 141 142 _LIBCUDACXX_INLINE_VISIBILITY143 stack(stack&& __q)144 noexcept(is_nothrow_move_constructible<container_type>::value)145 : c(_CUDA_VSTD::move(__q.c)) {}146 147 _LIBCUDACXX_INLINE_VISIBILITY148 stack& operator=(stack&& __q)149 noexcept(is_nothrow_move_assignable<container_type>::value)150 {c = _CUDA_VSTD::move(__q.c); return *this;}151 152 _LIBCUDACXX_INLINE_VISIBILITY153 explicit stack(container_type&& __c) : c(_CUDA_VSTD::move(__c)) {}154 155 _LIBCUDACXX_INLINE_VISIBILITY156 explicit stack(const container_type& __c) : c(__c) {}157 158 template <class _Alloc>159 _LIBCUDACXX_INLINE_VISIBILITY160 explicit stack(const _Alloc& __a,161 typename enable_if<uses_allocator<container_type,162 _Alloc>::value>::type* = 0)163 : c(__a) {}164 template <class _Alloc>165 _LIBCUDACXX_INLINE_VISIBILITY166 stack(const container_type& __c, const _Alloc& __a,167 typename enable_if<uses_allocator<container_type,168 _Alloc>::value>::type* = 0)169 : c(__c, __a) {}170 template <class _Alloc>171 _LIBCUDACXX_INLINE_VISIBILITY172 stack(const stack& __s, const _Alloc& __a,173 typename enable_if<uses_allocator<container_type,174 _Alloc>::value>::type* = 0)175 : c(__s.c, __a) {}176 template <class _Alloc>177 _LIBCUDACXX_INLINE_VISIBILITY178 stack(container_type&& __c, const _Alloc& __a,179 typename enable_if<uses_allocator<container_type,180 _Alloc>::value>::type* = 0)181 : c(_CUDA_VSTD::move(__c), __a) {}182 template <class _Alloc>183 _LIBCUDACXX_INLINE_VISIBILITY184 stack(stack&& __s, const _Alloc& __a,185 typename enable_if<uses_allocator<container_type,186 _Alloc>::value>::type* = 0)187 : c(_CUDA_VSTD::move(__s.c), __a) {}188 189 _LIBCUDACXX_NODISCARD_AFTER_CXX17 _LIBCUDACXX_INLINE_VISIBILITY190 bool empty() const {return c.empty();}191 _LIBCUDACXX_INLINE_VISIBILITY192 size_type size() const {return c.size();}193 _LIBCUDACXX_INLINE_VISIBILITY194 reference top() {return c.back();}195 _LIBCUDACXX_INLINE_VISIBILITY196 const_reference top() const {return c.back();}197 198 _LIBCUDACXX_INLINE_VISIBILITY199 void push(const value_type& __v) {c.push_back(__v);}200 _LIBCUDACXX_INLINE_VISIBILITY201 void push(value_type&& __v) {c.push_back(_CUDA_VSTD::move(__v));}202 203 template <class... _Args>204 _LIBCUDACXX_INLINE_VISIBILITY205#if _LIBCUDACXX_STD_VER > 14206 decltype(auto) emplace(_Args&&... __args)207 { return c.emplace_back(_CUDA_VSTD::forward<_Args>(__args)...);}208#else209 void emplace(_Args&&... __args)210 { c.emplace_back(_CUDA_VSTD::forward<_Args>(__args)...);}211#endif212 213 _LIBCUDACXX_INLINE_VISIBILITY214 void pop() {c.pop_back();}215 216 _LIBCUDACXX_INLINE_VISIBILITY217 void swap(stack& __s)218 noexcept(__is_nothrow_swappable<container_type>::value)219 {220 using _CUDA_VSTD::swap;221 swap(c, __s.c);222 }223 224 template <class T1, class _C1>225 friend226 bool227 operator==(const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);228 229 template <class T1, class _C1>230 friend231 bool232 operator< (const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);233};234 235#ifndef _LIBCUDACXX_HAS_NO_DEDUCTION_GUIDES236template<class _Container,237 class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type238>239stack(_Container)240 -> stack<typename _Container::value_type, _Container>;241 242template<class _Container,243 class _Alloc,244 class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type,245 class = typename enable_if< __is_allocator<_Alloc>::value, nullptr_t>::type246 >247stack(_Container, _Alloc)248 -> stack<typename _Container::value_type, _Container>;249#endif250 251template <class _Tp, class _Container>252inline _LIBCUDACXX_INLINE_VISIBILITY253bool254operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)255{256 return __x.c == __y.c;257}258 259template <class _Tp, class _Container>260inline _LIBCUDACXX_INLINE_VISIBILITY261bool262operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)263{264 return __x.c < __y.c;265}266 267template <class _Tp, class _Container>268inline _LIBCUDACXX_INLINE_VISIBILITY269bool270operator!=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)271{272 return !(__x == __y);273}274 275template <class _Tp, class _Container>276inline _LIBCUDACXX_INLINE_VISIBILITY277bool278operator> (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)279{280 return __y < __x;281}282 283template <class _Tp, class _Container>284inline _LIBCUDACXX_INLINE_VISIBILITY285bool286operator>=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)287{288 return !(__x < __y);289}290 291template <class _Tp, class _Container>292inline _LIBCUDACXX_INLINE_VISIBILITY293bool294operator<=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)295{296 return !(__y < __x);297}298 299template <class _Tp, class _Container>300inline _LIBCUDACXX_INLINE_VISIBILITY301typename enable_if<302 __is_swappable<_Container>::value,303 void304>::type305swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y)306 noexcept(noexcept(__x.swap(__y)))307{308 __x.swap(__y);309}310 311template <class _Tp, class _Container, class _Alloc>312struct _LIBCUDACXX_TEMPLATE_VIS uses_allocator<stack<_Tp, _Container>, _Alloc>313 : public uses_allocator<_Container, _Alloc>314{315};316 317_LIBCUDACXX_END_NAMESPACE_STD318 319#endif // _LIBCUDACXX_STACK320