From 17f1b653c38a2f9478aaf9d6d762d0c8dd9e6f6f Mon Sep 17 00:00:00 2001
From: Markus Mittendrein <git@maxmitti.tk>
Date: Sun, 21 Jul 2019 00:04:29 +0200
Subject: Simplify similar specializations of AutoConversion and FormatConvert
 using base structs

---
 cxxformat.hpp | 98 ++++++++++++++---------------------------------------------
 main.cpp      | 18 ++---------
 2 files changed, 25 insertions(+), 91 deletions(-)

diff --git a/cxxformat.hpp b/cxxformat.hpp
index d4e8dfd..b02fe4f 100644
--- a/cxxformat.hpp
+++ b/cxxformat.hpp
@@ -27,68 +27,35 @@ using FormatException = std::invalid_argument;
 template<typename To, typename From, typename Enable = void>
 struct FormatConvert {};
 
-template<typename From>
-struct FormatConvert<std::intmax_t, From, std::enable_if_t<std::is_signed_v<From> && std::is_integral_v<From>>>
+template<typename To, typename From>
+struct ImplicitConversion
 {
-	static constexpr std::intmax_t convert(From from)
+	static constexpr To convert(From from)
 	{
 		return from;
 	}
 };
 
 template<typename From>
-struct FormatConvert<std::intmax_t, From, std::enable_if_t<std::is_unsigned_v<From> && std::is_integral_v<From> && (sizeof(From) < sizeof(std::intmax_t))>>
-{
-	static constexpr std::intmax_t convert(From from)
-	{
-		return from;
-	}
-};
+struct FormatConvert<std::intmax_t, From, std::enable_if_t<std::is_signed_v<From> && std::is_integral_v<From>>> : ImplicitConversion<std::intmax_t, From> {};
 
 template<typename From>
-struct FormatConvert<std::uintmax_t, From, std::enable_if_t<std::is_unsigned_v<From> && std::is_integral_v<From>>>
-{
-	static constexpr std::uintmax_t convert(From from)
-	{
-		return from;
-	}
-};
+struct FormatConvert<std::intmax_t, From, std::enable_if_t<std::is_unsigned_v<From> && std::is_integral_v<From> && (sizeof(From) < sizeof(std::intmax_t))>> : ImplicitConversion<std::intmax_t, From> {};
+
+template<typename From>
+struct FormatConvert<std::uintmax_t, From, std::enable_if_t<std::is_unsigned_v<From> && std::is_integral_v<From>>> : ImplicitConversion<std::uintmax_t, From> {};
 
 template<typename String>
-struct FormatConvert<std::string_view, String, std::enable_if_t<std::is_convertible_v<String, std::string_view>>>
-{
-	static constexpr std::string_view convert(const String &str)
-	{
-		return str;
-	}
-};
+struct FormatConvert<std::string_view, String, std::enable_if_t<std::is_convertible_v<String, std::string_view>>> : ImplicitConversion<std::string_view, const String &> {};
 
 template<typename From>
-struct FormatConvert<double, From, std::enable_if_t<std::is_convertible_v<From, double> && !std::is_integral_v<From>>>
-{
-	static constexpr double convert(const From& val)
-	{
-		return val;
-	}
-};
+struct FormatConvert<double, From, std::enable_if_t<std::is_convertible_v<From, double> && !std::is_integral_v<From>>> : ImplicitConversion<double, const From &> {};
 
 template<typename Pointer>
-struct FormatConvert<const void *, Pointer, std::enable_if_t<std::is_pointer_v<Pointer> && !std::is_array_v<std::remove_pointer_t<Pointer>> && !std::is_same_v<std::remove_pointer_t<Pointer>, char>>>
-{
-	static constexpr const void *convert(const Pointer* pointer)
-	{
-		return pointer;
-	}
-};
+struct FormatConvert<const void *, Pointer, std::enable_if_t<std::is_pointer_v<Pointer> && !std::is_array_v<std::remove_pointer_t<Pointer>> && !std::is_same_v<std::remove_pointer_t<Pointer>, char>>> : ImplicitConversion<const void *, const Pointer *> {};
 
 template<typename Pointer>
-struct FormatConvert<const void *, Pointer, std::enable_if_t<std::is_pointer_v<Pointer> && std::is_array_v<std::remove_pointer_t<Pointer>>>>
-{
-	static constexpr const void *convert(const Pointer pointer)
-	{
-		return pointer;
-	}
-};
+struct FormatConvert<const void *, Pointer, std::enable_if_t<std::is_pointer_v<Pointer> && std::is_array_v<std::remove_pointer_t<Pointer>>>> : ImplicitConversion<const void*, const Pointer> {};
 
 template<typename From, typename Enable = void>
 struct AutoConversion
@@ -99,50 +66,29 @@ struct AutoConversion
 	}
 };
 
-template<typename From>
-struct AutoConversion<From, std::enable_if_t<std::is_integral_v<From> && std::is_unsigned_v<From>>>
+template<char Conversion, typename From>
+struct SimpleAutoConversion
 {
 	static std::string conversion(const From &)
 	{
-		return "u";
+		return std::string{Conversion};
 	}
 };
 
 template<typename From>
-struct AutoConversion<From, std::enable_if_t<std::is_integral_v<From> && std::is_signed_v<From>>>
-{
-	static std::string conversion(const From &)
-	{
-		return "d";
-	}
-};
+struct AutoConversion<From, std::enable_if_t<std::is_integral_v<From> && std::is_unsigned_v<From>>> : SimpleAutoConversion<'u', From> {};
 
 template<typename From>
-struct AutoConversion<From, std::enable_if_t<std::is_convertible_v<From, double> && !std::is_integral_v<From>>>
-{
-	static std::string conversion(const From &)
-	{
-		return "G";
-	}
-};
+struct AutoConversion<From, std::enable_if_t<std::is_integral_v<From> && std::is_signed_v<From>>> : SimpleAutoConversion<'d', From> {};
 
 template<typename From>
-struct AutoConversion<From, std::enable_if_t<std::is_convertible_v<From, std::string_view>>>
-{
-	static std::string conversion(const From &)
-	{
-		return "s";
-	}
-};
+struct AutoConversion<From, std::enable_if_t<std::is_convertible_v<From, double> && !std::is_integral_v<From>>> : SimpleAutoConversion<'G', From> {};
+
+template<typename From>
+struct AutoConversion<From, std::enable_if_t<std::is_convertible_v<From, std::string_view>>> : SimpleAutoConversion<'s', From> {};
 
 template<>
-struct AutoConversion<char>
-{
-	static std::string conversion(const char)
-	{
-		return "c";
-	}
-};
+struct AutoConversion<char> : SimpleAutoConversion<'c', const char> {};
 
 namespace detail
 {
diff --git a/main.cpp b/main.cpp
index 7a0ccd0..d7fb862 100644
--- a/main.cpp
+++ b/main.cpp
@@ -28,29 +28,17 @@ struct format::FormatConvert<std::string, T[N], std::enable_if_t<!std::is_same_v
 template<size_t N, typename T>
 struct format::FormatConvert<std::string, std::array<T, N>>
 {
-	static std::string convert(const std::array<T, N>& from)
+	static std::string convert(const std::array<T, N> &from)
 	{
 		return format::FormatConvert<std::string, T[N]>::convert(from.data());
 	}
 };
 
 template<size_t N, typename T>
-struct format::AutoConversion<std::array<T, N>>
-{
-	static std::string conversion(const std::array<T, N>&)
-	{
-		return "s";
-	}
-};
+struct format::AutoConversion<std::array<T, N>> : format::SimpleAutoConversion<'s', const std::array<T, N> &> {};
 
 template<size_t N, typename T>
-struct format::AutoConversion<T[N], std::enable_if_t<!std::is_same_v<format::detail::remove_cvref_t<T>, char>>>
-{
-	static std::string conversion(const T(&)[N])
-	{
-		return "s";
-	}
-};
+struct format::AutoConversion<T[N], std::enable_if_t<!std::is_same_v<format::detail::remove_cvref_t<T>, char>>> : format::SimpleAutoConversion<'s', const T(&)[N]> {};
 
 int main(int argc, char *argv[])
 {
-- 
cgit v1.2.3-54-g00ecf