Lines Matching +full:- +full:t
1 // -*- C++ -*-
2 //===----------------------------------------------------------------------===//
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
8 //===----------------------------------------------------------------------===//
13 // clang-format off
24 template <class T, class Alloc> struct uses_allocator;
38 template <class T>
39 struct pointer_traits<T*>
41 typedef T* pointer;
42 typedef T element_type;
50 template <class T> constexpr T* to_address(T* p) noexcept; // C++20
85 template <class T> using rebind_alloc = Alloc::rebind<T>::other | Alloc<T, Args...>;
86 template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
96 template <class T, class... Args>
97 static void construct(allocator_type& a, T* p, Args&&... args); // constexpr in C++20
99 template <class T>
100 static void destroy(allocator_type& a, T* p); // constexpr in C++20
123 template <class T>
129 typedef T* pointer; // deprecated in C++17, removed in C++20
130 typedef const T* const_pointer; // deprecated in C++17, removed in C++20
131 typedef typename add_lvalue_reference<T>::type
133 typedef typename add_lvalue_reference<const T>::type
136 typedef T value_type;
150 T* allocate(size_t n, const void* hint); // deprecated in C++17, removed in C++20
151 T* allocate(size_t n); // constexpr in C++20
152 void deallocate(T* p, size_t n) noexcept; // constexpr in C++20
160 template <class T, class U>
161 bool operator==(const allocator<T>&, const allocator<U>&) noexcept; // constexpr in C++20
163 template <class T, class U>
164 bool operator!=(const allocator<T>&, const allocator<U>&) noexcept; // removed in C++20
166 template <class OutputIterator, class T>
180 raw_storage_iterator& operator=(const T& element);
185 template <class T> pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept;
186 template <class T> void return_temporary_buffer(T* p) noexcept;
188 template <class T> T* addressof(T& r) noexcept;
189 template <class T> T* addressof(const T&& r) noexcept = delete;
200 …iterator InputIterator, sentinel-for<InputIterator> Sentinel1, nothrow-forward-iterator OutputIter…
205 template<input_range InputRange, nothrow-forward-range OutputRange>
221 template<input_iterator InputIterator, nothrow-forward-iterator OutputIterator, nothrow-sentinel-fo…
228 template <class ForwardIterator, class T>
229 void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x);
233 template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel,…
234 requires constructible_from<iter_value_t<ForwardIterator>, const T&>
235 ForwardIterator uninitialized_fill(ForwardIterator first, Sentinel last, const T& x); // since C++20
237 template <nothrow-forward-range ForwardRange, class T>
238 requires constructible_from<range_value_t<ForwardRange>, const T&>
239 borrowed_iterator_t<ForwardRange> uninitialized_fill(ForwardRange&& range, const T& x); // since C+…
243 template <class ForwardIterator, class Size, class T>
245 uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
249 template <nothrow-forward-iterator ForwardIterator, class T>
250 requires constructible_from<iter_value_t<ForwardIterator>, const T&>
255 template <class T, class ...Args>
256 constexpr T* construct_at(T* location, Args&& ...args); // since C++20
259 template<class T, class... Args>
260 constexpr T* construct_at(T* location, Args&&... args); // since C++20
263 template <class T>
264 void destroy_at(T* location); // constexpr in C++20
267 template<destructible T>
268 constexpr void destroy_at(T* location) noexcept; // since C++20
275 template<nothrow-input-iterator InputIterator, nothrow-sentinel-for<InputIterator> Sentinel>
278 template<nothrow-input-range InputRange>
287 template<nothrow-input-iterator InputIterator>
300 …tor, sentinel_for<InputIterator> Sentinel1, nothrow-forward-iterator OutputIterator, nothrow-senti…
305 template<input_range InputRange, nothrow-forward-range OutputRange>
320 template<input_iterator InputIterator, nothrow-forward-iterator OutputIterator, nothrow-sentinel-fo…
332 template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel>
336 template <nothrow-forward-range ForwardRange>
347 template <nothrow-forward-iterator ForwardIterator>
358 template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel>
362 template <nothrow-forward-range ForwardRange>
373 template <nothrow-forward-iterator ForwardIterator>
396 X* operator->() const throw();
406 template <class T>
412 …constexpr void operator()(T*) const noexcept; // constexpr since…
415 template <class T>
416 struct default_delete<T[]>
420 …constexpr void operator()(T*) const noexcept; // constexpr si…
424 template <class T, class D = default_delete<T>>
429 typedef T element_type;
455 …add_lvalue_reference<T>::type operator*() const noexcept(see below); // constexpr sin…
456 …constexpr pointer operator->() const noexcept; // constexpr sin…
468 template <class T, class D>
469 class unique_ptr<T[], D>
472 typedef implementation-defined pointer;
473 typedef T element_type;
496 constexpr T& operator[](size_t i) const; // constexpr since C++23
510 template <class T, class D>
511 …constexpr void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept; // constex…
532 template <class T, class D>
533 …constexpr bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept; // constexpr since C++…
534 template <class T, class D>
535 bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept; // removed in C++20
536 template <class T, class D>
537 bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept; // removed in C++20
538 template <class T, class D>
539 bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept; // removed in C++20
541 template <class T, class D>
542 constexpr bool operator<(const unique_ptr<T, D>& x, nullptr_t); // constexpr since C++23
543 template <class T, class D>
544 constexpr bool operator<(nullptr_t, const unique_ptr<T, D>& y); // constexpr since C++23
545 template <class T, class D>
546 constexpr bool operator<=(const unique_ptr<T, D>& x, nullptr_t); // constexpr since C++23
547 template <class T, class D>
548 constexpr bool operator<=(nullptr_t, const unique_ptr<T, D>& y); // constexpr since C++23
549 template <class T, class D>
550 constexpr bool operator>(const unique_ptr<T, D>& x, nullptr_t); // constexpr since C++23
551 template <class T, class D>
552 constexpr bool operator>(nullptr_t, const unique_ptr<T, D>& y); // constexpr since C++23
553 template <class T, class D>
554 constexpr bool operator>=(const unique_ptr<T, D>& x, nullptr_t); // constexpr since C++23
555 template <class T, class D>
556 constexpr bool operator>=(nullptr_t, const unique_ptr<T, D>& y); // constexpr since C++23
557 template<class T, class D>
558 requires three_way_comparable<typename unique_ptr<T, D>::pointer>
559 compare_three_way_result_t<typename unique_ptr<T, D>::pointer>
560 …constexpr operator<=>(const unique_ptr<T, D>& x, nullptr_t); // C++20, constexpr since C++23
568 template<class T, class... Args>
569 constexpr unique_ptr<T> make_unique(Args&&... args); // C++14, constexpr…
570 template<class T>
571 constexpr unique_ptr<T> make_unique(size_t n); // C++14, constexpr…
572 template<class T, class... Args> unspecified make_unique(Args&&...) = delete; // C++14, T == U[N]
574 template<class T>
575 …constexpr unique_ptr<T> make_unique_for_overwrite(); // T is not array, C++…
576 template<class T>
577 …constexpr unique_ptr<T> make_unique_for_overwrite(size_t n); // T is U[], C++20, co…
578 template<class T, class... Args>
579 unspecified make_unique_for_overwrite(Args&&...) = delete; // T is U[N], C++20
581 template<class E, class T, class Y, class D>
582 basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, unique_ptr<Y, D> const& p);
584 template<class T>
588 typedef T element_type; // until C++17
589 typedef remove_extent_t<T> element_type; // since C++17
590 typedef weak_ptr<T> weak_type; // C++17
599 template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept;
628 T* get() const noexcept;
629 T& operator*() const noexcept;
630 T* operator->() const noexcept;
638 template<class T>
639 shared_ptr(weak_ptr<T>) -> shared_ptr<T>;
640 template<class T, class D>
641 shared_ptr(unique_ptr<T, D>) -> shared_ptr<T>;
644 template<class T, class U>
645 bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
646 template<class T, class U>
647 …bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; // removed…
648 template<class T, class U>
649 …bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; // removed…
650 template<class T, class U>
651 …bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; // removed…
652 template<class T, class U>
653 …bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; // removed…
654 template<class T, class U>
655 …bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; // removed…
656 template<class T, class U>
657 strong_ordering operator<=>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept; // C++20
659 template <class T>
660 bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
661 template <class T>
662 bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept; // removed in C++20
663 template <class T>
664 bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept; // removed in C++20
665 template <class T>
666 bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept; // removed in C++20
667 template <class T>
668 bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept; // removed in C++20
669 template <class T>
670 bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept; // removed in C++20
671 template <class T>
672 bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept; // removed in C++20
673 template <class T>
674 bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept; // removed in C++20
675 template <class T>
676 bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept; // removed in C++20
677 template <class T>
678 bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept; // removed in C++20
679 template <class T>
680 bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept; // removed in C++20
681 template <class T>
682 bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept; // removed in C++20
683 template<class T>
684 strong_ordering operator<=>(shared_ptr<T> const& x, nullptr_t) noexcept; // C++20
687 template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
690 template<class T, class U>
691 shared_ptr<T> static_pointer_cast(shared_ptr<U> const& r) noexcept;
692 template<class T, class U>
693 shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r) noexcept;
694 template<class T, class U>
695 shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r) noexcept;
698 template<class E, class T, class Y>
699 basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p);
702 template<class D, class T> D* get_deleter(shared_ptr<T> const& p) noexcept;
704 template<class T, class... Args>
705 shared_ptr<T> make_shared(Args&&... args); // T is not an array
706 template<class T, class A, class... Args>
707 shared_ptr<T> allocate_shared(const A& a, Args&&... args); // T is not an array
709 template<class T>
710 shared_ptr<T> make_shared(size_t N); // T is U[] (since C++20)
711 template<class T, class A>
712 shared_ptr<T> allocate_shared(const A& a, size_t N); // T is U[] (since C++20)
714 template<class T>
715 shared_ptr<T> make_shared(); // T is U[N] (since C++20)
716 template<class T, class A>
717 shared_ptr<T> allocate_shared(const A& a); // T is U[N] (since C++20)
719 template<class T>
720 shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u); // T is U[] (since C++20)
721 template<class T, class A>
722 …shared_ptr<T> allocate_shared(const A& a, size_t N, const remove_extent_t<T>& u); // T is U[] (sin…
724 template<class T> shared_ptr<T>
725 make_shared(const remove_extent_t<T>& u); // T is U[N] (since C++20)
726 template<class T, class A>
727 … shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& u); // T is U[N] (since C++20)
729 template<class T>
730 shared_ptr<T> make_shared_for_overwrite(); // T is not U[], C++20
731 template<class T, class A>
732 shared_ptr<T> allocate_shared_for_overwrite(const A& a); // T is not U[], C++20
734 template<class T>
735 shared_ptr<T> make_shared_for_overwrite(size_t N); // T is U[], C++20
736 template<class T, class A>
737 shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N); // T is U[], C++20
739 template<class T>
743 typedef T element_type; // until C++17
744 typedef remove_extent_t<T> element_type; // since C++17
771 shared_ptr<T> lock() const noexcept;
776 template<class T>
777 weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
780 template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
783 template<class T> struct owner_less;
785 template<class T>
786 struct owner_less<shared_ptr<T> >
787 : binary_function<shared_ptr<T>, shared_ptr<T>, bool>
790 bool operator()(shared_ptr<T> const&, shared_ptr<T> const&) const noexcept;
791 bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const noexcept;
792 bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const noexcept;
795 template<class T>
796 struct owner_less<weak_ptr<T> >
797 : binary_function<weak_ptr<T>, weak_ptr<T>, bool>
800 bool operator()(weak_ptr<T> const&, weak_ptr<T> const&) const noexcept;
801 bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const noexcept;
802 bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const noexcept;
820 template<class T>
829 shared_ptr<T> shared_from_this();
830 shared_ptr<T const> shared_from_this() const;
833 template<class T>
834 bool atomic_is_lock_free(const shared_ptr<T>* p);
835 template<class T>
836 shared_ptr<T> atomic_load(const shared_ptr<T>* p);
837 template<class T>
838 shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo);
839 template<class T>
840 void atomic_store(shared_ptr<T>* p, shared_ptr<T> r);
841 template<class T>
842 void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
843 template<class T>
844 shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r);
845 template<class T>
846 shared_ptr<T>
847 atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
848 template<class T>
850 atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
851 template<class T>
853 atomic_compare_exchange_strong( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
854 template<class T>
856 atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
857 shared_ptr<T> w, memory_order success,
859 template<class T>
861 atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
862 shared_ptr<T> w, memory_order success,
865 template <class T> struct hash;
866 template <class T, class D> struct hash<unique_ptr<T, D> >;
867 template <class T> struct hash<shared_ptr<T> >;
869 template <class T, class Alloc>
870 inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
872 // [allocator.uses.construction], uses-allocator construction
873 template<class T, class Alloc, class... Args>
876 template<class T, class Alloc, class Tuple1, class Tuple2>
880 template<class T, class Alloc>
882 template<class T, class Alloc, class U, class V>
885 template<class T, class Alloc, class U, class V>
888 template<class T, class Alloc, class U, class V>
891 template<class T, class Alloc, class U, class V>
894 template<class T, class Alloc, class U, class V>
897 template<class T, class Alloc, pair-like P>
900 template<class T, class Alloc, class U>
903 template<class T, class Alloc, class... Args>
904 constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args); // since C++20
905 template<class T, class Alloc, class... Args>
906 constexpr T* uninitialized_construct_using_allocator(T* p, // since C++20
912 template<size_t N, class T>
913 [[nodiscard]] constexpr T* assume_aligned(T* ptr); // since C++20
915 // [out.ptr.t], class template out_ptr_t
923 // [inout.ptr.t], class template inout_ptr_t
935 // clang-format on
954 // standard-mandated includes