1 // DR 339 2 // 3 // Test of the use of various binary operators with SFINAE 4 5 // Boilerplate helpers 6 typedef char yes_type; 7 struct no_type { char data[2]; }; 8 9 template<typename T> T create_a(); 10 template<typename T> struct type { }; 11 12 template<bool, typename T = void> struct enable_if { typedef T type; }; 13 template<typename T> struct enable_if<false, T> { }; 14 15 #define JOIN( X, Y ) DO_JOIN( X, Y ) 16 #define DO_JOIN( X, Y ) DO_JOIN2(X,Y) 17 #define DO_JOIN2( X, Y ) X##Y 18 19 #define DEFINE_INFIX_BINARY_TRAIT(Name,Op) \ 20 template<typename T, typename U> \ 21 typename enable_if<(sizeof(create_a<T>() Op create_a<U>(), 1) > 0), \ 22 yes_type>::type \ 23 JOIN(check_,Name)(type<T>, type<U>); \ 24 \ 25 no_type JOIN(check_,Name)(...); \ 26 \ 27 template<typename T, typename U = T> \ 28 struct Name \ 29 { \ 30 static const bool value = \ 31 (sizeof(JOIN(check_,Name)(type<T>(), type<U>())) == sizeof(yes_type)); \ 32 } 33 34 template<typename T, typename U> 35 typename enable_if<(sizeof(create_a<T>()[create_a<U>()], 1) > 0), 36 yes_type>::type 37 check_subscript(int); 38 39 template<typename T, typename U> 40 no_type check_subscript(...); 41 42 template<typename T, typename U> 43 struct can_subscript 44 { 45 static const bool value = 46 (sizeof(check_subscript<T, U>(0)) == sizeof(yes_type)); 47 }; 48 49 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 50 # define STATIC_ASSERT(Expr) static_assert(Expr, #Expr) 51 #else 52 # define STATIC_ASSERT(Expr) int JOIN(a,__LINE__)[Expr? 1 : -1] 53 #endif 54 55 struct X { }; 56 struct Y { int operator[](X); }; 57 58 // is_addable 59 DEFINE_INFIX_BINARY_TRAIT(is_addable, +); 60 X operator+(X, X); 61 X operator+(X, Y); 62 STATIC_ASSERT((is_addable<int>::value)); 63 STATIC_ASSERT((is_addable<int, long>::value)); 64 STATIC_ASSERT((is_addable<X>::value)); 65 STATIC_ASSERT((is_addable<int*, int>::value)); 66 STATIC_ASSERT((!is_addable<int*>::value)); 67 STATIC_ASSERT((is_addable<X, Y>::value)); 68 STATIC_ASSERT((!is_addable<Y>::value)); 69 70 // is_subtractable 71 DEFINE_INFIX_BINARY_TRAIT(is_subtractable, -); 72 X operator-(X, X); 73 X operator-(X, Y); 74 STATIC_ASSERT((is_subtractable<int>::value)); 75 STATIC_ASSERT((is_subtractable<int, long>::value)); 76 STATIC_ASSERT((is_subtractable<X>::value)); 77 STATIC_ASSERT((is_subtractable<int*, int>::value)); 78 STATIC_ASSERT((is_subtractable<int*>::value)); 79 STATIC_ASSERT((is_subtractable<X, Y>::value)); 80 STATIC_ASSERT((!is_subtractable<Y>::value)); 81 STATIC_ASSERT((!is_subtractable<int X::*>::value)); 82 83 // is_multiplicable 84 DEFINE_INFIX_BINARY_TRAIT(is_multiplicable, *); 85 X operator*(X, X); 86 X operator*(X, Y); 87 STATIC_ASSERT((is_multiplicable<int>::value)); 88 STATIC_ASSERT((is_multiplicable<int, long>::value)); 89 STATIC_ASSERT((is_multiplicable<X>::value)); 90 STATIC_ASSERT((!is_multiplicable<int*, int>::value)); 91 STATIC_ASSERT((!is_multiplicable<int*>::value)); 92 STATIC_ASSERT((is_multiplicable<X, Y>::value)); 93 STATIC_ASSERT((!is_multiplicable<Y>::value)); 94 STATIC_ASSERT((!is_multiplicable<int X::*>::value)); 95 96 // is_divisible 97 DEFINE_INFIX_BINARY_TRAIT(is_divisible, /); 98 X operator/(X, X); 99 X operator/(X, Y); 100 STATIC_ASSERT((is_divisible<int>::value)); 101 STATIC_ASSERT((is_divisible<int, long>::value)); 102 STATIC_ASSERT((is_divisible<X>::value)); 103 STATIC_ASSERT((!is_divisible<int*, int>::value)); 104 STATIC_ASSERT((!is_divisible<int*>::value)); 105 STATIC_ASSERT((is_divisible<X, Y>::value)); 106 STATIC_ASSERT((!is_divisible<Y>::value)); 107 STATIC_ASSERT((!is_divisible<int X::*>::value)); 108 109 // has_remainder 110 DEFINE_INFIX_BINARY_TRAIT(has_remainder, %); 111 X operator%(X, X); 112 X operator%(X, Y); 113 STATIC_ASSERT((has_remainder<int>::value)); 114 STATIC_ASSERT((has_remainder<int, long>::value)); 115 STATIC_ASSERT((!has_remainder<float>::value)); 116 STATIC_ASSERT((has_remainder<X>::value)); 117 STATIC_ASSERT((!has_remainder<int*, int>::value)); 118 STATIC_ASSERT((!has_remainder<int*>::value)); 119 STATIC_ASSERT((has_remainder<X, Y>::value)); 120 STATIC_ASSERT((!has_remainder<Y>::value)); 121 STATIC_ASSERT((!has_remainder<int X::*>::value)); 122 123 // has_xor 124 DEFINE_INFIX_BINARY_TRAIT(has_xor, ^); 125 X operator^(X, X); 126 X operator^(X, Y); 127 STATIC_ASSERT((has_xor<int>::value)); 128 STATIC_ASSERT((has_xor<int, long>::value)); 129 STATIC_ASSERT((!has_xor<float>::value)); 130 STATIC_ASSERT((has_xor<X>::value)); 131 STATIC_ASSERT((!has_xor<int*, int>::value)); 132 STATIC_ASSERT((!has_xor<int*>::value)); 133 STATIC_ASSERT((has_xor<X, Y>::value)); 134 STATIC_ASSERT((!has_xor<Y>::value)); 135 STATIC_ASSERT((!has_xor<int X::*>::value)); 136 137 // has_bitand 138 DEFINE_INFIX_BINARY_TRAIT(has_bitand, &); 139 X operator&(X, X); 140 X operator&(X, Y); 141 STATIC_ASSERT((has_bitand<int>::value)); 142 STATIC_ASSERT((has_bitand<int, long>::value)); 143 STATIC_ASSERT((!has_bitand<float>::value)); 144 STATIC_ASSERT((has_bitand<X>::value)); 145 STATIC_ASSERT((!has_bitand<int*, int>::value)); 146 STATIC_ASSERT((!has_bitand<int*>::value)); 147 STATIC_ASSERT((has_bitand<X, Y>::value)); 148 STATIC_ASSERT((!has_bitand<Y>::value)); 149 STATIC_ASSERT((!has_bitand<int X::*>::value)); 150 151 // has_bitor 152 DEFINE_INFIX_BINARY_TRAIT(has_bitor, |); 153 X operator|(X, X); 154 X operator|(X, Y); 155 STATIC_ASSERT((has_bitor<int>::value)); 156 STATIC_ASSERT((has_bitor<int, long>::value)); 157 STATIC_ASSERT((!has_bitor<float>::value)); 158 STATIC_ASSERT((has_bitor<X>::value)); 159 STATIC_ASSERT((!has_bitor<int*, int>::value)); 160 STATIC_ASSERT((!has_bitor<int*>::value)); 161 STATIC_ASSERT((has_bitor<X, Y>::value)); 162 STATIC_ASSERT((!has_bitor<Y>::value)); 163 STATIC_ASSERT((!has_bitor<int X::*>::value)); 164 165 // has_left_shift 166 DEFINE_INFIX_BINARY_TRAIT(has_left_shift, <<); 167 X operator<<(X, X); 168 X operator<<(X, Y); 169 STATIC_ASSERT((has_left_shift<int>::value)); 170 STATIC_ASSERT((has_left_shift<int, long>::value)); 171 STATIC_ASSERT((!has_left_shift<float>::value)); 172 STATIC_ASSERT((has_left_shift<X>::value)); 173 STATIC_ASSERT((!has_left_shift<int*, int>::value)); 174 STATIC_ASSERT((!has_left_shift<int*>::value)); 175 STATIC_ASSERT((has_left_shift<X, Y>::value)); 176 STATIC_ASSERT((!has_left_shift<Y>::value)); 177 STATIC_ASSERT((!has_left_shift<int X::*>::value)); 178 179 // has_right_shift 180 DEFINE_INFIX_BINARY_TRAIT(has_right_shift, >>); 181 X operator>>(X, X); 182 X operator>>(X, Y); 183 STATIC_ASSERT((has_right_shift<int>::value)); 184 STATIC_ASSERT((has_right_shift<int, long>::value)); 185 STATIC_ASSERT((!has_right_shift<float>::value)); 186 STATIC_ASSERT((has_right_shift<X>::value)); 187 STATIC_ASSERT((!has_right_shift<int*, int>::value)); 188 STATIC_ASSERT((!has_right_shift<int*>::value)); 189 STATIC_ASSERT((has_right_shift<X, Y>::value)); 190 STATIC_ASSERT((!has_right_shift<Y>::value)); 191 STATIC_ASSERT((!has_right_shift<int X::*>::value)); 192 193 // can_subscript 194 STATIC_ASSERT((can_subscript<int*, int>::value)); 195 STATIC_ASSERT((can_subscript<int, int*>::value)); 196 STATIC_ASSERT((can_subscript<int(&)[7], int>::value)); 197 STATIC_ASSERT((can_subscript<int, int(&)[7]>::value)); 198 STATIC_ASSERT((!can_subscript<X, Y>::value)); 199 STATIC_ASSERT((can_subscript<Y, X>::value)); 200