1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
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-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_VECTOR
11#define _LIBCPP_VECTOR
12
13// clang-format off
14
15/*
16 vector synopsis
17
18namespace std
19{
20
21template <class T, class Allocator = allocator<T> >
22class vector
23{
24public:
25 typedef T value_type;
26 typedef Allocator allocator_type;
27 typedef typename allocator_type::reference reference;
28 typedef typename allocator_type::const_reference const_reference;
29 typedef implementation-defined iterator;
30 typedef implementation-defined const_iterator;
31 typedef typename allocator_type::size_type size_type;
32 typedef typename allocator_type::difference_type difference_type;
33 typedef typename allocator_type::pointer pointer;
34 typedef typename allocator_type::const_pointer const_pointer;
35 typedef std::reverse_iterator<iterator> reverse_iterator;
36 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
37
38 vector()
39 noexcept(is_nothrow_default_constructible<allocator_type>::value);
40 explicit vector(const allocator_type&);
41 explicit vector(size_type n);
42 explicit vector(size_type n, const allocator_type&); // C++14
43 vector(size_type n, const value_type& value, const allocator_type& = allocator_type());
44 template <class InputIterator>
45 vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type());
46 template<container-compatible-range<T> R>
47 constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
48 vector(const vector& x);
49 vector(vector&& x)
50 noexcept(is_nothrow_move_constructible<allocator_type>::value);
51 vector(initializer_list<value_type> il);
52 vector(initializer_list<value_type> il, const allocator_type& a);
53 ~vector();
54 vector& operator=(const vector& x);
55 vector& operator=(vector&& x)
56 noexcept(
57 allocator_type::propagate_on_container_move_assignment::value ||
58 allocator_type::is_always_equal::value); // C++17
59 vector& operator=(initializer_list<value_type> il);
60 template <class InputIterator>
61 void assign(InputIterator first, InputIterator last);
62 template<container-compatible-range<T> R>
63 constexpr void assign_range(R&& rg); // C++23
64 void assign(size_type n, const value_type& u);
65 void assign(initializer_list<value_type> il);
66
67 allocator_type get_allocator() const noexcept;
68
69 iterator begin() noexcept;
70 const_iterator begin() const noexcept;
71 iterator end() noexcept;
72 const_iterator end() const noexcept;
73
74 reverse_iterator rbegin() noexcept;
75 const_reverse_iterator rbegin() const noexcept;
76 reverse_iterator rend() noexcept;
77 const_reverse_iterator rend() const noexcept;
78
79 const_iterator cbegin() const noexcept;
80 const_iterator cend() const noexcept;
81 const_reverse_iterator crbegin() const noexcept;
82 const_reverse_iterator crend() const noexcept;
83
84 size_type size() const noexcept;
85 size_type max_size() const noexcept;
86 size_type capacity() const noexcept;
87 bool empty() const noexcept;
88 void reserve(size_type n);
89 void shrink_to_fit() noexcept;
90
91 reference operator[](size_type n);
92 const_reference operator[](size_type n) const;
93 reference at(size_type n);
94 const_reference at(size_type n) const;
95
96 reference front();
97 const_reference front() const;
98 reference back();
99 const_reference back() const;
100
101 value_type* data() noexcept;
102 const value_type* data() const noexcept;
103
104 void push_back(const value_type& x);
105 void push_back(value_type&& x);
106 template <class... Args>
107 reference emplace_back(Args&&... args); // reference in C++17
108 template<container-compatible-range<T> R>
109 constexpr void append_range(R&& rg); // C++23
110 void pop_back();
111
112 template <class... Args> iterator emplace(const_iterator position, Args&&... args);
113 iterator insert(const_iterator position, const value_type& x);
114 iterator insert(const_iterator position, value_type&& x);
115 iterator insert(const_iterator position, size_type n, const value_type& x);
116 template <class InputIterator>
117 iterator insert(const_iterator position, InputIterator first, InputIterator last);
118 template<container-compatible-range<T> R>
119 constexpr iterator insert_range(const_iterator position, R&& rg); // C++23
120 iterator insert(const_iterator position, initializer_list<value_type> il);
121
122 iterator erase(const_iterator position);
123 iterator erase(const_iterator first, const_iterator last);
124
125 void clear() noexcept;
126
127 void resize(size_type sz);
128 void resize(size_type sz, const value_type& c);
129
130 void swap(vector&)
131 noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value ||
132 allocator_traits<allocator_type>::is_always_equal::value); // C++17
133
134 bool __invariants() const;
135};
136
137template <class Allocator = allocator<T> >
138class vector<bool, Allocator>
139{
140public:
141 typedef bool value_type;
142 typedef Allocator allocator_type;
143 typedef implementation-defined iterator;
144 typedef implementation-defined const_iterator;
145 typedef typename allocator_type::size_type size_type;
146 typedef typename allocator_type::difference_type difference_type;
147 typedef iterator pointer;
148 typedef const_iterator const_pointer;
149 typedef std::reverse_iterator<iterator> reverse_iterator;
150 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
151
152 class reference
153 {
154 public:
155 reference(const reference&) noexcept;
156 operator bool() const noexcept;
157 reference& operator=(bool x) noexcept;
158 reference& operator=(const reference& x) noexcept;
159 iterator operator&() const noexcept;
160 void flip() noexcept;
161 };
162
163 class const_reference
164 {
165 public:
166 const_reference(const reference&) noexcept;
167 operator bool() const noexcept;
168 const_iterator operator&() const noexcept;
169 };
170
171 vector()
172 noexcept(is_nothrow_default_constructible<allocator_type>::value);
173 explicit vector(const allocator_type&) noexcept;
174 explicit vector(size_type n, const allocator_type& a = allocator_type()); // C++14
175 vector(size_type n, const value_type& value, const allocator_type& = allocator_type());
176 template <class InputIterator>
177 vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type());
178 template<container-compatible-range<bool> R>
179 constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator());
180 vector(const vector& x);
181 vector(vector&& x) noexcept;
182 vector(initializer_list<value_type> il);
183 vector(initializer_list<value_type> il, const allocator_type& a);
184 ~vector();
185 vector& operator=(const vector& x);
186 vector& operator=(vector&& x)
187 noexcept(
188 allocator_type::propagate_on_container_move_assignment::value ||
189 allocator_type::is_always_equal::value); // C++17
190 vector& operator=(initializer_list<value_type> il);
191 template <class InputIterator>
192 void assign(InputIterator first, InputIterator last);
193 template<container-compatible-range<T> R>
194 constexpr void assign_range(R&& rg); // C++23
195 void assign(size_type n, const value_type& u);
196 void assign(initializer_list<value_type> il);
197
198 allocator_type get_allocator() const noexcept;
199
200 iterator begin() noexcept;
201 const_iterator begin() const noexcept;
202 iterator end() noexcept;
203 const_iterator end() const noexcept;
204
205 reverse_iterator rbegin() noexcept;
206 const_reverse_iterator rbegin() const noexcept;
207 reverse_iterator rend() noexcept;
208 const_reverse_iterator rend() const noexcept;
209
210 const_iterator cbegin() const noexcept;
211 const_iterator cend() const noexcept;
212 const_reverse_iterator crbegin() const noexcept;
213 const_reverse_iterator crend() const noexcept;
214
215 size_type size() const noexcept;
216 size_type max_size() const noexcept;
217 size_type capacity() const noexcept;
218 bool empty() const noexcept;
219 void reserve(size_type n);
220 void shrink_to_fit() noexcept;
221
222 reference operator[](size_type n);
223 const_reference operator[](size_type n) const;
224 reference at(size_type n);
225 const_reference at(size_type n) const;
226
227 reference front();
228 const_reference front() const;
229 reference back();
230 const_reference back() const;
231
232 void push_back(const value_type& x);
233 template <class... Args> reference emplace_back(Args&&... args); // C++14; reference in C++17
234 template<container-compatible-range<T> R>
235 constexpr void append_range(R&& rg); // C++23
236 void pop_back();
237
238 template <class... Args> iterator emplace(const_iterator position, Args&&... args); // C++14
239 iterator insert(const_iterator position, const value_type& x);
240 iterator insert(const_iterator position, size_type n, const value_type& x);
241 template <class InputIterator>
242 iterator insert(const_iterator position, InputIterator first, InputIterator last);
243 template<container-compatible-range<T> R>
244 constexpr iterator insert_range(const_iterator position, R&& rg); // C++23
245 iterator insert(const_iterator position, initializer_list<value_type> il);
246
247 iterator erase(const_iterator position);
248 iterator erase(const_iterator first, const_iterator last);
249
250 void clear() noexcept;
251
252 void resize(size_type sz);
253 void resize(size_type sz, value_type x);
254
255 void swap(vector&)
256 noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value ||
257 allocator_traits<allocator_type>::is_always_equal::value); // C++17
258 void flip() noexcept;
259
260 bool __invariants() const;
261};
262
263template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
264 vector(InputIterator, InputIterator, Allocator = Allocator())
265 -> vector<typename iterator_traits<InputIterator>::value_type, Allocator>; // C++17
266
267template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
268 vector(from_range_t, R&&, Allocator = Allocator())
269 -> vector<ranges::range_value_t<R>, Allocator>; // C++23
270
271template <class Allocator> struct hash<std::vector<bool, Allocator>>;
272
273template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y); // constexpr since C++20
274template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20
275template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20
276template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20
277template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20
278template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20
279template <class T, class Allocator> constexpr
280 constexpr synth-three-way-result<T> operator<=>(const vector<T, Allocator>& x,
281 const vector<T, Allocator>& y); // since C++20
282
283template <class T, class Allocator>
284void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
285 noexcept(noexcept(x.swap(y)));
286
287template <class T, class Allocator, class U>
288typename vector<T, Allocator>::size_type
289erase(vector<T, Allocator>& c, const U& value); // since C++20
290template <class T, class Allocator, class Predicate>
291typename vector<T, Allocator>::size_type
292erase_if(vector<T, Allocator>& c, Predicate pred); // since C++20
293
294
295template<class T>
296 inline constexpr bool is-vector-bool-reference = see below; // exposition only, since C++23
297
298template<class T, class charT> requires is-vector-bool-reference<T> // Since C++23
299 struct formatter<T, charT>;
300
301} // std
302
303*/
304
305// clang-format on
306
307#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
308# include <__cxx03/vector>
309#else
310# include <__config>
311
312# include <__vector/comparison.h>
313# include <__vector/swap.h>
314# include <__vector/vector.h>
315# include <__vector/vector_bool.h>
316
317# if _LIBCPP_STD_VER >= 17
318# include <__vector/pmr.h>
319# endif
320
321# if _LIBCPP_STD_VER >= 20
322# include <__vector/erase.h>
323# endif
324
325# if _LIBCPP_STD_VER >= 23
326# include <__vector/vector_bool_formatter.h>
327# endif
328
329# include <version>
330
331// standard-mandated includes
332
333// [iterator.range]
334# include <__iterator/access.h>
335# include <__iterator/data.h>
336# include <__iterator/empty.h>
337# include <__iterator/reverse_access.h>
338# include <__iterator/size.h>
339
340// [vector.syn]
341# include <compare>
342# include <initializer_list>
343
344// [vector.syn], [unord.hash]
345# include <__functional/hash.h>
346
347# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
348# pragma GCC system_header
349# endif
350
351# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
352# include <algorithm>
353# include <array>
354# include <atomic>
355# include <cctype>
356# include <cerrno>
357# include <clocale>
358# include <concepts>
359# include <cstdint>
360# include <cstdlib>
361# include <iosfwd>
362# if _LIBCPP_HAS_LOCALIZATION
363# include <locale>
364# endif
365# include <optional>
366# include <string>
367# include <string_view>
368# include <tuple>
369# include <type_traits>
370# include <typeinfo>
371# include <utility>
372# endif
373#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
374
375#endif // _LIBCPP_VECTOR
376