1 #ifndef TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 2 #define TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 3 4 #if defined(_MSC_VER) || \ 5 (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 6 (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 7 #pragma once 8 #endif 9 10 #include <type_traits> 11 #include <utility> 12 #include <string> 13 #include <sstream> 14 15 namespace YAML { 16 template <typename> 17 struct is_numeric { 18 enum { value = false }; 19 }; 20 21 template <> 22 struct is_numeric<char> { 23 enum { value = true }; 24 }; 25 template <> 26 struct is_numeric<unsigned char> { 27 enum { value = true }; 28 }; 29 template <> 30 struct is_numeric<int> { 31 enum { value = true }; 32 }; 33 template <> 34 struct is_numeric<unsigned int> { 35 enum { value = true }; 36 }; 37 template <> 38 struct is_numeric<long int> { 39 enum { value = true }; 40 }; 41 template <> 42 struct is_numeric<unsigned long int> { 43 enum { value = true }; 44 }; 45 template <> 46 struct is_numeric<short int> { 47 enum { value = true }; 48 }; 49 template <> 50 struct is_numeric<unsigned short int> { 51 enum { value = true }; 52 }; 53 #if defined(_MSC_VER) && (_MSC_VER < 1310) 54 template <> 55 struct is_numeric<__int64> { 56 enum { value = true }; 57 }; 58 template <> 59 struct is_numeric<unsigned __int64> { 60 enum { value = true }; 61 }; 62 #else 63 template <> 64 struct is_numeric<long long> { 65 enum { value = true }; 66 }; 67 template <> 68 struct is_numeric<unsigned long long> { 69 enum { value = true }; 70 }; 71 #endif 72 template <> 73 struct is_numeric<float> { 74 enum { value = true }; 75 }; 76 template <> 77 struct is_numeric<double> { 78 enum { value = true }; 79 }; 80 template <> 81 struct is_numeric<long double> { 82 enum { value = true }; 83 }; 84 85 template <bool, class T = void> 86 struct enable_if_c { 87 typedef T type; 88 }; 89 90 template <class T> 91 struct enable_if_c<false, T> {}; 92 93 template <class Cond, class T = void> 94 struct enable_if : public enable_if_c<Cond::value, T> {}; 95 96 template <bool, class T = void> 97 struct disable_if_c { 98 typedef T type; 99 }; 100 101 template <class T> 102 struct disable_if_c<true, T> {}; 103 104 template <class Cond, class T = void> 105 struct disable_if : public disable_if_c<Cond::value, T> {}; 106 } 107 108 template <typename S, typename T> 109 struct is_streamable { 110 template <typename SS, typename TT> 111 static auto test(int) 112 -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type()); 113 114 template <typename, typename> 115 static auto test(...) -> std::false_type; 116 117 static const bool value = decltype(test<S, T>(0))::value; 118 }; 119 120 template<typename Key, bool Streamable> 121 struct streamable_to_string { 122 static std::string impl(const Key& key) { 123 std::stringstream ss; 124 ss << key; 125 return ss.str(); 126 } 127 }; 128 129 template<typename Key> 130 struct streamable_to_string<Key, false> { 131 static std::string impl(const Key&) { 132 return ""; 133 } 134 }; 135 #endif // TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 136