NexusForce 1.0.0
A rigorously engineered full-stack C++ backend library.
载入中...
搜索中...
未找到
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 noexcept { return _NEFORCE hash_combine_all(first, second); }
441
446 NEFORCE_CONSTEXPR14 void
447 swap(pair& p) noexcept(conjunction<is_nothrow_swappable<T1>, is_nothrow_swappable<T2>>::value) {
448 _NEFORCE swap(first, p.first);
449 _NEFORCE swap(second, p.second);
450 }
451};
452
453#ifdef NEFORCE_STANDARD_17
454template <typename T1, typename T2>
455pair(T1, T2) -> pair<T1, T2>;
456#endif
457
458
469template <typename T1, typename T2>
470constexpr pair<unwrap_ref_decay_t<T1>, unwrap_ref_decay_t<T2>>
471make_pair(T1&& x, T2&& y) noexcept(conjunction<is_nothrow_constructible<unwrap_ref_decay_t<T1>, T1>,
472 is_nothrow_constructible<unwrap_ref_decay_t<T2>, T2>>::value) {
473 using unwrap_pair = pair<unwrap_ref_decay_t<T1>, unwrap_ref_decay_t<T2>>;
474 return unwrap_pair(_NEFORCE forward<T1>(x), _NEFORCE forward<T2>(y));
475}
476 // Pair
478
484
490template <typename... Types>
491struct tuple_size<tuple<Types...>> : integral_constant<size_t, sizeof...(Types)> {};
492
493#define __NEFORCE_BUILD_TUPLE_TUPLE_SIZE(CV) \
494 template <typename... Types> \
495 struct tuple_size<tuple<Types...> CV> : integral_constant<size_t, sizeof...(Types)> {};
496NEFORCE_MACRO_RANGES_CV(__NEFORCE_BUILD_TUPLE_TUPLE_SIZE)
497#undef __NEFORCE_BUILD_TUPLE_TUPLE_SIZE
498
499
505template <size_t Index>
506struct tuple_element<Index, tuple<>> {};
507
513template <typename This, typename... Rest>
514struct tuple_element<0, tuple<This, Rest...>> {
515 using type = This;
516 using tuple_type = tuple<This, Rest...>;
517};
518
525template <size_t Index, typename This, typename... Rest>
526struct tuple_element<Index, tuple<This, Rest...>> : tuple_element<Index - 1, tuple<Rest...>> {};
527
534template <size_t Index, typename... Types>
535struct tuple_element : tuple_element<Index, tuple<Types...>> {};
536
537
543template <typename T1, typename T2>
544struct tuple_size<pair<T1, T2>> : integral_constant<size_t, 2> {};
545
546#define __NEFORCE_BUILD_PAIR_TUPLE_SIZE(CV) \
547 template <typename T1, typename T2> \
548 struct tuple_size<pair<T1, T2> CV> : integral_constant<size_t, 2> {};
549NEFORCE_MACRO_RANGES_CV(__NEFORCE_BUILD_PAIR_TUPLE_SIZE)
550#undef __NEFORCE_BUILD_PAIR_TUPLE_SIZE
551
558template <size_t Index, typename T1, typename T2>
559struct tuple_element<Index, pair<T1, T2>> {
560 static_assert(Index < 2, "pair element index out of range.");
561
562 using type = conditional_t<Index == 0, T1, T2>;
563 using tuple_type = tuple<T1, T2>;
564};
565 // Tuple
567
573
574#ifndef NEFORCE_STANDARD_17
576NEFORCE_BEGIN_INNER__
577
578template <size_t Index, typename T1, typename T2>
579struct __pair_get_helper;
580template <typename T1, typename T2>
581struct __pair_get_helper<0, T1, T2> {
582 NEFORCE_NODISCARD constexpr static tuple_element_t<0, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept {
583 return pir.first;
584 }
585 NEFORCE_NODISCARD constexpr static const tuple_element_t<0, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept {
586 return pir.first;
587 }
588 NEFORCE_NODISCARD constexpr static tuple_element_t<0, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept {
589 return _NEFORCE forward<T1>(pir.first);
590 }
591 NEFORCE_NODISCARD constexpr static const tuple_element_t<0, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept {
592 return _NEFORCE forward<const T1>(pir.first);
593 }
594};
595
596template <typename T1, typename T2>
597struct __pair_get_helper<1, T1, T2> {
598 NEFORCE_NODISCARD constexpr static tuple_element_t<1, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept {
599 return pir.second;
600 }
601 NEFORCE_NODISCARD constexpr static const tuple_element_t<1, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept {
602 return pir.second;
603 }
604 NEFORCE_NODISCARD constexpr static tuple_element_t<1, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept {
605 return _NEFORCE forward<T2>(pir.second);
606 }
607 NEFORCE_NODISCARD constexpr static const tuple_element_t<1, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept {
608 return _NEFORCE forward<const T2>(pir.second);
609 }
610};
611
612NEFORCE_END_INNER__
614#endif // !NEFORCE_STANDARD_17
615
619template <size_t Index, typename T1, typename T2>
620NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept;
621
622#ifdef NEFORCE_STANDARD_17
623template <size_t Index, typename T1, typename T2>
624NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept {
625 if constexpr (Index == 0) {
626 return pir.first;
627 } else {
628 return pir.second;
629 }
630}
631#else
632template <size_t Index, typename T1, typename T2>
633NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>& get(pair<T1, T2>& pir) noexcept {
634 return inner::__pair_get_helper<Index, T1, T2>::get(pir);
635}
636#endif // NEFORCE_STANDARD_17
637
641template <typename T1, typename T2>
642NEFORCE_NODISCARD constexpr T1& get(pair<T1, T2>& pir) noexcept {
643 return pir.first;
644}
645
649template <typename T2, typename T1>
650NEFORCE_NODISCARD constexpr T2& get(pair<T1, T2>& pir) noexcept {
651 return pir.second;
652}
653
654
658template <size_t Index, typename T1, typename T2>
659NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept;
660
661#ifdef NEFORCE_STANDARD_17
662template <size_t Index, typename T1, typename T2>
663NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept {
664 if constexpr (Index == 0) {
665 return pir.first;
666 } else {
667 return pir.second;
668 }
669}
670#else
671template <size_t Index, typename T1, typename T2>
672NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>& get(const pair<T1, T2>& pir) noexcept {
673 return inner::__pair_get_helper<Index, T1, T2>::get(pir);
674}
675#endif // NEFORCE_STANDARD_17
676
680template <typename T1, typename T2>
681NEFORCE_NODISCARD constexpr const T1& get(const pair<T1, T2>& pir) noexcept {
682 return pir.first;
683}
684
688template <typename T2, typename T1>
689NEFORCE_NODISCARD constexpr const T2& get(const pair<T1, T2>& pir) noexcept {
690 return pir.second;
691}
692
693
697template <size_t Index, typename T1, typename T2>
698NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept;
699
700#ifdef NEFORCE_STANDARD_17
701template <size_t Index, typename T1, typename T2>
702NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept {
703 if constexpr (Index == 0) {
704 return _NEFORCE forward<T1>(pir.first);
705 } else {
706 return _NEFORCE forward<T2>(pir.second);
707 }
708}
709#else
710template <size_t Index, typename T1, typename T2>
711NEFORCE_NODISCARD constexpr tuple_element_t<Index, pair<T1, T2>>&& get(pair<T1, T2>&& pir) noexcept {
712 return _NEFORCE forward<tuple_element_t<Index, pair<T1, T2>>>(
713 inner::__pair_get_helper<Index, T1, T2>::get(_NEFORCE forward<pair<T1, T2>>(pir)));
714}
715#endif // NEFORCE_STANDARD_17
716
720template <typename T1, typename T2>
721NEFORCE_NODISCARD constexpr T1&& get(pair<T1, T2>&& pir) noexcept {
722 return _NEFORCE forward<T1>(pir.first);
723}
724
728template <typename T2, typename T1>
729NEFORCE_NODISCARD constexpr T2&& get(pair<T1, T2>&& pir) noexcept {
730 return _NEFORCE forward<T2>(pir.second);
731}
732
733
737template <size_t Index, typename T1, typename T2>
738NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept;
739
740#ifdef NEFORCE_STANDARD_17
741template <size_t Index, typename T1, typename T2>
742NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept {
743 if constexpr (Index == 0) {
744 return _NEFORCE forward<const T1>(pir.first);
745 } else {
746 return _NEFORCE forward<const T2>(pir.second);
747 }
748}
749#else
750template <size_t Index, typename T1, typename T2>
751NEFORCE_NODISCARD constexpr const tuple_element_t<Index, pair<T1, T2>>&& get(const pair<T1, T2>&& pir) noexcept {
752 return _NEFORCE forward<const tuple_element_t<Index, pair<T1, T2>>>(
753 inner::__pair_get_helper<Index, T1, T2>::get(_NEFORCE forward<const pair<T1, T2>>(pir)));
754}
755#endif // NEFORCE_STANDARD_17
756
760template <typename T1, typename T2>
761NEFORCE_NODISCARD constexpr const T1&& get(const pair<T1, T2>&& pir) noexcept {
762 return _NEFORCE forward<const T1>(pir.first);
763}
764
768template <typename T2, typename T1>
769NEFORCE_NODISCARD constexpr const T2&& get(const pair<T1, T2>&& pir) noexcept {
770 return _NEFORCE forward<const T2>(pir.second);
771}
772 // Pair
774
775NEFORCE_END_NAMESPACE__
776
777#ifdef NEFORCE_STANDARD_17
778# include <utility>
779namespace std {
780 template <typename T1, typename T2>
781 struct tuple_size<_NEFORCE pair<T1, T2>> : _NEFORCE integral_constant<_NEFORCE size_t, 2> {};
782
783 template <_NEFORCE size_t I, typename T1, typename T2>
784 struct tuple_element<I, _NEFORCE pair<T1, T2>> {
785 using type = _NEFORCE tuple_element_t<I, _NEFORCE pair<T1, T2>>;
786 };
787} // namespace std
788#endif
789
790#endif // NEFORCE_CORE_UTILITY_PAIR_HPP__
neforce::forward
constexpr T && forward(remove_reference_t< T > &x) noexcept
完美转发左值
定义 type_traits.hpp:3028
neforce::get
enable_if_t< is_void_v< T >, future_result_t< T > > get(future< T > &f)
通用future结果获取函数
定义 future.hpp:1189
neforce::index_sequence
integer_sequence< size_t, Values... > index_sequence
索引序列
定义 integer_sequence.hpp:68
neforce::index_sequence_for
make_index_sequence< sizeof...(Types)> index_sequence_for
根据类型参数包生成索引序列
定义 integer_sequence.hpp:88
neforce::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:471
neforce::unwrap_ref_decay_t
typename unwrap_ref_decay< T >::type unwrap_ref_decay_t
unwrap_ref_decay的便捷别名
定义 reference_wrapper.hpp:233
neforce::move
constexpr Iterator2 move(Iterator1 first, Iterator1 last, Iterator2 result) noexcept(noexcept(inner::__move_aux(first, last, result)))
移动范围元素
定义 shift.hpp:312
neforce::tuple_element_t
typename tuple_element< Index, Types... >::type tuple_element_t
tuple_element的类型别名
定义 pair.hpp:52
neforce::tuple_size_v
constexpr size_t tuple_size_v
tuple_size的类型别名
定义 pair.hpp:37
neforce::tuple_extract_base_t
typename tuple_element< Index, Types... >::tuple_type tuple_extract_base_t
获取tuple元素基类型的类型别名
定义 pair.hpp:60
NEFORCE_MACRO_RANGES_CV
#define NEFORCE_MACRO_RANGES_CV(MAC)
cv限定符列表宏
定义 c++config.hpp:710
neforce::conjunction_v
constexpr bool conjunction_v
conjunction的便捷变量模板
定义 type_traits.hpp:321
neforce::enable_if_t
typename enable_if< Test, T >::type enable_if_t
enable_if的便捷别名
定义 type_traits.hpp:118
neforce::conditional_t
typename conditional< Test, T1, T2 >::type conditional_t
conditional的便捷别名
定义 type_traits.hpp:145
neforce::type_identity_t
typename type_identity< T >::type type_identity_t
type_identity的便捷别名
定义 type_traits.hpp:209
neforce::hash_combine_all
constexpr size_t hash_combine_all(const Types &... values) noexcept
混合多个哈希值
定义 hash.hpp:308
icommon.hpp
基本接口基类
integer_sequence.hpp
整数序列工具
reference_wrapper.hpp
引用包装器
neforce::conjunction
类型集合的逻辑与操作
定义 type_traits.hpp:308
neforce::icommon
通用接口，同时具备可比较和可哈希功能
定义 icommon.hpp:193
neforce::integral_constant
整数常量包装器
定义 type_traits.hpp:36
neforce::is_assignable
判断类型是否可以使用指定类型的值进行赋值
定义 type_traits.hpp:2473
neforce::is_constructible
判断类型是否可以使用指定参数构造
定义 type_traits.hpp:2366
neforce::is_convertible
判断类型From是否可以隐式转换为类型To
定义 type_traits.hpp:3144
neforce::is_copy_constructible
判断类型是否可复制构造
定义 type_traits.hpp:2384
neforce::is_default_constructible
判断类型是否可默认构造
定义 type_traits.hpp:2402
neforce::is_implicitly_default_constructible
判断类型是否可隐式默认构造
定义 type_traits.hpp:2430
neforce::is_nothrow_assignable
判断类型是否可以使用指定类型的值进行无异常赋值
定义 type_traits.hpp:2873
neforce::is_nothrow_constructible
判断类型是否可以使用指定参数无异常构造
定义 type_traits.hpp:2753
neforce::is_nothrow_copy_assignable
判断类型是否可无异常复制赋值
定义 type_traits.hpp:2897
neforce::is_nothrow_copy_constructible
判断类型是否可无异常复制构造
定义 type_traits.hpp:2818
neforce::is_nothrow_default_constructible
判断类型是否可无异常默认构造
定义 type_traits.hpp:2761
neforce::is_nothrow_move_assignable
判断类型是否可无异常移动赋值
定义 type_traits.hpp:2915
neforce::is_nothrow_swappable
判断类型是否可以与自身无异常交换
定义 type_traits.hpp:3959
neforce::pair
存储两个值的元组对
定义 pair.hpp:96
neforce::pair::pair
pair(const pair &p)=default
默认拷贝构造函数
neforce::pair::swap
constexpr void swap(pair &p) noexcept(conjunction< is_nothrow_swappable< T1 >, is_nothrow_swappable< T2 > >::value)
交换两个pair的内容
定义 pair.hpp:447
neforce::pair::~pair
constexpr ~pair()=default
析构函数
neforce::pair::to_hash
constexpr size_t to_hash() const noexcept
计算hash值
定义 pair.hpp:440
neforce::pair::pair
pair(pair &&p)=default
默认移动构造函数
neforce::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
neforce::pair::pair
constexpr pair(Tuple1 &t1, Tuple2 &t2, index_sequence< Index1... > idx1, index_sequence< Index2... > idx2)
从两个tuple构造pair
定义 pair.hpp:321
neforce::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
neforce::pair::pair
constexpr pair(unpack_utility_construct_tag, tuple< Types1... > t1, tuple< Types2... > t2)
从两个tuple构造pair
定义 pair.hpp:335
neforce::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
neforce::pair::equal_to
constexpr bool equal_to(const pair &y) const noexcept(noexcept(this->first==y.first &&this->second==y.second))
相等比较运算符
定义 pair.hpp:417
neforce::pair::operator=
pair & operator=(const volatile pair &)=delete
禁止volatile拷贝赋值
neforce::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
neforce::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
neforce::tuple_element
获取tuple元素类型的特化
定义 pair.hpp:496
neforce::tuple_size
获取tuple大小的特化
定义 pair.hpp:26
neforce::unpack_utility_construct_tag
解包工具构造标签
定义 typeinfo/types.hpp:520