ceph/src/boost/libs/yap/test/value.cpp

   1 // Copyright (C) 2016-2018 T. Zachary Laine
   2 //
   3 // Distributed under the Boost Software License, Version 1.0. (See
   4 // accompanying file LICENSE_1_0.txt or copy at
   5 // http://www.boost.org/LICENSE_1_0.txt)
   6 #include <boost/yap/expression.hpp>
   7
   8 #include <boost/mpl/assert.hpp>
   9
  10 #include <boost/test/minimal.hpp>
  11
  12
  13 template<typename T>
  14 using term = boost::yap::terminal<boost::yap::expression, T>;
  15
  16 template<typename T>
  17 using ref = boost::yap::expression_ref<boost::yap::expression, T>;
  18
  19 namespace yap = boost::yap;
  20 namespace bh = boost::hana;
  21
  22
  23 template<boost::yap::expr_kind Kind, typename Tuple>
  24 struct user_expr
  25 {
  26     static boost::yap::expr_kind const kind = Kind;
  27
  28     Tuple elements;
  29 };
  30
  31 BOOST_YAP_USER_BINARY_OPERATOR(plus, user_expr, user_expr)
  32
  33 template<typename T>
  34 using user_term = boost::yap::terminal<user_expr, T>;
  35
  36 template<typename T>
  37 using user_ref = boost::yap::expression_ref<user_expr, T>;
  38
  39
  40 int test_main(int, char * [])
  41 {
  42     {
  43         {
  44             BOOST_MPL_ASSERT((std::is_same<decltype(yap::value(1.0)), double &&>));
  45             BOOST_CHECK(yap::value(1.0) == 1.0);
  46         }
  47
  48         {
  49             double d = 2.0;
  50             BOOST_MPL_ASSERT((std::is_same<decltype(yap::value(d)), double &>));
  51             BOOST_CHECK(yap::value(d) == 2.0);
  52         }
  53
  54         {
  55             double const d = 3.0;
  56             BOOST_MPL_ASSERT(
  57                 (std::is_same<decltype(yap::value(d)), double const &>));
  58             BOOST_CHECK(yap::value(d) == 3.0);
  59         }
  60     }
  61
  62     {
  63         {
  64             term<double> td = {{1.0}};
  65             BOOST_MPL_ASSERT(
  66                 (std::is_same<decltype(yap::value(std::move(td))), double &&>));
  67             BOOST_CHECK(yap::value(std::move(td)) == 1.0);
  68         }
  69
  70         {
  71             term<double> td = {{2.0}};
  72             BOOST_MPL_ASSERT((std::is_same<decltype(yap::value(td)), double &>));
  73             BOOST_CHECK(yap::value(td) == 2.0);
  74         }
  75
  76         {
  77             term<double> const td = {{3.0}};
  78             BOOST_MPL_ASSERT(
  79                 (std::is_same<decltype(yap::value(td)), double const &>));
  80             BOOST_CHECK(yap::value(td) == 3.0);
  81         }
  82
  83         term<double> unity = {{1.0}};
  84         using plus_expr_type = yap::expression<
  85             yap::expr_kind::plus,
  86             bh::tuple<ref<term<double> &>, term<int>>>;
  87         plus_expr_type plus_expr = unity + term<int>{{1}};
  88
  89         {
  90             ref<term<double> &> ref = bh::front(plus_expr.elements);
  91             BOOST_MPL_ASSERT(
  92                 (std::is_same<decltype(yap::value(std::move(ref))), double &>));
  93         }
  94
  95         {
  96             ref<term<double> &> ref = bh::front(plus_expr.elements);
  97             BOOST_MPL_ASSERT((std::is_same<decltype(yap::value(ref)), double &>));
  98         }
  99
 100         {
 101             ref<term<double> &> const ref = bh::front(plus_expr.elements);
 102             BOOST_MPL_ASSERT((std::is_same<decltype(yap::value(ref)), double &>));
 103         }
 104
 105         {
 106             term<double> const unity = {{1.0}};
 107             yap::expression<
 108                 yap::expr_kind::plus,
 109                 bh::tuple<ref<term<double> const &>, term<int>>>
 110                 plus_expr = unity + term<int>{{1}};
 111
 112             {
 113                 ref<term<double> const &> ref = bh::front(plus_expr.elements);
 114                 BOOST_MPL_ASSERT((std::is_same<
 115                                   decltype(yap::value(std::move(ref))),
 116                                   double const &>));
 117             }
 118
 119             {
 120                 ref<term<double> const &> ref = bh::front(plus_expr.elements);
 121                 BOOST_MPL_ASSERT(
 122                     (std::is_same<decltype(yap::value(ref)), double const &>));
 123             }
 124
 125             {
 126                 ref<term<double> const &> const ref = bh::front(plus_expr.elements);
 127                 BOOST_MPL_ASSERT(
 128                     (std::is_same<decltype(yap::value(ref)), double const &>));
 129             }
 130         }
 131     }
 132
 133     {
 134         {
 135             user_term<double> td = {{1.0}};
 136             BOOST_MPL_ASSERT(
 137                 (std::is_same<decltype(yap::value(std::move(td))), double &&>));
 138             BOOST_CHECK(yap::value(std::move(td)) == 1.0);
 139         }
 140
 141         {
 142             user_term<double> td = {{2.0}};
 143             BOOST_MPL_ASSERT((std::is_same<decltype(yap::value(td)), double &>));
 144             BOOST_CHECK(yap::value(td) == 2.0);
 145         }
 146
 147         {
 148             user_term<double> const td = {{3.0}};
 149             BOOST_MPL_ASSERT(
 150                 (std::is_same<decltype(yap::value(td)), double const &>));
 151             BOOST_CHECK(yap::value(td) == 3.0);
 152         }
 153
 154         user_term<double> unity = {{1.0}};
 155         using plus_expr_type = user_expr<
 156             yap::expr_kind::plus,
 157             bh::tuple<user_ref<user_term<double> &>, user_term<int>>>;
 158         plus_expr_type plus_expr = unity + user_term<int>{{1}};
 159
 160         {
 161             user_ref<user_term<double> &> ref = bh::front(plus_expr.elements);
 162             BOOST_MPL_ASSERT(
 163                 (std::is_same<decltype(yap::value(std::move(ref))), double &>));
 164         }
 165
 166         {
 167             user_ref<user_term<double> &> ref = bh::front(plus_expr.elements);
 168             BOOST_MPL_ASSERT((std::is_same<decltype(yap::value(ref)), double &>));
 169         }
 170
 171         {
 172             user_ref<user_term<double> &> const ref = bh::front(plus_expr.elements);
 173             BOOST_MPL_ASSERT((std::is_same<decltype(yap::value(ref)), double &>));
 174         }
 175
 176         {
 177             user_term<double> const unity = {{1.0}};
 178             user_expr<
 179                 yap::expr_kind::plus,
 180                 bh::tuple<user_ref<user_term<double> const &>, user_term<int>>>
 181                 plus_expr = unity + user_term<int>{{1}};
 182
 183             {
 184                 user_ref<user_term<double> const &> ref =
 185                     bh::front(plus_expr.elements);
 186                 BOOST_MPL_ASSERT((std::is_same<
 187                                   decltype(yap::value(std::move(ref))),
 188                                   double const &>));
 189             }
 190
 191             {
 192                 user_ref<user_term<double> const &> ref =
 193                     bh::front(plus_expr.elements);
 194                 BOOST_MPL_ASSERT(
 195                     (std::is_same<decltype(yap::value(ref)), double const &>));
 196             }
 197
 198             {
 199                 user_ref<user_term<double> const &> const ref =
 200                     bh::front(plus_expr.elements);
 201                 BOOST_MPL_ASSERT(
 202                     (std::is_same<decltype(yap::value(ref)), double const &>));
 203             }
 204         }
 205     }
 206
 207     return 0;
 208 }