376 lines · plain
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-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCPP_VECTOR11#define _LIBCPP_VECTOR12 13// clang-format off14 15/*16 vector synopsis17 18namespace std19{20 21template <class T, class Allocator = allocator<T> >22class vector23{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++1443 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++2348 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++1759 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++2364 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++17108 template<container-compatible-range<T> R>109 constexpr void append_range(R&& rg); // C++23110 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++23120 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++17133 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 reference153 {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_reference164 {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++14175 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++17190 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++23195 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++17234 template<container-compatible-range<T> R>235 constexpr void append_range(R&& rg); // C++23236 void pop_back();237 238 template <class... Args> iterator emplace(const_iterator position, Args&&... args); // C++14239 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++23245 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++17258 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++17266 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++23270 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++20274template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20275template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20276template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20277template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20278template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20279template <class T, class Allocator> constexpr280 constexpr synth-three-way-result<T> operator<=>(const vector<T, Allocator>& x,281 const vector<T, Allocator>& y); // since C++20282 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_type289erase(vector<T, Allocator>& c, const U& value); // since C++20290template <class T, class Allocator, class Predicate>291typename vector<T, Allocator>::size_type292erase_if(vector<T, Allocator>& c, Predicate pred); // since C++20293 294 295template<class T>296 inline constexpr bool is-vector-bool-reference = see below; // exposition only, since C++23297 298template<class T, class charT> requires is-vector-bool-reference<T> // Since C++23299 struct formatter<T, charT>;300 301} // std302 303*/304 305// clang-format on306 307#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)308# include <__cxx03/vector>309#else310# 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 >= 17318# include <__vector/pmr.h>319# endif320 321# if _LIBCPP_STD_VER >= 20322# include <__vector/erase.h>323# endif324 325# if _LIBCPP_STD_VER >= 23326# include <__vector/vector_bool_formatter.h>327# endif328 329# include <version>330 331// standard-mandated includes332 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_header349# endif350 351# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20352# 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_LOCALIZATION363# include <locale>364# endif365# include <optional>366# include <string>367# include <string_view>368# include <tuple>369# include <type_traits>370# include <typeinfo>371# include <utility>372# endif373#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)374 375#endif // _LIBCPP_VECTOR376