Lines Matching +full:class +full:- +full:d
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;
26 template <class Ptr>
33 template <class U> using rebind = <details>;
38 template <class T>
45 template <class U> using rebind = U*;
50 template <class T> constexpr T* to_address(T* p) noexcept; // C++20
51 template <class Ptr> constexpr auto to_address(const Ptr& p) noexcept; // C++20
53 template <class Alloc>
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>
99 template <class T>
106 template<class Pointer, class SizeType = size_t>
113 class allocator<void> // removed in C++20
120 template <class _Up> struct rebind {typedef allocator<_Up> other;};
123 template <class T>
124 class allocator
138 …template <class U> struct rebind {typedef allocator<U> other;}; // deprecated in C++17, removed in…
145 template <class U>
154 template<class U, class... Args>
156 template <class U>
160 template <class T, class U>
163 template <class T, class U>
166 template <class OutputIterator, class T>
167 class raw_storage_iterator // deprecated in C++17, removed in C++20
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;
191 template <class InputIterator, class ForwardIterator>
197 template<class InputIterator, class OutputIterator>
200 …iterator InputIterator, sentinel-for<InputIterator> Sentinel1, nothrow-forward-iterator OutputIter…
205 template<input_range InputRange, nothrow-forward-range OutputRange>
212 template <class InputIterator, class Size, class ForwardIterator>
218 template<class InputIterator, class OutputIterator>
221 template<input_iterator InputIterator, nothrow-forward-iterator OutputIterator, nothrow-sentinel-fo…
228 template <class ForwardIterator, class T>
233 template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel,…
237 template <nothrow-forward-range ForwardRange, class T>
243 template <class ForwardIterator, class Size, class T>
249 template <nothrow-forward-iterator ForwardIterator, class T>
255 template <class T, class ...Args>
259 template<class T, class... Args>
263 template <class T>
271 template <class ForwardIterator>
275 template<nothrow-input-iterator InputIterator, nothrow-sentinel-for<InputIterator> Sentinel>
278 template<nothrow-input-range InputRange>
283 template <class ForwardIterator, class Size>
287 template<nothrow-input-iterator InputIterator>
292 template <class InputIterator, class ForwardIterator>
297 template<class InputIterator, class OutputIterator>
300 …tor, sentinel_for<InputIterator> Sentinel1, nothrow-forward-iterator OutputIterator, nothrow-senti…
305 template<input_range InputRange, nothrow-forward-range OutputRange>
312 template <class InputIterator, class Size, class ForwardIterator>
317 template<class InputIterator, class OutputIterator>
320 template<input_iterator InputIterator, nothrow-forward-iterator OutputIterator, nothrow-sentinel-fo…
327 template <class ForwardIterator>
332 template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel>
336 template <nothrow-forward-range ForwardRange>
342 template <class ForwardIterator, class Size>
347 template <nothrow-forward-iterator ForwardIterator>
353 template <class ForwardIterator>
358 template <nothrow-forward-iterator ForwardIterator, nothrow-sentinel-for<ForwardIterator> Sentinel>
362 template <nothrow-forward-range ForwardRange>
368 template <class ForwardIterator, class Size>
373 template <nothrow-forward-iterator ForwardIterator>
379 template <class Y> struct auto_ptr_ref {}; // deprecated in C++11, removed in C++17
381 template<class X>
382 class auto_ptr // deprecated in C++11, removed in C++17
389 template<class Y> auto_ptr(auto_ptr<Y>&) throw();
391 template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw();
396 X* operator->() const throw();
402 template<class Y> operator auto_ptr_ref<Y>() throw();
403 template<class Y> operator auto_ptr<Y>() throw();
406 template <class T>
410 …template <class U> constexpr default_delete(const default_delete<U>&) noexcept; // constexpr since…
415 template <class T>
419 …template <class U> constexpr default_delete(const default_delete <U[]>&) noexcept; // constexpr si…
421 template <class U> void operator()(U*) const = delete;
424 template <class T, class D = default_delete<T>>
425 class unique_ptr
430 typedef D deleter_type;
439 template <class U, class E>
441 template <class U>
449 template <class U, class E>
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;
474 typedef D deleter_type;
479 constexpr unique_ptr(pointer p, see below d) noexcept; // constexpr since C++23
480 constexpr unique_ptr(pointer p, see below d) noexcept; // constexpr since C++23
482 template <class U, class E>
491 template <class U, class E>
506 template <class U> void reset(U) = delete;
510 template <class T, class D>
511 …constexpr void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept; // constex…
513 template <class T1, class D1, class T2, class D2>
515 template <class T1, class D1, class T2, class D2>
517 template <class T1, class D1, class T2, class D2>
519 template <class T1, class D1, class T2, class D2>
521 template <class T1, class D1, class T2, class D2>
523 template <class T1, class D1, class T2, class D2>
525 template<class T1, class D1, class T2, class D2>
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
562 class bad_weak_ptr
568 template<class T, class... Args>
570 template<class T>
572 template<class T, class... Args> unspecified make_unique(Args&&...) = delete; // C++14, T == U[N]
574 template<class T>
576 template<class T>
578 template<class T, class... Args>
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>
585 class shared_ptr
594 template<class Y> explicit shared_ptr(Y* p);
595 template<class Y, class D> shared_ptr(Y* p, D d);
596 template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
597 template <class D> shared_ptr(nullptr_t p, D d);
598 template <class D, class A> shared_ptr(nullptr_t p, D d, A a);
599 template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept;
601 template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
603 template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
604 template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
605 template<class Y> shared_ptr(auto_ptr<Y>&& r); // removed in C++17
606 template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
614 template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
616 template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r);
617 template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r); // removed in C++17
618 template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
623 template<class Y> void reset(Y* p);
624 template<class Y, class D> void reset(Y* p, D d);
625 template<class Y, class D, class A> void reset(Y* p, D d, A a);
630 T* operator->() const noexcept;
634 template<class U> bool owner_before(shared_ptr<U> const& b) const noexcept;
635 template<class U> bool owner_before(weak_ptr<U> const& b) 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>
646 template<class T, class U>
648 template<class T, class U>
650 template<class T, class U>
652 template<class T, class U>
654 template<class T, class U>
656 template<class T, class U>
659 template <class T>
661 template <class T>
663 template <class T>
665 template <class T>
667 template <class T>
669 template <class T>
671 template <class T>
673 template <class T>
675 template <class T>
677 template <class T>
679 template <class T>
681 template <class T>
683 template<class T>
687 template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
690 template<class T, class U>
692 template<class T, class U>
694 template<class T, class U>
698 template<class E, class T, class Y>
702 template<class D, class T> D* get_deleter(shared_ptr<T> const& p) noexcept;
704 template<class T, class... Args>
706 template<class T, class A, class... Args>
709 template<class T>
711 template<class T, class A>
714 template<class T>
716 template<class T, class A>
719 template<class T>
721 template<class T, class A>
724 template<class T> shared_ptr<T>
726 template<class T, class A>
729 template<class T>
731 template<class T, class A>
734 template<class T>
736 template<class T, class A>
739 template<class T>
740 class weak_ptr
748 template<class Y> weak_ptr(shared_ptr<Y> const& r) noexcept;
750 template<class Y> weak_ptr(weak_ptr<Y> const& r) noexcept;
752 template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept; // C++14
759 template<class Y> weak_ptr& operator=(weak_ptr<Y> const& r) noexcept;
760 template<class Y> weak_ptr& operator=(shared_ptr<Y> const& r) noexcept;
762 template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept; // C++14
772 template<class U> bool owner_before(shared_ptr<U> const& b) const noexcept;
773 template<class U> bool owner_before(weak_ptr<U> const& b) 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;
782 // class owner_less:
783 template<class T> struct owner_less;
785 template<class T>
795 template<class T>
808 template <class _Tp, class _Up>
810 template <class _Tp, class _Up>
812 template <class _Tp, class _Up>
814 template <class _Tp, class _Up>
820 template<class T>
821 class enable_shared_from_this
833 template<class T>
835 template<class T>
837 template<class T>
839 template<class T>
841 template<class T>
843 template<class T>
845 template<class T>
848 template<class T>
851 template<class T>
854 template<class T>
859 template<class T>
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>
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>
905 template<class T, class Alloc, class... Args>
912 template<size_t N, class T>
915 // [out.ptr.t], class template out_ptr_t
916 template<class Smart, class Pointer, class... Args>
917 class out_ptr_t; // since c++23
920 template<class Pointer = void, class Smart, class... Args>
923 // [inout.ptr.t], class template inout_ptr_t
924 template<class Smart, class Pointer, class... Args>
925 class inout_ptr_t; // since c++23
928 template<class Pointer = void, class Smart, class... Args>
935 // clang-format on
954 // standard-mandated includes