add void_t, negation, conjunction that are missing in C+14

after backportig gegeric converters from c++17 branch.

Author: pmed

test/test_utility.cpp

@@ -190,8 +190,8 @@ void test_type_traits()
 	static_assert(v8pp::detail::is_string<v8pp::string_view>::value, "std::string_view");
 	static_assert(v8pp::detail::is_string<std::u16string>::value, "std::u16string");
 	static_assert(v8pp::detail::is_string<v8pp::u16string_view>::value, "std::u16string_view");
-	static_assert(v8pp::detail::is_string<std::u32string>::value, "std::u32string");
-	static_assert(v8pp::detail::is_string<v8pp::u32string_view>::value, "std::u32string_view");
+	//static_assert(v8pp::detail::is_string<std::u32string>::value, "std::u32string");
+	//static_assert(v8pp::detail::is_string<v8pp::u32string_view>::value, "std::u32string_view");
 	static_assert(v8pp::detail::is_string<std::wstring>::value, "std::wstring");
 	static_assert(v8pp::detail::is_string<v8pp::wstring_view>::value, "std::wstring_view");
 	static_assert(v8pp::detail::is_string<char const*>::value, "char const*");

v8pp/convert.hpp

@@ -12,15 +12,10 @@
 #include <v8.h>
 
 #include <climits>
-#include <string>
-#include <array>
-#include <vector>
-#include <map>
+#include <limits>
 #include <memory>
-#include <iterator>
 #include <stdexcept>
 #include <type_traits>
-#include <typeinfo>
 
 #include "v8pp/ptr_traits.hpp"
 #include "v8pp/utility.hpp"
@@ -456,14 +451,14 @@ struct convert<v8::Local<T>>
 
 
 template<typename T>
-struct is_wrapped_class : std::conjunction<
+struct is_wrapped_class : conjunction<
 	std::is_class<T>,
-	std::negation<detail::is_string<T>>,
-	std::negation<detail::is_mapping<T>>,
-	std::negation<detail::is_sequence<T>>,
-	std::negation<detail::is_array<T>>,
-	std::negation<detail::is_tuple<T>>,
-	std::negation<detail::is_shared_ptr<T>>
+	negation<detail::is_string<T>>,
+	negation<detail::is_mapping<T>>,
+	negation<detail::is_sequence<T>>,
+	negation<detail::is_array<T>>,
+	negation<detail::is_tuple<T>>,
+	negation<detail::is_shared_ptr<T>>
 > {};
 
 // convert specialization for wrapped user classes

v8pp/utility.hpp

@@ -112,11 +112,45 @@ class basic_string_view
 
 using string_view = basic_string_view<char>;
 using u16string_view = basic_string_view<char16_t>;
-using u32string_view = basic_string_view<char32_t>;
 using wstring_view = basic_string_view<wchar_t>;
+
 } // namespace v8pp {
 #endif
 
+namespace v8pp
+{
+/////////////////////////////////////////////////////////////////////////////
+//
+// void_t
+//
+#ifdef __cpp_lib_void_t
+using std::void_t;
+#else
+template<typename...> using void_t = void;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// conjunction, disjunction, negation
+//
+#ifdef __cpp_lib_logical_traits
+using std::conjunction;
+using std::disjunction;
+using std::negation;
+#else
+template<bool...> struct bool_pack {};
+
+template<typename... Bs>
+using conjunction = std::is_same<bool_pack<true, Bs::value...>, bool_pack<Bs::value..., true>>;
+
+template<typename... Bs>
+using disjunction = std::integral_constant<bool, !conjunction<Bs...>::value>;
+
+template<typename B>
+using negation = std::integral_constant<bool, !B::value>;
+#endif
+} // namespace v8pp {
+
 namespace v8pp { namespace detail {
 
 template<typename T>
@@ -157,7 +191,7 @@ template<typename T, typename U = void>
 struct is_mapping : std::false_type {};
 
 template<typename T>
-struct is_mapping<T, std::void_t<typename T::key_type, typename T::mapped_type,
+struct is_mapping<T, void_t<typename T::key_type, typename T::mapped_type,
 	decltype(std::declval<T>().begin()), decltype(std::declval<T>().end())>> : std::true_type {};
 
 /////////////////////////////////////////////////////////////////////////////
@@ -168,9 +202,9 @@ template<typename T, typename U = void>
 struct is_sequence : std::false_type {};
 
 template<typename T>
-struct is_sequence<T, std::void_t<typename T::value_type,
+struct is_sequence<T, void_t<typename T::value_type,
 	decltype(std::declval<T>().begin()), decltype(std::declval<T>().end()),
-	decltype(std::declval<T>().emplace_back(std::declval<typename T::value_type>()))>> : std::negation<is_string<T>> {};
+	decltype(std::declval<T>().emplace_back(std::declval<typename T::value_type>()))>> : negation<is_string<T>> {};
 
 /////////////////////////////////////////////////////////////////////////////
 //
@@ -183,7 +217,7 @@ struct has_reserve : std::false_type
 };
 
 template<typename T>
-struct has_reserve<T, std::void_t<decltype(std::declval<T>().reserve(0))>> : std::true_type
+struct has_reserve<T, void_t<decltype(std::declval<T>().reserve(0))>> : std::true_type
 {
 	static void reserve(T& container, size_t capacity)
 	{