Lines Matching +full:alloc +full:- +full:ranges
1 // -*- C++ -*-
2 //===----------------------------------------------------------------------===//
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
8 //===----------------------------------------------------------------------===//
46 template<container-compatible-range<T> R> queue(from_range_t, R&& rg); // since C++23
47 template <class Alloc>
48 explicit queue(const Alloc& a);
49 template <class Alloc>
50 queue(const container_type& c, const Alloc& a);
51 template <class Alloc>
52 queue(container_type&& c, const Alloc& a);
53 template <class Alloc>
54 queue(const queue& q, const Alloc& a);
55 template <class Alloc>
56 queue(queue&& q, const Alloc& a);
57 template <class InputIterator, class Alloc>
58 queue(InputIterator first, InputIterator last, const Alloc&); // since C++23
59 template<container-compatible-range<T> R, class Alloc>
60 queue(from_range_t, R&& rg, const Alloc&); // since C++23
72 template<container-compatible-range<T> R>
81 queue(Container) -> queue<typename Container::value_type, Container>; // C++17
84 queue(InputIterator, InputIterator) -> queue<iter-value-type<InputIterator>>; // since C++23
86 template<ranges::input_range R>
87 queue(from_range_t, R&&) -> queue<ranges::range_value_t<R>>; // since C++23
90 queue(Container, Allocator) -> queue<typename Container::value_type, Container>; // C++17
94 -> queue<iter-value-type<InputIterator>,
95 deque<iter-value-type<InputIterator>, Allocator>>; // since C++23
97 template<ranges::input_range R, class Allocator>
99 -> queue<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>; // since C++23
157 template <container-compatible-range<T> R>
159 template <class Alloc>
160 explicit priority_queue(const Alloc& a);
161 template <class Alloc>
162 priority_queue(const Compare& comp, const Alloc& a);
163 template <class Alloc>
165 const Alloc& a);
166 template <class Alloc>
168 const Alloc& a);
171 const Alloc& a);
174 const Compare& comp, const Alloc& a);
177 const Compare& comp, const Container& c, const Alloc& a);
180 const Compare& comp, Container&& c, const Alloc& a);
181 template <container-compatible-range<T> R, class Alloc>
182 priority_queue(from_range_t, R&& rg, const Compare&, const Alloc&); // since C++23
183 template <container-compatible-range<T> R, class Alloc>
184 priority_queue(from_range_t, R&& rg, const Alloc&); // since C++23
185 template <class Alloc>
186 priority_queue(const priority_queue& q, const Alloc& a);
187 template <class Alloc>
188 priority_queue(priority_queue&& q, const Alloc& a);
196 template<container-compatible-range<T> R>
208 -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
211 class Compare = less<iter-value-type<InputIterator>>,
212 class Container = vector<iter-value-type<InputIterator>>>
214 -> priority_queue<iter-value-type<InputIterator>, Container, Compare>; // C++17
216 template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>>
218 -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>>, Compare>; // C++23
222 -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
226 -> priority_queue<iter-value-type<InputIterator>,
227 vector<iter-value-type<InputIterator>, Allocator>,
228 less<iter-value-type<InputIterator>>>; // C++17
232 -> priority_queue<iter-value-type<InputIterator>,
233 vector<iter-value-type<InputIterator>, Allocator>, Compare>; // C++17
237 -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
239 template<ranges::input_range R, class Compare, class Allocator>
241 -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>,
244 template<ranges::input_range R, class Allocator>
246 … -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>>; // C++23
277 // standard-mandated includes
393 ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
432 queue(_Container) -> queue<typename _Container::value_type, _Container>;
438 queue(_Container, _Alloc) -> queue<typename _Container::value_type, _Container>;
443 queue(_InputIterator, _InputIterator) -> queue<__iter_value_type<_InputIterator>>;
445 template <ranges::input_range _Range>
446 queue(from_range_t, _Range&&) -> queue<ranges::range_value_t<_Range>>;
454 …_Alloc) -> queue<__iter_value_type<_InputIterator>, deque<__iter_value_type<_InputIterator>, _Allo…
456 template <ranges::input_range _Range, class _Alloc, __enable_if_t<__is_allocator<_Alloc>::value, in…
459 _Alloc) -> queue<ranges::range_value_t<_Range>, deque<ranges::range_value_t<_Range>, _Alloc>>;
666 ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
689 priority_queue(_Compare, _Container) -> priority_queue<typename _Container::value_type, _Container,…
698 -> priority_queue<__iter_value_type<_InputIterator>, _Container, _Compare>;
706 priority_queue(_Compare, _Container, _Alloc) -> priority_queue<typename _Container::value_type, _Co…
713 -> priority_queue<__iter_value_type<_InputIterator>,
724 -> priority_queue<__iter_value_type<_InputIterator>,
737 -> priority_queue<typename _Container::value_type, _Container, _Compare>;
742 template <ranges::input_range _Range,
743 class _Compare = less<ranges::range_value_t<_Range>>,
746 … -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>>, _Compare>;
748 template <ranges::input_range _Range,
754 …-> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>, _Alloc>, _C…
756 template <ranges::input_range _Range, class _Alloc, class = enable_if_t<__is_allocator<_Alloc>::val…
758 -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>, _Alloc>>;