Merge branch 'conditional' into develop

boostorg · Mar 26, 2016 · 1a9b1ec · 1a9b1ec
2 parents 5aa5211 + 4f9fd6b
commit 1a9b1ec
Show file tree

Hide file tree

Showing 5 changed files with 71 additions and 14 deletions.
diff --git a/include/fit/conditional.hpp b/include/fit/conditional.hpp
@@ -74,6 +74,7 @@
 /// to how the function is chosen.
 
 #include <fit/reveal.hpp>
+#include <fit/detail/compressed_pair.hpp>
 #include <fit/detail/callable_base.hpp>
 #include <fit/detail/delegate.hpp>
 #include <fit/detail/join.hpp>
@@ -86,22 +87,22 @@ namespace fit {
 namespace detail {
 
 template<class F1, class F2>
-struct conditional_kernel : F1, F2
+struct basic_conditional_adaptor : F1, F2
 {
-    FIT_INHERIT_DEFAULT(conditional_kernel, F1, F2)
+    FIT_INHERIT_DEFAULT(basic_conditional_adaptor, F1, F2)
 
     template<class A, class B,
         FIT_ENABLE_IF_CONVERTIBLE(A, F1),
         FIT_ENABLE_IF_CONVERTIBLE(B, F2)>
-    constexpr conditional_kernel(A&& f1, B&& f2) : F1(FIT_FORWARD(A)(f1)), F2(FIT_FORWARD(B)(f2))
+    constexpr basic_conditional_adaptor(A&& f1, B&& f2) : F1(FIT_FORWARD(A)(f1)), F2(FIT_FORWARD(B)(f2))
     {}
 
     template<class X,
         class=typename std::enable_if<
         FIT_IS_CONVERTIBLE(X, F1) && 
         FIT_IS_DEFAULT_CONSTRUCTIBLE(F2)
     >::type>
-    constexpr conditional_kernel(X&& x) : F1(FIT_FORWARD(X)(x))
+    constexpr basic_conditional_adaptor(X&& x) : F1(FIT_FORWARD(X)(x))
     {} 
 
     template<class... Ts>
@@ -114,14 +115,65 @@ struct conditional_kernel : F1, F2
     >
     {};
 
-    FIT_RETURNS_CLASS(conditional_kernel);
+    FIT_RETURNS_CLASS(basic_conditional_adaptor);
 
     template<class... Ts, class F=typename select<Ts...>::type>
     constexpr FIT_SFINAE_RESULT(typename select<Ts...>::type, id_<Ts>...) 
-    operator()(Ts && ... x) const
+    operator()(Ts && ... xs) const
+    FIT_SFINAE_RETURNS
+    (
+        FIT_RETURNS_STATIC_CAST(const F&)(*FIT_CONST_THIS)(FIT_FORWARD(Ts)(xs)...)
+    );
+};
+
+struct low_rank {};
+
+struct high_rank : low_rank {};
+
+template <class ...Ts, class F1, class F2, class = typename std::enable_if<(
+    is_callable<F1, Ts...>::value
+)>::type>
+constexpr F1&& which(high_rank, holder<Ts...>, F1&& f1, F2&&) 
+{ 
+    return FIT_FORWARD(F1)(f1); 
+}
+
+template <class ...Ts, class F1, class F2>
+constexpr F2&& which(low_rank, holder<Ts...>, F1&&, F2&& f2) 
+{ 
+    return FIT_FORWARD(F2)(f2); 
+}
+
+template<class F1, class F2>
+struct conditional_kernel : compressed_pair<F1, F2>
+{
+    typedef compressed_pair<F1, F2> base;
+    FIT_INHERIT_CONSTRUCTOR(conditional_kernel, base)
+
+    template<class... Ts>
+    struct select
+    : std::conditional
+    <
+        is_callable<F1, Ts...>::value, 
+        F1,
+        F2
+    >
+    {};
+
+    FIT_RETURNS_CLASS(conditional_kernel);
+
+    template<class... Ts>
+    constexpr FIT_SFINAE_RESULT(typename select<Ts...>::type, id_<Ts>...) 
+    operator()(Ts && ... xs) const
     FIT_SFINAE_RETURNS
     (
-        FIT_RETURNS_STATIC_CAST(const F&)(*FIT_CONST_THIS)(FIT_FORWARD(Ts)(x)...)
+        detail::which(
+            high_rank{}, 
+            holder<Ts...>{},
+            FIT_CONST_THIS->first(xs...),
+            FIT_CONST_THIS->second(xs...)
+        )
+        (FIT_FORWARD(Ts)(xs)...)
     );
 };
 }

diff --git a/include/fit/detail/compressed_pair.hpp b/include/fit/detail/compressed_pair.hpp
@@ -83,21 +83,21 @@ struct compressed_pair<First, Second>
     FIT_INHERIT_DEFAULT(compressed_pair, first_base, second_base)
 
     template<class Base, class... Xs>
-    constexpr const Base& get_base(Xs&&... xs) const
+    constexpr const Base& get_alias_base(Xs&&... xs) const
     {
         return always_ref(*this)(xs...);
     }
 
     template<class... Xs>
     constexpr const First& first(Xs&&... xs) const
     {
-        return alias_value(this->get_base<first_base>(xs...), xs...);
+        return alias_value(this->get_alias_base<first_base>(xs...), xs...);
     }
 
     template<class... Xs>
     constexpr const Second& second(Xs&&... xs) const
     {
-        return alias_value(this->get_base<second_base>(xs...), xs...);
+        return alias_value(this->get_alias_base<second_base>(xs...), xs...);
     }
 
 };

diff --git a/include/fit/partial.hpp b/include/fit/partial.hpp
@@ -176,7 +176,7 @@ struct partial_adaptor_pack
 template<class F, class Pack>
 struct partial_adaptor_base 
 {
-    typedef conditional_adaptor
+    typedef basic_conditional_adaptor
     <
         partial_adaptor_invoke<partial_adaptor<F, Pack>, F, Pack>,
         partial_adaptor_join<partial_adaptor<F, Pack>, F, Pack> 
@@ -186,7 +186,7 @@ struct partial_adaptor_base
 template<class Derived, class F>
 struct partial_adaptor_pack_base
 {
-    typedef conditional_adaptor
+    typedef basic_conditional_adaptor
     <
         F,
         partial_adaptor_pack<Derived, F> 

diff --git a/include/fit/pipable.hpp b/include/fit/pipable.hpp
@@ -154,9 +154,9 @@ constexpr auto operator|(A&& a, const pipe_closure<F, Pack>& p) FIT_RETURNS
 
 template<class F>
 struct pipable_adaptor 
-: conditional_adaptor<detail::callable_base<F>, detail::pipe_pack<pipable_adaptor<F>, detail::callable_base<F>> >
+: detail::basic_conditional_adaptor<detail::callable_base<F>, detail::pipe_pack<pipable_adaptor<F>, detail::callable_base<F>> >
 {
-    typedef conditional_adaptor<detail::callable_base<F>, detail::pipe_pack<pipable_adaptor<F>, detail::callable_base<F>> > base;
+    typedef detail::basic_conditional_adaptor<detail::callable_base<F>, detail::pipe_pack<pipable_adaptor<F>, detail::callable_base<F>> > base;
     typedef pipable_adaptor fit_rewritable_tag;
 
     FIT_INHERIT_CONSTRUCTOR(pipable_adaptor, base);

diff --git a/test/conditional.cpp b/test/conditional.cpp
@@ -114,4 +114,9 @@ FIT_TEST_CASE()
     FIT_TEST_CHECK(static_fun(t3()) == 3);
 }
 #endif
+
+FIT_TEST_CASE()
+{
+    FIT_TEST_CHECK(fit::conditional(fit::identity, fit::identity)(3) == 3);
+}
 }