From d36ab3e517c28a46bce8ea137c7622292661790d Mon Sep 17 00:00:00 2001
From: badair <badair@harding.edu>
Date: Wed, 30 Mar 2016 00:58:29 -0500
Subject: [PATCH] adding common_signature

---
 include/callable_traits/config.hpp            |   1 +
 include/callable_traits/detail/at.hpp         |  38 ++++++
 include/callable_traits/detail/best_match.hpp |  12 +-
 .../detail/bind_expression_parser.hpp         |  11 +-
 .../callable_traits/detail/build_function.hpp |  30 +++++
 .../detail/common_signature_t.hpp             | 120 ++++++++++++++++++
 include/callable_traits/detail/traits.hpp     |   5 +-
 include/callable_traits/interface.hpp         |  10 ++
 ...ak_common_type.cpp => best_match_bind.cpp} |   0
 test/can_invoke_constexpr.cpp                 |   7 +
 test/common_signature.cpp                     |  75 +++++++++++
 test/detail/make_constexpr.cpp                |  12 ++
 test/is_constexpr.cpp                         |   7 +
 13 files changed, 312 insertions(+), 16 deletions(-)
 create mode 100644 include/callable_traits/detail/at.hpp
 create mode 100644 include/callable_traits/detail/build_function.hpp
 create mode 100644 include/callable_traits/detail/common_signature_t.hpp
 rename test/{weak_common_type.cpp => best_match_bind.cpp} (100%)
 create mode 100644 test/common_signature.cpp

diff --git a/include/callable_traits/config.hpp b/include/callable_traits/config.hpp
index b97d745..d78fe24 100644
--- a/include/callable_traits/config.hpp
+++ b/include/callable_traits/config.hpp
@@ -20,6 +20,7 @@ Distributed under the Boost Software License, Version 1.0.
 #undef CALLABLE_TRAITS_VARARGS_CC
 #define CALLABLE_TRAITS_VARARGS_CC __cdecl
 #define CALLABLE_TRAITS_CONSTEXPR_CHECKS_DISABLED
+#define CALLABLE_TRAITS_MSVC
 #endif //ifndef __clang__
 #endif //_MSC_VER
 
diff --git a/include/callable_traits/detail/at.hpp b/include/callable_traits/detail/at.hpp
new file mode 100644
index 0000000..572706a
--- /dev/null
+++ b/include/callable_traits/detail/at.hpp
@@ -0,0 +1,38 @@
+/*!
+Copyright (c) 2016 Barrett Adair
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef CALLABLE_TRAITS_DETAIL_AT_HPP
+#define CALLABLE_TRAITS_DETAIL_AT_HPP
+
+#include <callable_traits/detail/disjunction.hpp>
+#include <tuple>
+#include <functional>
+
+namespace callable_traits {
+    
+    namespace detail {
+
+        template<std::size_t I, typename Tup>
+        using at = typename std::tuple_element<I, Tup>::type;
+
+        template<std::size_t I, typename Tup, typename = std::true_type>
+        struct weak_at_t {
+            using type = at<I, Tup>;
+        };
+
+        template<std::size_t I, typename Tup>
+        struct weak_at_t<I, Tup, std::integral_constant<bool, I >= std::tuple_size<Tup>::value>>{
+            using type = invalid_type;
+        };
+
+        template<std::size_t I, typename Tup>
+        using weak_at = typename weak_at_t<I, Tup>::type;
+
+    }
+}
+
+#endif
diff --git a/include/callable_traits/detail/best_match.hpp b/include/callable_traits/detail/best_match.hpp
index ee52367..75beff6 100644
--- a/include/callable_traits/detail/best_match.hpp
+++ b/include/callable_traits/detail/best_match.hpp
@@ -108,14 +108,16 @@ namespace callable_traits {
         };
 
         template<typename... Ts>
-        using sorted_cartesian_product_of_conversions = tuple_sort<
-            std::tuple<map_conversions<Ts, Ts...>...>,
-            conversion_result_sort_predicate
-        >;
+        struct sorted_cartesian_product_of_conversions {
+            using type = tuple_sort<
+                std::tuple<map_conversions<Ts, Ts...>...>,
+                conversion_result_sort_predicate
+            >;
+        };
 
         template<typename... Ts>
         using best_conversion_result =
-            typename std::tuple_element<0, sorted_cartesian_product_of_conversions<Ts...>>::type;
+            typename std::tuple_element<0, typename sorted_cartesian_product_of_conversions<Ts...>::type>::type;
 
         template<typename... Ts>
         using best_match = typename best_conversion_result<Ts...>::key;
diff --git a/include/callable_traits/detail/bind_expression_parser.hpp b/include/callable_traits/detail/bind_expression_parser.hpp
index 2095a81..0e934a4 100644
--- a/include/callable_traits/detail/bind_expression_parser.hpp
+++ b/include/callable_traits/detail/bind_expression_parser.hpp
@@ -15,6 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <callable_traits/detail/fwd/bind_expression_parser_fwd.hpp>
 #include <callable_traits/detail/best_match.hpp>
 #include <callable_traits/detail/prepend.hpp>
+#include <callable_traits/detail/build_function.hpp>
 #include <tuple>
 #include <functional>
 
@@ -111,14 +112,6 @@ namespace callable_traits {
             using type = std::tuple<>;
         };
 
-        template<typename...>
-        struct build_function {};
-
-        template<typename Return, typename... Args>
-        struct build_function<Return, std::tuple<Args...>>{
-            using type = Return(Args...);
-        };
-
         template<typename T>
         struct bind_expression_parser
         {
@@ -150,7 +143,7 @@ namespace callable_traits {
 
             using arg_types = typename common_expected_arg_types<grouped_placeholders>::type;
             using return_type = typename root_expression::return_type;
-            using function_type = typename build_function<return_type, arg_types>::type;
+            using function_type = build_function<return_type, arg_types>;
             using abominable_type = function_type;
         };
     }
diff --git a/include/callable_traits/detail/build_function.hpp b/include/callable_traits/detail/build_function.hpp
new file mode 100644
index 0000000..e1b2ac5
--- /dev/null
+++ b/include/callable_traits/detail/build_function.hpp
@@ -0,0 +1,30 @@
+/*!
+Copyright (c) 2016 Barrett Adair
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef CALLABLE_TRAITS_DETAIL_BUILD_FUNCTION_HPP
+#define CALLABLE_TRAITS_DETAIL_BUILD_FUNCTION_HPP
+
+#include <tuple>
+
+namespace callable_traits {
+    
+    namespace detail {
+
+        template<typename...>
+        struct build_function_t;
+
+        template<typename Return, typename... Args>
+        struct build_function_t<Return, std::tuple<Args...>>{
+            using type = Return(Args...);
+        };
+
+        template<typename Ret, typename Tup>
+        using build_function = typename build_function_t<Ret, Tup>::type;
+    }
+}
+
+#endif
diff --git a/include/callable_traits/detail/common_signature_t.hpp b/include/callable_traits/detail/common_signature_t.hpp
new file mode 100644
index 0000000..4b19ed5
--- /dev/null
+++ b/include/callable_traits/detail/common_signature_t.hpp
@@ -0,0 +1,120 @@
+/*!
+Copyright (c) 2016 Barrett Adair
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef CALLABLE_TRAITS_DETAIL_COMMON_SIGNATURE_T_HPP
+#define CALLABLE_TRAITS_DETAIL_COMMON_SIGNATURE_T_HPP
+
+#include <callable_traits/detail/traits.hpp>
+#include <callable_traits/detail/tuple_group_by.hpp>
+#include <callable_traits/detail/tuple_sort.hpp>
+#include <callable_traits/detail/bind_expression.hpp>
+#include <callable_traits/detail/fwd/bind_expression_parser_fwd.hpp>
+#include <callable_traits/detail/best_match.hpp>
+#include <callable_traits/detail/prepend.hpp>
+#include <callable_traits/detail/at.hpp>
+#include <callable_traits/detail/build_function.hpp>
+#include <tuple>
+#include <functional>
+
+namespace callable_traits {
+    
+    namespace detail {
+
+        template<typename Tup, typename Seq>
+        struct reverse_impl;
+
+        template<typename Tup, size_t... I>
+        struct reverse_impl<Tup, std::index_sequence<I...>> {
+            using type = std::tuple<at<sizeof...(I) - 1 - I, Tup>...>;
+        };
+
+        template<typename Tup>
+        using reverse = typename reverse_impl<Tup,
+                std::make_index_sequence<std::tuple_size<Tup>::value>>::type;
+
+        template<typename Tup, std::size_t EndSize>
+        struct trim_left;
+
+        template<typename Arg, std::size_t EndSize>
+        struct trim_left<std::tuple<Arg>, EndSize> {
+            using type = typename std::conditional<
+                EndSize == 1,
+                std::tuple<Arg>,
+                std::tuple<>
+            >::type;
+        };
+
+        template<std::size_t EndSize>
+        struct trim_left<std::tuple<>, EndSize> {
+            using type = std::tuple<>;
+        };
+
+        template<typename Front, typename... Args, std::size_t EndSize>
+        struct trim_left<std::tuple<Front, Args...>, EndSize> {
+
+            using type = typename std::conditional<
+                EndSize == sizeof...(Args) + 1,
+                std::tuple<Front, Args...>,
+                typename trim_left<std::tuple<Args...>, EndSize>::type
+            >::type;
+        };
+
+        template<typename Tup, std::size_t EndSize>
+        struct trim_right {
+            using reversed = reverse<Tup>;
+            using type = reverse<typename trim_left<reversed, EndSize>::type>;
+        };
+
+        template<typename Tup, std::size_t I, typename Seq>
+        struct best_match_cross_section;
+
+        template<typename Tup, std::size_t I, std::size_t... J>
+        struct best_match_cross_section<Tup, I, std::index_sequence<J...>>{
+            using type = best_match<weak_at<I, weak_at<J, Tup>>...>;
+        };
+
+        template<typename ArgsTuplesTuple, typename Seq>
+        struct common_args;
+
+        template<typename Tup, std::size_t... I>
+        struct common_args<Tup, std::index_sequence<I...>> {
+            using seq = std::index_sequence<I...>;
+            using type = std::tuple<typename best_match_cross_section<Tup, I, seq>::type...>;
+        };
+
+        template<typename TraitsTup, typename Seq>
+        struct common_signature_t;
+
+        template<typename TraitsTup, std::size_t... I>
+        struct common_signature_t<TraitsTup, std::index_sequence<I...>> {
+
+            using common_return = typename std::common_type<
+                typename at<I, TraitsTup>::return_type...
+            >::type;
+
+            using args_tuples = std::tuple<
+                typename at<I, TraitsTup>::arg_types...
+            >;
+
+            using first_args = at<0, args_tuples>;
+
+            using arg_count = std::tuple_size<first_args>;
+
+            using seq = std::make_index_sequence<
+                arg_count::value <= sizeof...(I) ? sizeof...(I) : arg_count::value
+            >;
+
+            using common_arg_types = typename common_args<args_tuples, seq>::type;
+            using trimmed_arg_types = typename trim_right<
+                common_arg_types, arg_count::value>::type;
+
+            using type = build_function<common_return, trimmed_arg_types>;
+        };
+    }
+}
+
+#endif
diff --git a/include/callable_traits/detail/traits.hpp b/include/callable_traits/detail/traits.hpp
index 00148a0..0fd92e8 100644
--- a/include/callable_traits/detail/traits.hpp
+++ b/include/callable_traits/detail/traits.hpp
@@ -26,9 +26,10 @@ namespace callable_traits {
 
     namespace detail {
 
-        template<typename T, typename U = typename std::remove_reference<T>::type>
+        template<typename T>
         using decay_if_ptr_or_integral_constant = typename std::conditional<
-            std::is_pointer<U>::value || is_integral_constant<T>::value,
+            std::is_pointer<typename std::remove_reference<T>::type>::value
+                || is_integral_constant<T>::value,
             shallow_decay<T>,
             T
         >::type;
diff --git a/include/callable_traits/interface.hpp b/include/callable_traits/interface.hpp
index a9e92ad..fcdea8c 100644
--- a/include/callable_traits/interface.hpp
+++ b/include/callable_traits/interface.hpp
@@ -22,6 +22,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <callable_traits/detail/shallow_decay.hpp>
 #include <callable_traits/detail/disjunction.hpp>
 #include <callable_traits/detail/is_constexpr_t.hpp>
+#include <callable_traits/detail/common_signature_t.hpp>
 #include <type_traits>
 #include <utility>
 
@@ -44,6 +45,12 @@ namespace callable_traits {
         template<typename T>
         using qualified_signature = typename detail::traits<T>::abominable_type;
 
+        template<typename... Ts>
+        using common_signature = typename detail::common_signature_t<
+            std::tuple<detail::traits<Ts>...>,
+            std::make_index_sequence<sizeof...(Ts)>
+        >::type;
+
         template<typename T>
         using result_of = typename detail::traits<T>::return_type;
 
@@ -114,6 +121,9 @@ namespace callable_traits {
     template<typename T>
     using qualified_signature = detail::if_valid<no_sfinae::qualified_signature<T>>;
 
+    template<typename... Ts>
+    using common_signature = no_sfinae::common_signature<Ts...>;
+
     template<typename T>
     using result_of = detail::if_valid<no_sfinae::result_of<T>>;
 
diff --git a/test/weak_common_type.cpp b/test/best_match_bind.cpp
similarity index 100%
rename from test/weak_common_type.cpp
rename to test/best_match_bind.cpp
diff --git a/test/can_invoke_constexpr.cpp b/test/can_invoke_constexpr.cpp
index 3dab55a..58c8473 100644
--- a/test/can_invoke_constexpr.cpp
+++ b/test/can_invoke_constexpr.cpp
@@ -1,3 +1,10 @@
+/*!
+Copyright (c) 2016 Barrett Adair
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
 #include <type_traits>
 #include <callable_traits/callable_traits.hpp>
 
diff --git a/test/common_signature.cpp b/test/common_signature.cpp
new file mode 100644
index 0000000..cc42bff
--- /dev/null
+++ b/test/common_signature.cpp
@@ -0,0 +1,75 @@
+/*!
+Copyright (c) 2016 Barrett Adair
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
+#include <type_traits>
+#include <callable_traits/callable_traits.hpp>
+
+#ifndef CT_ASSERT
+#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+#endif //CT_ASSERT
+
+namespace ct = callable_traits;
+
+//ct::common_signature makes MSVC crash :(
+#ifndef CALLABLE_TRAITS_MSVC
+
+namespace test1 {
+
+    using test = ct::common_signature<
+        char(int),
+        short(int&&),
+        int(const int&)
+    >;
+
+    using expect = int(int);
+
+    CT_ASSERT(std::is_same<test, expect>::value);
+}
+
+namespace test2 {
+
+    using test = ct::common_signature<
+        char(),
+        int()
+    >;
+
+    using expect = int();
+
+    CT_ASSERT(std::is_same<test, expect>::value);
+}
+
+namespace test3 {
+
+    struct Vampire {};
+    struct Robot {};
+    struct Animal {};
+    struct Dog : Animal {};
+    struct Poodle : Dog {};
+    struct VampireRobotPoodle : Poodle, Robot, Vampire {};
+
+    using test = ct::common_signature<
+        Dog(VampireRobotPoodle, Vampire, Robot, Dog, Animal),
+        Poodle(Vampire, VampireRobotPoodle, Robot, Dog, Animal),
+        Poodle(Vampire, Robot, VampireRobotPoodle, Dog, Animal),
+        VampireRobotPoodle(Vampire, Robot, Dog, VampireRobotPoodle, Animal),
+        Animal(Vampire, Robot, Dog, Animal, VampireRobotPoodle)
+    >;
+
+    using expect = Animal(
+        VampireRobotPoodle,
+        VampireRobotPoodle,
+        VampireRobotPoodle,
+        VampireRobotPoodle,
+        VampireRobotPoodle
+    );
+
+    CT_ASSERT(std::is_same<test, expect>::value);
+}
+
+#endif
+
+int main() { return 0; }
diff --git a/test/detail/make_constexpr.cpp b/test/detail/make_constexpr.cpp
index 4c1c082..eeddba8 100644
--- a/test/detail/make_constexpr.cpp
+++ b/test/detail/make_constexpr.cpp
@@ -1,9 +1,19 @@
+/*!
+Copyright (c) 2016 Barrett Adair
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
+#include <callable_traits/config.hpp>
 #include <callable_traits/detail/make_constexpr.hpp>
 
 #ifndef CT_ASSERT
 #define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
 #endif //CT_ASSERT
 
+#ifndef CALLABLE_TRAITS_CONSTEXPR_CHECKS_DISABLED
+
 struct foo {
 
     constexpr int operator()(int&) & {
@@ -84,4 +94,6 @@ CT_ASSERT(12 == CALLABLE_TRAITS_MAKE_CONSTEXPR(const foo)(CALLABLE_TRAITS_MAKE_C
 CT_ASSERT(12 == CALLABLE_TRAITS_MAKE_CONSTEXPR(const foo&&)(CALLABLE_TRAITS_MAKE_CONSTEXPR(int)));
 CT_ASSERT(12 == CALLABLE_TRAITS_MAKE_CONSTEXPR(const foo)(CALLABLE_TRAITS_MAKE_CONSTEXPR(int)));
 
+#endif
+
 int main() { return 0; }
\ No newline at end of file
diff --git a/test/is_constexpr.cpp b/test/is_constexpr.cpp
index c1235b2..cff0c36 100644
--- a/test/is_constexpr.cpp
+++ b/test/is_constexpr.cpp
@@ -1,3 +1,10 @@
+/*!
+Copyright (c) 2016 Barrett Adair
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
 #include <type_traits>
 #include <callable_traits/callable_traits.hpp>