ceph/src/boost/libs/hof/test/reveal.cpp

   1 /*=============================================================================
   2     Copyright (c) 2017 Paul Fultz II
   3     reveal.cpp
   4     Distributed under the Boost Software License, Version 1.0. (See accompanying
   5     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 ==============================================================================*/
   7 #include "test.hpp"
   8 #include <boost/hof/reveal.hpp>
   9 #include <boost/hof/first_of.hpp>
  10 #include <boost/hof/static.hpp>
  11 #include <boost/hof/lambda.hpp>
  12 #include <boost/hof/fix.hpp>
  13
  14 namespace reveal_test {
  15
  16 #define CONDITIONAL_FUNCTION(n) \
  17 struct t ## n {}; \
  18 struct f ## n \
  19 { \
  20     constexpr int operator()(t ## n) const \
  21     { \
  22         return n; \
  23     } \
  24 };
  25
  26 CONDITIONAL_FUNCTION(1)
  27 CONDITIONAL_FUNCTION(2)
  28 CONDITIONAL_FUNCTION(3)
  29
  30 typedef boost::hof::first_of_adaptor<f1, f2, f3> f_type;
  31 static constexpr boost::hof::static_<f_type> f = {};
  32
  33 BOOST_HOF_TEST_CASE()
  34 {
  35     BOOST_HOF_TEST_CHECK(boost::hof::reveal(f)(t1()) == 1);
  36     BOOST_HOF_TEST_CHECK(boost::hof::reveal(f)(t2()) == 2);
  37     BOOST_HOF_TEST_CHECK(boost::hof::reveal(f)(t3()) == 3);
  38
  39
  40     static_assert(boost::hof::is_invocable<boost::hof::reveal_adaptor<f_type>, t1>::value, "Invocable");
  41     static_assert(boost::hof::is_invocable<boost::hof::reveal_adaptor<f_type>, t2>::value, "Invocable");
  42     static_assert(boost::hof::is_invocable<boost::hof::reveal_adaptor<f_type>, t3>::value, "Invocable");
  43
  44     static_assert(!boost::hof::is_invocable<boost::hof::reveal_adaptor<f_type>, int>::value, "Invocable");
  45     // boost::hof::reveal(f)(1);
  46 }
  47
  48 #ifndef _MSC_VER
  49 static constexpr auto lam = boost::hof::first_of(
  50     BOOST_HOF_STATIC_LAMBDA(t1)
  51     {
  52         return 1;
  53     },
  54     BOOST_HOF_STATIC_LAMBDA(t2)
  55     {
  56         return 2;
  57     },
  58     BOOST_HOF_STATIC_LAMBDA(t3)
  59     {
  60         return 3;
  61     }
  62 );
  63
  64 BOOST_HOF_TEST_CASE()
  65 {
  66     STATIC_ASSERT_EMPTY(lam);
  67     STATIC_ASSERT_EMPTY(boost::hof::reveal(lam));
  68     BOOST_HOF_TEST_CHECK(boost::hof::reveal(lam)(t1()) == 1);
  69     BOOST_HOF_TEST_CHECK(boost::hof::reveal(lam)(t2()) == 2);
  70     BOOST_HOF_TEST_CHECK(boost::hof::reveal(lam)(t3()) == 3);
  71
  72     // boost::hof::reveal(lam)(1);
  73     // lam(1);
  74 }
  75 #endif
  76
  77 BOOST_HOF_STATIC_LAMBDA_FUNCTION(static_fun) = boost::hof::first_of(
  78     [](t1)
  79     {
  80         return 1;
  81     },
  82     [](t2)
  83     {
  84         return 2;
  85     },
  86     [](t3)
  87     {
  88         return 3;
  89     }
  90 );
  91
  92 BOOST_HOF_TEST_CASE()
  93 {
  94 #ifndef _MSC_VER
  95     STATIC_ASSERT_EMPTY(static_fun);
  96     // STATIC_ASSERT_EMPTY(boost::hof::reveal(static_fun));
  97 #endif
  98     BOOST_HOF_TEST_CHECK(boost::hof::reveal(static_fun)(t1()) == 1);
  99     BOOST_HOF_TEST_CHECK(boost::hof::reveal(static_fun)(t2()) == 2);
 100     BOOST_HOF_TEST_CHECK(boost::hof::reveal(static_fun)(t3()) == 3);
 101
 102     BOOST_HOF_TEST_CHECK(static_fun(t1()) == 1);
 103     BOOST_HOF_TEST_CHECK(static_fun(t2()) == 2);
 104     BOOST_HOF_TEST_CHECK(static_fun(t3()) == 3);
 105
 106     // boost::hof::reveal(static_fun)(1);
 107 }
 108
 109 struct integral_type
 110 {
 111     template<class T>
 112     BOOST_HOF_USING_TYPENAME(failure_alias, std::enable_if<std::is_integral<T>::value>::type);
 113
 114     struct failure
 115     : boost::hof::as_failure<failure_alias>
 116     {};
 117
 118     template<class T, class=typename std::enable_if<std::is_integral<T>::value>::type>
 119     constexpr T operator()(T x) const
 120     {
 121         return x;
 122     }
 123 };
 124 struct foo {};
 125 struct dont_catch {};
 126
 127 struct catch_all
 128 {
 129     template<class T>
 130     BOOST_HOF_USING_TYPENAME(failure_alias, std::enable_if<!std::is_same<T, dont_catch>::value>::type);
 131
 132     struct failure
 133     : boost::hof::as_failure<failure_alias>
 134     {};
 135
 136     template<class T, class=typename std::enable_if<!std::is_same<T, dont_catch>::value>::type>
 137     constexpr int operator()(T) const
 138     {
 139         return -1;
 140     }
 141 };
 142
 143 static constexpr boost::hof::reveal_adaptor<boost::hof::first_of_adaptor<integral_type, catch_all>> check_failure = {};
 144
 145
 146 BOOST_HOF_TEST_CASE()
 147 {
 148     BOOST_HOF_TEST_CHECK(check_failure(5) == 5);
 149     BOOST_HOF_TEST_CHECK(check_failure(foo()) == -1);
 150
 151     static_assert(!boost::hof::is_invocable<decltype(check_failure), dont_catch>::value, "Invocable");
 152     static_assert(!boost::hof::is_invocable<decltype(check_failure), int, int>::value, "Invocable");
 153
 154     // check_failure(dont_catch());
 155 }
 156
 157 }