NexusForce 1.0.0
A Modern C++ Library with extended functionality, web components, and utility libraries
载入中...
搜索中...
未找到
pair.hpp
浏览该文件的文档.
1#ifndef NEFORCE_CORE_UTILITY_PAIR_HPP__
2#define NEFORCE_CORE_UTILITY_PAIR_HPP__
3
10
11#include "NeForce/core/interface/icommon.hpp"
12#include "NeForce/core/utility/integer_sequence.hpp"
13#include "NeForce/core/utility/reference_wrapper.hpp"
14NEFORCE_BEGIN_NAMESPACE__
15
21
22template <typename...>
23struct tuple;
24
25template <typename>
26struct tuple_size;
27
28#ifdef NEFORCE_STANDARD_14
36template <typename T>
37constexpr size_t tuple_size_v = tuple_size<remove_cvref_t<T>>::value;
38#endif
39
40
41template <size_t Index, typename... Tuple>
42struct tuple_element;
43
51template <size_t Index, typename... Types>
52using tuple_element_t = typename tuple_element<Index, Types...>::type;
53
59template <size_t Index, typename... Types>
60using tuple_extract_base_t = typename tuple_element<Index, Types...>::tuple_type;
61
62template <size_t Index, typename... Types>
63NEFORCE_NODISCARD constexpr tuple_element_t<Index, Types...>& get(tuple<Types...>& t) noexcept;
64template <size_t Index, typename... Types>
65NEFORCE_NODISCARD constexpr const tuple_element_t<Index, Types...>& get(const tuple<Types...>& t) noexcept;
66template <size_t Index, typename... Types>
67NEFORCE_NODISCARD constexpr tuple_element_t<Index, Types...>&& get(tuple<Types...>&& t) noexcept;
68template <size_t Index, typename... Types>
69NEFORCE_NODISCARD constexpr const tuple_element_t<Index, Types...>&& get(const tuple<Types...>&& t) noexcept;
70
72NEFORCE_BEGIN_INNER__
73template <size_t Index, typename... Types>
74NEFORCE_NODISCARD constexpr tuple_element_t<Index, Types...>&& __pair_get_from_tuple(tuple<Types...>&& t) noexcept;
75NEFORCE_END_INNER__
77 // Tuple
79
85
95template <typename T1, typename T2>
96struct pair : icommon<pair<T1, T2>> {
97 using first_type = T1;
98 using second_type = T2;
99
100 T1 first;
101 T2 second;
102
103#ifdef NEFORCE_STANDARD_20
111 template <typename U1 = T1, typename U2 = T2,
112 enable_if_t<conjunction_v<is_default_constructible<U1>, is_default_constructible<U2>>, int> = 0>
117
127 template <typename U1 = T1, typename U2 = T2,
128 enable_if_t<conjunction_v<is_copy_constructible<U1>, is_copy_constructible<U2>>, int> = 0>
129 constexpr explicit(!conjunction_v<is_convertible<const U1&, U1>, is_convertible<const U2&, U2>>)
130 pair(const T1& a, const T2& b) noexcept(
131 conjunction_v<is_nothrow_copy_constructible<U1>, is_nothrow_copy_constructible<U2>>) :
132 first(a),
133 second(b) {}
134
144 template <typename U1, typename U2,
145 enable_if_t<conjunction_v<is_constructible<T1, U1>, is_constructible<T2, U2>>, int> = 0>
146 constexpr explicit(!conjunction_v<is_convertible<U1, T1>, is_convertible<U2, T2>>)
147 pair(U1&& a,
148 U2&& b) noexcept(conjunction_v<is_nothrow_constructible<T1, U1>, is_nothrow_constructible<T2, U2>>) :
149 first(_NEFORCE forward<U1>(a)),
150 second(_NEFORCE forward<U2>(b)) {}
151
160 template <typename U1, typename U2,
161 enable_if_t<conjunction_v<is_constructible<T1, const U1&>, is_constructible<T2, const U2&>>, int> = 0>
162 constexpr explicit(!conjunction_v<is_convertible<const U1&, T1>, is_convertible<const U2&, T2>>)
163 pair(const pair<U1, U2>& p) noexcept(
164 conjunction_v<is_nothrow_constructible<T1, const U1&>, is_nothrow_constructible<T2, const U2&>>) :
165 first(p.first),
166 second(p.second) {}
167
176 template <typename U1, typename U2,
177 enable_if_t<conjunction_v<is_constructible<T1, U1>, is_constructible<T2, U2>>, int> = 0>
178 constexpr explicit(!conjunction_v<is_convertible<U1, T1>, is_convertible<U2, T2>>) pair(pair<U1, U2>&& p) noexcept(
179 conjunction_v<is_nothrow_constructible<T1, U1>, is_nothrow_constructible<T2, U2>>) :
180 first(_NEFORCE forward<U1>(p.first)),
181 second(_NEFORCE forward<U2>(p.second)) {}
182#else
186 template <typename U1 = T1, typename U2 = T2,
187 enable_if_t<conjunction<is_default_constructible<U1>, is_default_constructible<U2>>::value &&
188 !conjunction<is_implicitly_default_constructible<U1>,
189 is_implicitly_default_constructible<U2>>::value,
190 int> = 0>
191 explicit pair() noexcept(
192 conjunction<is_nothrow_default_constructible<U1>, is_nothrow_default_constructible<U2>>::value) :
193 first(),
194 second() {}
198 template <typename U1 = T1, typename U2 = T2,
199 enable_if_t<conjunction<is_default_constructible<U1>, is_default_constructible<U2>>::value &&
200 conjunction<is_implicitly_default_constructible<U1>,
201 is_implicitly_default_constructible<U2>>::value,
202 int> = 0>
203 pair() noexcept(conjunction<is_nothrow_default_constructible<U1>, is_nothrow_default_constructible<U2>>::value) :
204 first(),
205 second() {}
206
210 template <typename U1 = T1, typename U2 = T2,
211 enable_if_t<conjunction<is_copy_constructible<U1>, is_copy_constructible<U2>>::value &&
212 !conjunction<is_convertible<const U1&, U1>, is_convertible<const U2&, U2>>::value,
213 int> = 0>
214 explicit pair(const T1& a, const T2& b) noexcept(
215 conjunction<is_nothrow_copy_constructible<U1>, is_nothrow_copy_constructible<U2>>::value) :
216 first(a),
217 second(b) {}
218
222 template <typename U1 = T1, typename U2 = T2,
223 enable_if_t<conjunction<is_copy_constructible<U1>, is_copy_constructible<U2>>::value &&
224 conjunction<is_convertible<const U1&, U1>, is_convertible<const U2&, U2>>::value,
225 int> = 0>
226 pair(const T1& a, const T2& b) noexcept(
227 conjunction<is_nothrow_copy_constructible<U1>, is_nothrow_copy_constructible<U2>>::value) :
228 first(a),
229 second(b) {}
230
234 template <typename U1, typename U2,
235 enable_if_t<conjunction<is_constructible<T1, U1>, is_constructible<T2, U2>>::value &&
236 !conjunction<is_convertible<U1, T1>, is_convertible<U2, T2>>::value,
237 int> = 0>
238 explicit pair(U1&& a, U2&& b) noexcept(
239 conjunction<is_nothrow_constructible<T1, U1>, is_nothrow_constructible<T2, U2>>::value) :
240 first(_NEFORCE forward<U1>(a)),
241 second(_NEFORCE forward<U2>(b)) {}
242
246 template <typename U1, typename U2,
247 enable_if_t<conjunction<is_constructible<T1, U1>, is_constructible<T2, U2>>::value &&
248 conjunction<is_convertible<U1, T1>, is_convertible<U2, T2>>::value,
249 int> = 0>
250 pair(U1&& a,
251 U2&& b) noexcept(conjunction<is_nothrow_constructible<T1, U1>, is_nothrow_constructible<T2, U2>>::value) :
252 first(_NEFORCE forward<U1>(a)),
253 second(_NEFORCE forward<U2>(b)) {}
254
258 template <typename U1, typename U2,
259 enable_if_t<conjunction<is_constructible<T1, const U1&>, is_constructible<T2, const U2&>>::value &&
260 !conjunction<is_convertible<const U1&, T1>, is_convertible<const U2&, T2>>::value,
261 int> = 0>
262 explicit pair(const pair<U1, U2>& p) noexcept(
263 conjunction<is_nothrow_constructible<T1, const U1&>, is_nothrow_constructible<T2, const U2&>>::value) :
264 first(p.first),
265 second(p.second) {}
266
270 template <typename U1, typename U2,
271 enable_if_t<conjunction<is_constructible<T1, const U1&>, is_constructible<T2, const U2&>>::value &&
272 conjunction<is_convertible<const U1&, T1>, is_convertible<const U2&, T2>>::value,
273 int> = 0>
274 pair(const pair<U1, U2>& p) noexcept(
275 conjunction<is_nothrow_constructible<T1, const U1&>, is_nothrow_constructible<T2, const U2&>>::value) :
276 first(p.first),
277 second(p.second) {}
278
282 template <typename U1, typename U2,
283 enable_if_t<conjunction<is_constructible<T1, U1>, is_constructible<T2, U2>>::value &&
284 !conjunction<is_convertible<U1, T1>, is_convertible<U2, T2>>::value,
285 int> = 0>
286 explicit pair(pair<U1, U2>&& p) noexcept(
287 conjunction<is_nothrow_constructible<T1, U1>, is_nothrow_constructible<T2, U2>>::value) :
288 first(_NEFORCE forward<U1>(p.first)),
289 second(_NEFORCE forward<U2>(p.second)) {}
290
294 template <typename U1, typename U2,
295 enable_if_t<conjunction<is_constructible<T1, U1>, is_constructible<T2, U2>>::value &&
296 conjunction<is_convertible<U1, T1>, is_convertible<U2, T2>>::value,
297 int> = 0>
298 pair(pair<U1, U2>&& p) noexcept(
299 conjunction<is_nothrow_constructible<T1, U1>, is_nothrow_constructible<T2, U2>>::value) :
300 first(_NEFORCE forward<U1>(p.first)),
301 second(_NEFORCE forward<U2>(p.second)) {}
302#endif
303
304 pair(const pair& p) = default;
305 pair(pair&& p) = default;
306
320 template <typename Tuple1, typename Tuple2, size_t... Index1, size_t... Index2>
321 constexpr pair(Tuple1& t1, Tuple2& t2, index_sequence<Index1...> idx1, index_sequence<Index2...> idx2) :
322 first(inner::__pair_get_from_tuple<Index1>(_NEFORCE move(t1))...),
323 second(inner::__pair_get_from_tuple<Index2>(_NEFORCE move(t2))...) {}
324
334 template <typename... Types1, typename... Types2>
335 constexpr pair(unpack_utility_construct_tag /*unused*/, tuple<Types1...> t1, tuple<Types2...> t2) :
336 pair(t1, t2, index_sequence_for<Types1...>{}, index_sequence_for<Types2...>{}) {}
337
344 template <typename T = pair, enable_if_t<conjunction<is_copy_assignable<typename T::first_type>,
345 is_copy_assignable<typename T::second_type>>::value,
346 int> = 0>
347 NEFORCE_CONSTEXPR14 pair& operator=(type_identity_t<const T&> p) noexcept(
348 conjunction<is_nothrow_copy_assignable<T1>, is_nothrow_copy_assignable<T2>>::value) {
349 first = p.first;
350 second = p.second;
351 return *this;
352 }
353
360 template <typename T = pair, enable_if_t<conjunction<is_move_assignable<typename T::first_type>,
361 is_move_assignable<typename T::second_type>>::value,
362 int> = 0>
363 NEFORCE_CONSTEXPR14 pair& operator=(type_identity_t<T&&> p) noexcept(
364 conjunction<is_nothrow_move_assignable<T1>, is_nothrow_move_assignable<T2>>::value) {
365 first = _NEFORCE forward<T1>(p.first);
366 second = _NEFORCE forward<T2>(p.second);
367 return *this;
368 }
369
377 template <typename U1, typename U2,
378 enable_if_t<conjunction<negation<is_same<pair, pair<U1, U2>>>, is_assignable<T1&, const U1&>,
379 is_assignable<T2&, const U2&>>::value,
380 int> = 0>
381 NEFORCE_CONSTEXPR14 pair& operator=(const pair<U1, U2>& p) noexcept(
382 conjunction<is_nothrow_assignable<T1&, const U1&>, is_nothrow_assignable<T2&, const U2&>>::value) {
383 first = p.first;
384 second = p.second;
385 return *this;
386 }
387
395 template <typename U1, typename U2,
396 enable_if_t<conjunction<negation<is_same<pair, pair<U1, U2>>>, is_assignable<T1&, U1>,
397 is_assignable<T2&, U2>>::value,
398 int> = 0>
399 NEFORCE_CONSTEXPR14 pair& operator=(pair<U1, U2>&& p) noexcept(
400 conjunction<is_nothrow_assignable<T1&, U1>, is_nothrow_assignable<T2&, U2>>::value) {
401 first = _NEFORCE forward<U1>(p.first);
402 second = _NEFORCE forward<U2>(p.second);
403 return *this;
404 }
405
406 pair& operator=(const volatile pair&) = delete;
407
408 NEFORCE_CONSTEXPR20 ~pair() = default;
409
417 constexpr bool equal_to(const pair& y) const
418 noexcept(noexcept(this->first == y.first && this->second == y.second)) {
419 return this->first == y.first && this->second == y.second;
420 }
421
429 constexpr bool less_than(const pair& y) const
430 noexcept(noexcept(this->first < y.first || (!(y.first < this->first) && this->second < y.second))) {
431 return this->first < y.first || (!(y.first < this->first) && this->second < y.second);
432 }
433
440 NEFORCE_NODISCARD constexpr size_t to_hash() const
441 noexcept(noexcept(hash<remove_cvref_t<T1>>()(first) ^ hash<remove_cvref_t<T2>>()(second))) {
442 return hash<remove_cvref_t<T1>>()(first) ^ hash<remove_cvref_t<T2>>()(second);
443 }
444
449 NEFORCE_CONSTEXPR14 void
450 swap(pair& p) noexcept(conjunction<is_nothrow_swappable<T1>, is_nothrow_swappable<T2>>::value) {
451 _NEFORCE swap(first, p.first);
452 _NEFORCE swap(second, p.second);
453 }
454};
455
456#ifdef NEFORCE_STANDARD_17
457template <typename T1, typename T2>
458pair(T1, T2) -> pair<T1, T2>;
459#endif
460
461
472template <typename T1, typename T2>
473constexpr pair<unwrap_ref_decay_t<T1>, unwrap_ref_decay_t<T2>>
474make_pair(T1&& x, T2&& y) noexcept(conjunction<is_nothrow_constructible<unwrap_ref_decay_t<T1>, T1>,
475 is_nothrow_constructible<unwrap_ref_decay_t<T2>, T2>>::value) {
476 using unwrap_pair = pair<unwrap_ref_decay_t<T1>, unwrap_ref_decay_t<T2>>;
477 return unwrap_pair(_NEFORCE forward<T1>(x), _NEFORCE forward<T2>(y));
478}
479 // Pair
481
487
493template <typename... Types>
494struct tuple_size<tuple<Types...>> : integral_constant<size_t, sizeof...(Types)> {};
495
496#define __NEFORCE_BUILD_TUPLE_TUPLE_SIZE(CV) \
497 template <typename... Types> \
498 struct tuple_size<tuple<Types...> CV> : integral_constant<size_t, sizeof...(Types)> {};
499NEFORCE_MACRO_RANGES_CV(__NEFORCE_BUILD_TUPLE_TUPLE_SIZE)
500#undef __NEFORCE_BUILD_TUPLE_TUPLE_SIZE
501
502
508template <size_t Index>
509struct tuple_element<Index, tuple<>> {};
510
516template <typename This, typename... Rest>
517struct tuple_element<0, tuple<This, Rest...>> {
518 using type = This;
519 using tuple_type = tuple<This, Rest...>;
520};
521
528template <size_t Index, typename This, typename... Rest>
529struct tuple_element<Index, tuple<This, Rest...>> : tuple_element<Index - 1, tuple<Rest...>> {};
530
537template <size_t Index, typename... Types>
538struct tuple_element : tuple_element<Index, tuple<Types...>> {};
539
540
546template <typename T1, typename T2>
547struct tuple_size<pair<T1, T2>> : integral_constant<size_t, 2> {};
548
549#define __NEFORCE_BUILD_PAIR_TUPLE_SIZE(CV) \
550 template <typename T1, typename T2> \
551 struct tuple_size<pair<T1, T2> CV> : integral_constant<size_t, 2> {};
552NEFORCE_MACRO_RANGES_CV(__NEFORCE_BUILD_PAIR_TUPLE_SIZE)
553#undef __NEFORCE_BUILD_PAIR_TUPLE_SIZE
554
561template <size_t Index, typename T1, typename T2>
562struct tuple_element<Index, pair<T1, T2>> {
563 static_assert(Index < 2, "pair element index out of range.");
564
565 using type = conditional_t<Index == 0, T1, T2>;
566 using tuple_type = tuple<T1, T2>;
567};
568 // Tuple
570
576
577#ifndef NEFORCE_STANDARD_17
579NEFORCE_BEGIN_INNER__
580
581template <size_t Index, typename T1, typename T2>
582struct __pair_get_helper;
583template <typename T1, typename T2>
584struct __pair_get_helper<0, T1, T2> {
585 NEFORCE_NODISCARD constexpr static tuple_element_t<0, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept {
586 return pir.first;
587 }
588 NEFORCE_NODISCARD constexpr static const tuple_element_t<0, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept {
589 return pir.first;
590 }
591 NEFORCE_NODISCARD constexpr static tuple_element_t<0, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept {
592 return _NEFORCE forward<T1>(pir.first);
593 }
594 NEFORCE_NODISCARD constexpr static const tuple_element_t<0, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept {
595 return _NEFORCE forward<const T1>(pir.first);
596 }
597};
598
599template <typename T1, typename T2>
600struct __pair_get_helper<1, T1, T2> {
601 NEFORCE_NODISCARD constexpr static tuple_element_t<1, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept {
602 return pir.second;
603 }
604 NEFORCE_NODISCARD constexpr static const tuple_element_t<1, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept {
605 return pir.second;
606 }
607 NEFORCE_NODISCARD constexpr static tuple_element_t<1, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept {
608 return _NEFORCE forward<T2>(pir.second);
609 }
610 NEFORCE_NODISCARD constexpr static const tuple_element_t<1, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept {
611 return _NEFORCE forward<const T2>(pir.second);
612 }
613};
614
615NEFORCE_END_INNER__
617#endif // !NEFORCE_STANDARD_17
618
622template <size_t Index, typename T1, typename T2>
623NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept;
624
625#ifdef NEFORCE_STANDARD_17
626template <size_t Index, typename T1, typename T2>
627NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept {
628 if constexpr (Index == 0) {
629 return pir.first;
630 } else {
631 return pir.second;
632 }
633}
634#else
635template <size_t Index, typename T1, typename T2>
636NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept {
637 return inner::__pair_get_helper<Index, T1, T2>::get(pir);
638}
639#endif // NEFORCE_STANDARD_17
640
644template <typename T1, typename T2>
645NEFORCE_NODISCARD constexpr T1& get(pair<T1, T2>& pir) noexcept {
646 return pir.first;
647}
648
652template <typename T2, typename T1>
653NEFORCE_NODISCARD constexpr T2& get(pair<T1, T2>& pir) noexcept {
654 return pir.second;
655}
656
657
661template <size_t Index, typename T1, typename T2>
662NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept;
663
664#ifdef NEFORCE_STANDARD_17
665template <size_t Index, typename T1, typename T2>
666NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept {
667 if constexpr (Index == 0) {
668 return pir.first;
669 } else {
670 return pir.second;
671 }
672}
673#else
674template <size_t Index, typename T1, typename T2>
675NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept {
676 return inner::__pair_get_helper<Index, T1, T2>::get(pir);
677}
678#endif // NEFORCE_STANDARD_17
679
683template <typename T1, typename T2>
684NEFORCE_NODISCARD constexpr const T1& get(const pair<T1, T2>& pir) noexcept {
685 return pir.first;
686}
687
691template <typename T2, typename T1>
692NEFORCE_NODISCARD constexpr const T2& get(const pair<T1, T2>& pir) noexcept {
693 return pir.second;
694}
695
696
700template <size_t Index, typename T1, typename T2>
701NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept;
702
703#ifdef NEFORCE_STANDARD_17
704template <size_t Index, typename T1, typename T2>
705NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept {
706 if constexpr (Index == 0) {
707 return _NEFORCE forward<T1>(pir.first);
708 } else {
709 return _NEFORCE forward<T2>(pir.second);
710 }
711}
712#else
713template <size_t Index, typename T1, typename T2>
714NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept {
715 return _NEFORCE forward<tuple_element_t<Index, pair<T1, T2>>>(
716 inner::__pair_get_helper<Index, T1, T2>::get(_NEFORCE forward<pair<T1, T2>>(pir)));
717}
718#endif // NEFORCE_STANDARD_17
719
723template <typename T1, typename T2>
724NEFORCE_NODISCARD constexpr T1&& get(pair<T1, T2>&& pir) noexcept {
725 return _NEFORCE forward<T1>(pir.first);
726}
727
731template <typename T2, typename T1>
732NEFORCE_NODISCARD constexpr T2&& get(pair<T1, T2>&& pir) noexcept {
733 return _NEFORCE forward<T2>(pir.second);
734}
735
736
740template <size_t Index, typename T1, typename T2>
741NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept;
742
743#ifdef NEFORCE_STANDARD_17
744template <size_t Index, typename T1, typename T2>
745NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept {
746 if constexpr (Index == 0) {
747 return _NEFORCE forward<const T1>(pir.first);
748 } else {
749 return _NEFORCE forward<const T2>(pir.second);
750 }
751}
752#else
753template <size_t Index, typename T1, typename T2>
754NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept {
755 return _NEFORCE forward<const tuple_element_t<Index, pair<T1, T2>>>(
756 inner::__pair_get_helper<Index, T1, T2>::get(_NEFORCE forward<const pair<T1, T2>>(pir)));
757}
758#endif // NEFORCE_STANDARD_17
759
763template <typename T1, typename T2>
764NEFORCE_NODISCARD constexpr const T1&& get(const pair<T1, T2>&& pir) noexcept {
765 return _NEFORCE forward<const T1>(pir.first);
766}
767
771template <typename T2, typename T1>
772NEFORCE_NODISCARD constexpr const T2&& get(const pair<T1, T2>&& pir) noexcept {
773 return _NEFORCE forward<const T2>(pir.second);
774}
775 // Pair
777
778NEFORCE_END_NAMESPACE__
779
780#ifdef NEFORCE_STANDARD_17
781# include <utility>
782namespace std {
783 template <typename T1, typename T2>
784 struct tuple_size<_NEFORCE pair<T1, T2>> : _NEFORCE integral_constant<_NEFORCE size_t, 2> {};
785
786 template <_NEFORCE size_t I, typename T1, typename T2>
787 struct tuple_element<I, _NEFORCE pair<T1, T2>> {
788 using type = _NEFORCE tuple_element_t<I, _NEFORCE pair<T1, T2>>;
789 };
790} // namespace std
791#endif
792
793#endif // NEFORCE_CORE_UTILITY_PAIR_HPP__
forward
constexpr T && forward(remove_reference_t< T > &x) noexcept
完美转发左值
定义 type_traits.hpp:3028
get
enable_if_t< is_void_v< T >, future_result_t< T > > get(future< T > &f)
通用future结果获取函数
定义 future.hpp:1189
index_sequence
integer_sequence< size_t, Values... > index_sequence
索引序列
定义 integer_sequence.hpp:68
index_sequence_for
make_index_sequence< sizeof...(Types)> index_sequence_for
根据类型参数包生成索引序列
定义 integer_sequence.hpp:88
make_pair
constexpr pair< unwrap_ref_decay_t< T1 >, unwrap_ref_decay_t< T2 > > make_pair(T1 &&x, T2 &&y) noexcept(conjunction< is_nothrow_constructible< unwrap_ref_decay_t< T1 >, T1 >, is_nothrow_constructible< unwrap_ref_decay_t< T2 >, T2 > >::value)
创建pair的辅助函数
定义 pair.hpp:474
unwrap_ref_decay_t
typename unwrap_ref_decay< T >::type unwrap_ref_decay_t
unwrap_ref_decay的便捷别名
定义 reference_wrapper.hpp:233
remove_cvref_t
typename remove_cvref< T >::type remove_cvref_t
remove_cvref的便捷别名
定义 type_traits.hpp:522
move
constexpr Iterator2 move(Iterator1 first, Iterator1 last, Iterator2 result) noexcept(noexcept(inner::__move_aux(first, last, result)))
移动范围元素
定义 shift.hpp:312
swap
void swap()=delete
删除无参数的swap重载
tuple_extract_base_t
typename tuple_element< Index, Types... >::tuple_type tuple_extract_base_t
获取tuple元素基类型的类型别名
定义 pair.hpp:60
tuple_size_v
constexpr size_t tuple_size_v
tuple_size的类型别名
定义 pair.hpp:37
tuple_element_t
typename tuple_element< Index, Types... >::type tuple_element_t
tuple_element的类型别名
定义 pair.hpp:52
get
constexpr tuple_element_t< Index, Types... > & get(tuple< Types... > &t) noexcept
获取元组中指定位置的元素引用
定义 tuple.hpp:670
NEFORCE_MACRO_RANGES_CV
#define NEFORCE_MACRO_RANGES_CV(MAC)
cv限定符列表宏
定义 c++config.hpp:639
conjunction_v
constexpr bool conjunction_v
conjunction的便捷变量模板
定义 type_traits.hpp:321
conditional_t
typename conditional< Test, T1, T2 >::type conditional_t
conditional的便捷别名
定义 type_traits.hpp:145
type_identity_t
typename type_identity< T >::type type_identity_t
type_identity的便捷别名
定义 type_traits.hpp:209
enable_if_t
typename enable_if< Test, T >::type enable_if_t
enable_if的便捷别名
定义 type_traits.hpp:118
icommon.hpp
基本接口基类
integer_sequence.hpp
整数序列工具
reference_wrapper.hpp
引用包装器
conjunction
类型集合的逻辑与操作
定义 type_traits.hpp:308
hash
哈希函数的主模板
定义 hash.hpp:84
icommon
通用接口，同时具备可比较和可哈希功能
定义 icommon.hpp:193
integral_constant
整数常量包装器
定义 type_traits.hpp:36
is_assignable
判断类型是否可以使用指定类型的值进行赋值
定义 type_traits.hpp:2473
is_constructible
判断类型是否可以使用指定参数构造
定义 type_traits.hpp:2366
is_convertible
判断类型From是否可以隐式转换为类型To
定义 type_traits.hpp:3144
is_copy_constructible
判断类型是否可复制构造
定义 type_traits.hpp:2384
is_default_constructible
判断类型是否可默认构造
定义 type_traits.hpp:2402
is_implicitly_default_constructible
判断类型是否可隐式默认构造
定义 type_traits.hpp:2430
is_nothrow_assignable
判断类型是否可以使用指定类型的值进行无异常赋值
定义 type_traits.hpp:2873
is_nothrow_constructible
判断类型是否可以使用指定参数无异常构造
定义 type_traits.hpp:2753
is_nothrow_copy_assignable
判断类型是否可无异常复制赋值
定义 type_traits.hpp:2897
is_nothrow_copy_constructible
判断类型是否可无异常复制构造
定义 type_traits.hpp:2818
is_nothrow_default_constructible
判断类型是否可无异常默认构造
定义 type_traits.hpp:2761
is_nothrow_move_assignable
判断类型是否可无异常移动赋值
定义 type_traits.hpp:2915
is_nothrow_swappable
判断类型是否可以与自身无异常交换
定义 type_traits.hpp:3959
pair
存储两个值的元组对
定义 pair.hpp:96
pair::pair
constexpr pair(Tuple1 &t1, Tuple2 &t2, index_sequence< Index1... > idx1, index_sequence< Index2... > idx2)
从两个tuple构造pair
定义 pair.hpp:321
pair::less_than
constexpr bool less_than(const pair &y) const noexcept(noexcept(this->first< y.first||(!(y.first< this->first) &&this->second< y.second)))
小于比较运算符
定义 pair.hpp:429
pair::operator=
constexpr pair & operator=(const pair< U1, U2 > &p) noexcept(conjunction< is_nothrow_assignable< T1 &, const U1 & >, is_nothrow_assignable< T2 &, const U2 & > >::value)
从不同类型pair的拷贝赋值运算符
定义 pair.hpp:381
pair::operator=
constexpr pair & operator=(type_identity_t< T && > p) noexcept(conjunction< is_nothrow_move_assignable< T1 >, is_nothrow_move_assignable< T2 > >::value)
移动赋值运算符
定义 pair.hpp:363
pair::pair
pair(const pair &p)=default
默认拷贝构造函数
pair::to_hash
constexpr size_t to_hash() const noexcept(noexcept(hash< remove_cvref_t< T1 > >()(first) ^ hash< remove_cvref_t< T2 > >()(second)))
计算hash值
定义 pair.hpp:440
pair::pair
constexpr pair(unpack_utility_construct_tag, tuple< Types1... > t1, tuple< Types2... > t2)
从两个tuple构造pair
定义 pair.hpp:335
pair::equal_to
constexpr bool equal_to(const pair &y) const noexcept(noexcept(this->first==y.first &&this->second==y.second))
相等比较运算符
定义 pair.hpp:417
pair::operator=
pair & operator=(const volatile pair &)=delete
禁止volatile拷贝赋值
pair::operator=
constexpr pair & operator=(pair< U1, U2 > &&p) noexcept(conjunction< is_nothrow_assignable< T1 &, U1 >, is_nothrow_assignable< T2 &, U2 > >::value)
从不同类型pair的移动赋值运算符
定义 pair.hpp:399
pair::operator=
constexpr pair & operator=(type_identity_t< const T & > p) noexcept(conjunction< is_nothrow_copy_assignable< T1 >, is_nothrow_copy_assignable< T2 > >::value)
拷贝赋值运算符
定义 pair.hpp:347
pair::swap
constexpr void swap(pair &p) noexcept(conjunction< is_nothrow_swappable< T1 >, is_nothrow_swappable< T2 > >::value)
交换两个pair的内容
定义 pair.hpp:450
pair::pair
pair(pair &&p)=default
默认移动构造函数
pair::~pair
constexpr ~pair()=default
析构函数
tuple_element
获取tuple元素类型的特化
定义 pair.hpp:499
tuple_size
获取tuple大小的特化
定义 pair.hpp:26
unpack_utility_construct_tag
解包工具构造标签
定义 types.hpp:521