Competitive/atcoder/internal_type_traits.hpp at master · rishabhdeepsingh/Competitive · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#pragma once
#include "../library/IO.hpp"

namespace atcoder::internal {

#ifndef _MSC_VER
template<class T>
using is_signed_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value ||
    std::is_same<T, __int128>::value,
                          std::true_type,
                          std::false_type>::type;

template<class T>
using is_unsigned_int128 =
typename std::conditional<std::is_same<T, __uint128_t>::value ||
    std::is_same<T, unsigned __int128>::value,
                          std::true_type,
                          std::false_type>::type;

template<class T>
using make_unsigned_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value,
                          __uint128_t,
                          unsigned __int128>;

template<class T>
using is_integral = typename std::conditional<std::is_integral<T>::value ||
    is_signed_int128<T>::value ||
    is_unsigned_int128<T>::value,
                                              std::true_type,
                                              std::false_type>::type;

template<class T>
using is_signed_int = typename std::conditional<(is_integral<T>::value &&
    std::is_signed<T>::value) ||
    is_signed_int128<T>::value,
                                                std::true_type,
                                                std::false_type>::type;

template<class T>
using is_unsigned_int =
typename std::conditional<(is_integral<T>::value &&
    std::is_unsigned<T>::value) ||
    is_unsigned_int128<T>::value,
                          std::true_type,
                          std::false_type>::type;

template<class T>
using to_unsigned = typename std::conditional<
    is_signed_int128<T>::value,
    make_unsigned_int128<T>,
    typename std::conditional<std::is_signed<T>::value,
                              std::make_unsigned<T>,
                              std::common_type<T>>::type>::type;

#else

template <class T> using is_integral = typename std::is_integral<T>;

template <class T>
using is_signed_int =
    typename std::conditional<is_integral<T>::value && std::is_signed<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using is_unsigned_int =
    typename std::conditional<is_integral<T>::value &&
                                  std::is_unsigned<T>::value,
                              std::true_type,
                              std::false_type>::type;

template <class T>
using to_unsigned = typename std::conditional<is_signed_int<T>::value,
                                              std::make_unsigned<T>,
                                              std::common_type<T>>::type;

#endif

template<class T>
using is_signed_int_t = std::enable_if_t<is_signed_int<T>::value>;

template<class T>
using is_unsigned_int_t = std::enable_if_t<is_unsigned_int<T>::value>;

template<class T> using to_unsigned_t = typename to_unsigned<T>::type;

}  // namespace atcoder:internal