vasilito
cb424d7448
verify-patch-sanity.py validates every active recipe .patch has internally- consistent hunk line counts — catching the 'malformed patch at line N' failure at commit/CI/preflight time instead of hours into a cook. This cycle hit that class three times (qtwaylandscanner, sddm, xwayland), each only discovered when cookbook tried to apply the patch. Running it across the repo found 29 latent malformed patches (validated against GNU patch: e.g. relibc/P3-sysv-ipc reproduces 'malformed patch at line 22'). They were harmless only because they sit in vendored recipes (baked, not re- applied) — but would fail on any version-bump re-derivation. --fix recounts the hunk headers (body untouched) and repaired all 29. Wired into build-preflight.sh (Phase 1.0D) and redbear-ci.yml, with a unit test (test-patch-sanity.sh). Skips archived/legacy trees and unvalidatable formats (empty placeholders, bare-@@ git hunks).
376 lines
14 KiB
C++
376 lines
14 KiB
C++
// -*- C++ -*-
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP_VECTOR
|
|
#define _LIBCPP_VECTOR
|
|
|
|
// clang-format off
|
|
|
|
/*
|
|
vector synopsis
|
|
|
|
namespace std
|
|
{
|
|
|
|
template <class T, class Allocator = allocator<T> >
|
|
class vector
|
|
{
|
|
public:
|
|
typedef T value_type;
|
|
typedef Allocator allocator_type;
|
|
typedef typename allocator_type::reference reference;
|
|
typedef typename allocator_type::const_reference const_reference;
|
|
typedef implementation-defined iterator;
|
|
typedef implementation-defined const_iterator;
|
|
typedef typename allocator_type::size_type size_type;
|
|
typedef typename allocator_type::difference_type difference_type;
|
|
typedef typename allocator_type::pointer pointer;
|
|
typedef typename allocator_type::const_pointer const_pointer;
|
|
typedef std::reverse_iterator<iterator> reverse_iterator;
|
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
|
|
vector()
|
|
noexcept(is_nothrow_default_constructible<allocator_type>::value);
|
|
explicit vector(const allocator_type&);
|
|
explicit vector(size_type n);
|
|
explicit vector(size_type n, const allocator_type&); // C++14
|
|
vector(size_type n, const value_type& value, const allocator_type& = allocator_type());
|
|
template <class InputIterator>
|
|
vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type());
|
|
template<container-compatible-range<T> R>
|
|
constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
|
|
vector(const vector& x);
|
|
vector(vector&& x)
|
|
noexcept(is_nothrow_move_constructible<allocator_type>::value);
|
|
vector(initializer_list<value_type> il);
|
|
vector(initializer_list<value_type> il, const allocator_type& a);
|
|
~vector();
|
|
vector& operator=(const vector& x);
|
|
vector& operator=(vector&& x)
|
|
noexcept(
|
|
allocator_type::propagate_on_container_move_assignment::value ||
|
|
allocator_type::is_always_equal::value); // C++17
|
|
vector& operator=(initializer_list<value_type> il);
|
|
template <class InputIterator>
|
|
void assign(InputIterator first, InputIterator last);
|
|
template<container-compatible-range<T> R>
|
|
constexpr void assign_range(R&& rg); // C++23
|
|
void assign(size_type n, const value_type& u);
|
|
void assign(initializer_list<value_type> il);
|
|
|
|
allocator_type get_allocator() const noexcept;
|
|
|
|
iterator begin() noexcept;
|
|
const_iterator begin() const noexcept;
|
|
iterator end() noexcept;
|
|
const_iterator end() const noexcept;
|
|
|
|
reverse_iterator rbegin() noexcept;
|
|
const_reverse_iterator rbegin() const noexcept;
|
|
reverse_iterator rend() noexcept;
|
|
const_reverse_iterator rend() const noexcept;
|
|
|
|
const_iterator cbegin() const noexcept;
|
|
const_iterator cend() const noexcept;
|
|
const_reverse_iterator crbegin() const noexcept;
|
|
const_reverse_iterator crend() const noexcept;
|
|
|
|
size_type size() const noexcept;
|
|
size_type max_size() const noexcept;
|
|
size_type capacity() const noexcept;
|
|
bool empty() const noexcept;
|
|
void reserve(size_type n);
|
|
void shrink_to_fit() noexcept;
|
|
|
|
reference operator[](size_type n);
|
|
const_reference operator[](size_type n) const;
|
|
reference at(size_type n);
|
|
const_reference at(size_type n) const;
|
|
|
|
reference front();
|
|
const_reference front() const;
|
|
reference back();
|
|
const_reference back() const;
|
|
|
|
value_type* data() noexcept;
|
|
const value_type* data() const noexcept;
|
|
|
|
void push_back(const value_type& x);
|
|
void push_back(value_type&& x);
|
|
template <class... Args>
|
|
reference emplace_back(Args&&... args); // reference in C++17
|
|
template<container-compatible-range<T> R>
|
|
constexpr void append_range(R&& rg); // C++23
|
|
void pop_back();
|
|
|
|
template <class... Args> iterator emplace(const_iterator position, Args&&... args);
|
|
iterator insert(const_iterator position, const value_type& x);
|
|
iterator insert(const_iterator position, value_type&& x);
|
|
iterator insert(const_iterator position, size_type n, const value_type& x);
|
|
template <class InputIterator>
|
|
iterator insert(const_iterator position, InputIterator first, InputIterator last);
|
|
template<container-compatible-range<T> R>
|
|
constexpr iterator insert_range(const_iterator position, R&& rg); // C++23
|
|
iterator insert(const_iterator position, initializer_list<value_type> il);
|
|
|
|
iterator erase(const_iterator position);
|
|
iterator erase(const_iterator first, const_iterator last);
|
|
|
|
void clear() noexcept;
|
|
|
|
void resize(size_type sz);
|
|
void resize(size_type sz, const value_type& c);
|
|
|
|
void swap(vector&)
|
|
noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value ||
|
|
allocator_traits<allocator_type>::is_always_equal::value); // C++17
|
|
|
|
bool __invariants() const;
|
|
};
|
|
|
|
template <class Allocator = allocator<T> >
|
|
class vector<bool, Allocator>
|
|
{
|
|
public:
|
|
typedef bool value_type;
|
|
typedef Allocator allocator_type;
|
|
typedef implementation-defined iterator;
|
|
typedef implementation-defined const_iterator;
|
|
typedef typename allocator_type::size_type size_type;
|
|
typedef typename allocator_type::difference_type difference_type;
|
|
typedef iterator pointer;
|
|
typedef const_iterator const_pointer;
|
|
typedef std::reverse_iterator<iterator> reverse_iterator;
|
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
|
|
class reference
|
|
{
|
|
public:
|
|
reference(const reference&) noexcept;
|
|
operator bool() const noexcept;
|
|
reference& operator=(bool x) noexcept;
|
|
reference& operator=(const reference& x) noexcept;
|
|
iterator operator&() const noexcept;
|
|
void flip() noexcept;
|
|
};
|
|
|
|
class const_reference
|
|
{
|
|
public:
|
|
const_reference(const reference&) noexcept;
|
|
operator bool() const noexcept;
|
|
const_iterator operator&() const noexcept;
|
|
};
|
|
|
|
vector()
|
|
noexcept(is_nothrow_default_constructible<allocator_type>::value);
|
|
explicit vector(const allocator_type&) noexcept;
|
|
explicit vector(size_type n, const allocator_type& a = allocator_type()); // C++14
|
|
vector(size_type n, const value_type& value, const allocator_type& = allocator_type());
|
|
template <class InputIterator>
|
|
vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type());
|
|
template<container-compatible-range<bool> R>
|
|
constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator());
|
|
vector(const vector& x);
|
|
vector(vector&& x) noexcept;
|
|
vector(initializer_list<value_type> il);
|
|
vector(initializer_list<value_type> il, const allocator_type& a);
|
|
~vector();
|
|
vector& operator=(const vector& x);
|
|
vector& operator=(vector&& x)
|
|
noexcept(
|
|
allocator_type::propagate_on_container_move_assignment::value ||
|
|
allocator_type::is_always_equal::value); // C++17
|
|
vector& operator=(initializer_list<value_type> il);
|
|
template <class InputIterator>
|
|
void assign(InputIterator first, InputIterator last);
|
|
template<container-compatible-range<T> R>
|
|
constexpr void assign_range(R&& rg); // C++23
|
|
void assign(size_type n, const value_type& u);
|
|
void assign(initializer_list<value_type> il);
|
|
|
|
allocator_type get_allocator() const noexcept;
|
|
|
|
iterator begin() noexcept;
|
|
const_iterator begin() const noexcept;
|
|
iterator end() noexcept;
|
|
const_iterator end() const noexcept;
|
|
|
|
reverse_iterator rbegin() noexcept;
|
|
const_reverse_iterator rbegin() const noexcept;
|
|
reverse_iterator rend() noexcept;
|
|
const_reverse_iterator rend() const noexcept;
|
|
|
|
const_iterator cbegin() const noexcept;
|
|
const_iterator cend() const noexcept;
|
|
const_reverse_iterator crbegin() const noexcept;
|
|
const_reverse_iterator crend() const noexcept;
|
|
|
|
size_type size() const noexcept;
|
|
size_type max_size() const noexcept;
|
|
size_type capacity() const noexcept;
|
|
bool empty() const noexcept;
|
|
void reserve(size_type n);
|
|
void shrink_to_fit() noexcept;
|
|
|
|
reference operator[](size_type n);
|
|
const_reference operator[](size_type n) const;
|
|
reference at(size_type n);
|
|
const_reference at(size_type n) const;
|
|
|
|
reference front();
|
|
const_reference front() const;
|
|
reference back();
|
|
const_reference back() const;
|
|
|
|
void push_back(const value_type& x);
|
|
template <class... Args> reference emplace_back(Args&&... args); // C++14; reference in C++17
|
|
template<container-compatible-range<T> R>
|
|
constexpr void append_range(R&& rg); // C++23
|
|
void pop_back();
|
|
|
|
template <class... Args> iterator emplace(const_iterator position, Args&&... args); // C++14
|
|
iterator insert(const_iterator position, const value_type& x);
|
|
iterator insert(const_iterator position, size_type n, const value_type& x);
|
|
template <class InputIterator>
|
|
iterator insert(const_iterator position, InputIterator first, InputIterator last);
|
|
template<container-compatible-range<T> R>
|
|
constexpr iterator insert_range(const_iterator position, R&& rg); // C++23
|
|
iterator insert(const_iterator position, initializer_list<value_type> il);
|
|
|
|
iterator erase(const_iterator position);
|
|
iterator erase(const_iterator first, const_iterator last);
|
|
|
|
void clear() noexcept;
|
|
|
|
void resize(size_type sz);
|
|
void resize(size_type sz, value_type x);
|
|
|
|
void swap(vector&)
|
|
noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value ||
|
|
allocator_traits<allocator_type>::is_always_equal::value); // C++17
|
|
void flip() noexcept;
|
|
|
|
bool __invariants() const;
|
|
};
|
|
|
|
template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
|
|
vector(InputIterator, InputIterator, Allocator = Allocator())
|
|
-> vector<typename iterator_traits<InputIterator>::value_type, Allocator>; // C++17
|
|
|
|
template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
|
|
vector(from_range_t, R&&, Allocator = Allocator())
|
|
-> vector<ranges::range_value_t<R>, Allocator>; // C++23
|
|
|
|
template <class Allocator> struct hash<std::vector<bool, Allocator>>;
|
|
|
|
template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y); // constexpr since C++20
|
|
template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20
|
|
template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20
|
|
template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20
|
|
template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20
|
|
template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); // removed in C++20
|
|
template <class T, class Allocator> constexpr
|
|
constexpr synth-three-way-result<T> operator<=>(const vector<T, Allocator>& x,
|
|
const vector<T, Allocator>& y); // since C++20
|
|
|
|
template <class T, class Allocator>
|
|
void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
|
|
noexcept(noexcept(x.swap(y)));
|
|
|
|
template <class T, class Allocator, class U>
|
|
typename vector<T, Allocator>::size_type
|
|
erase(vector<T, Allocator>& c, const U& value); // since C++20
|
|
template <class T, class Allocator, class Predicate>
|
|
typename vector<T, Allocator>::size_type
|
|
erase_if(vector<T, Allocator>& c, Predicate pred); // since C++20
|
|
|
|
|
|
template<class T>
|
|
inline constexpr bool is-vector-bool-reference = see below; // exposition only, since C++23
|
|
|
|
template<class T, class charT> requires is-vector-bool-reference<T> // Since C++23
|
|
struct formatter<T, charT>;
|
|
|
|
} // std
|
|
|
|
*/
|
|
|
|
// clang-format on
|
|
|
|
#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
|
|
# include <__cxx03/vector>
|
|
#else
|
|
# include <__config>
|
|
|
|
# include <__vector/comparison.h>
|
|
# include <__vector/swap.h>
|
|
# include <__vector/vector.h>
|
|
# include <__vector/vector_bool.h>
|
|
|
|
# if _LIBCPP_STD_VER >= 17
|
|
# include <__vector/pmr.h>
|
|
# endif
|
|
|
|
# if _LIBCPP_STD_VER >= 20
|
|
# include <__vector/erase.h>
|
|
# endif
|
|
|
|
# if _LIBCPP_STD_VER >= 23
|
|
# include <__vector/vector_bool_formatter.h>
|
|
# endif
|
|
|
|
# include <version>
|
|
|
|
// standard-mandated includes
|
|
|
|
// [iterator.range]
|
|
# include <__iterator/access.h>
|
|
# include <__iterator/data.h>
|
|
# include <__iterator/empty.h>
|
|
# include <__iterator/reverse_access.h>
|
|
# include <__iterator/size.h>
|
|
|
|
// [vector.syn]
|
|
# include <compare>
|
|
# include <initializer_list>
|
|
|
|
// [vector.syn], [unord.hash]
|
|
# include <__functional/hash.h>
|
|
|
|
# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
# pragma GCC system_header
|
|
# endif
|
|
|
|
# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
|
|
# include <algorithm>
|
|
# include <array>
|
|
# include <atomic>
|
|
# include <cctype>
|
|
# include <cerrno>
|
|
# include <clocale>
|
|
# include <concepts>
|
|
# include <cstdint>
|
|
# include <cstdlib>
|
|
# include <iosfwd>
|
|
# if _LIBCPP_HAS_LOCALIZATION
|
|
# include <locale>
|
|
# endif
|
|
# include <optional>
|
|
# include <string>
|
|
# include <string_view>
|
|
# include <tuple>
|
|
# include <type_traits>
|
|
# include <typeinfo>
|
|
# include <utility>
|
|
# endif
|
|
#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
|
|
|
|
#endif // _LIBCPP_VECTOR
|