ceph/src/boost/libs/yap/test/deref.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         term<double> unity = {{1.0}};
  44         using plus_expr_type = yap::expression<
  45             yap::expr_kind::plus,
  46             bh::tuple<ref<term<double> &>, term<int>>>;
  47
  48         plus_expr_type plus_expr = unity + term<int>{{1}};
  49
  50         {
  51             ref<term<double> &> ref = bh::front(plus_expr.elements);
  52             BOOST_MPL_ASSERT((std::is_same<
  53                               decltype(yap::deref(std::move(ref))),
  54                               term<double> &>));
  55             BOOST_CHECK(yap::value(ref) == 1.0);
  56         }
  57
  58         {
  59             ref<term<double> &> ref = bh::front(plus_expr.elements);
  60             BOOST_MPL_ASSERT(
  61                 (std::is_same<decltype(yap::deref(ref)), term<double> &>));
  62             BOOST_CHECK(yap::value(ref) == 1.0);
  63         }
  64
  65         {
  66             ref<term<double> &> const ref = bh::front(plus_expr.elements);
  67             BOOST_MPL_ASSERT(
  68                 (std::is_same<decltype(yap::deref(ref)), term<double> &>));
  69             BOOST_CHECK(yap::value(ref) == 1.0);
  70         }
  71
  72         {
  73             term<double> const unity = {{1.0}};
  74             yap::expression<
  75                 yap::expr_kind::plus,
  76                 bh::tuple<ref<term<double> const &>, term<int>>>
  77                 plus_expr = unity + term<int>{{1}};
  78
  79             {
  80                 ref<term<double> const &> ref = bh::front(plus_expr.elements);
  81                 BOOST_MPL_ASSERT((std::is_same<
  82                                   decltype(yap::deref(std::move(ref))),
  83                                   term<double> const &>));
  84                 BOOST_CHECK(yap::value(ref) == 1.0);
  85             }
  86
  87             {
  88                 ref<term<double> const &> ref = bh::front(plus_expr.elements);
  89                 BOOST_MPL_ASSERT((std::is_same<
  90                                   decltype(yap::deref(ref)),
  91                                   term<double> const &>));
  92                 BOOST_CHECK(yap::value(ref) == 1.0);
  93             }
  94
  95             {
  96                 ref<term<double> const &> const ref =
  97                     bh::front(plus_expr.elements);
  98                 BOOST_MPL_ASSERT((std::is_same<
  99                                   decltype(yap::deref(ref)),
 100                                   term<double> const &>));
 101                 BOOST_CHECK(yap::value(ref) == 1.0);
 102             }
 103         }
 104     }
 105
 106     {
 107         user_term<double> unity = {{1.0}};
 108         using plus_expr_type = user_expr<
 109             yap::expr_kind::plus,
 110             bh::tuple<user_ref<user_term<double> &>, user_term<int>>>;
 111
 112         plus_expr_type plus_expr = unity + user_term<int>{{1}};
 113
 114         {
 115             user_ref<user_term<double> &> ref = bh::front(plus_expr.elements);
 116             BOOST_MPL_ASSERT((std::is_same<
 117                               decltype(yap::deref(std::move(ref))),
 118                               user_term<double> &>));
 119             BOOST_CHECK(yap::value(ref) == 1.0);
 120         }
 121
 122         {
 123             user_ref<user_term<double> &> ref = bh::front(plus_expr.elements);
 124             BOOST_MPL_ASSERT(
 125                 (std::is_same<decltype(yap::deref(ref)), user_term<double> &>));
 126             BOOST_CHECK(yap::value(ref) == 1.0);
 127         }
 128
 129         {
 130             user_ref<user_term<double> &> const ref =
 131                 bh::front(plus_expr.elements);
 132             BOOST_MPL_ASSERT(
 133                 (std::is_same<decltype(yap::deref(ref)), user_term<double> &>));
 134             BOOST_CHECK(yap::value(ref) == 1.0);
 135         }
 136
 137         {
 138             user_term<double> const unity = {{1.0}};
 139             user_expr<
 140                 yap::expr_kind::plus,
 141                 bh::tuple<user_ref<user_term<double> const &>, user_term<int>>>
 142                 plus_expr = unity + user_term<int>{{1}};
 143
 144             {
 145                 user_ref<user_term<double> const &> ref =
 146                     bh::front(plus_expr.elements);
 147                 BOOST_MPL_ASSERT((std::is_same<
 148                                   decltype(yap::deref(std::move(ref))),
 149                                   user_term<double> const &>));
 150                 BOOST_CHECK(yap::value(ref) == 1.0);
 151             }
 152
 153             {
 154                 user_ref<user_term<double> const &> ref =
 155                     bh::front(plus_expr.elements);
 156                 BOOST_MPL_ASSERT((std::is_same<
 157                                   decltype(yap::deref(ref)),
 158                                   user_term<double> const &>));
 159                 BOOST_CHECK(yap::value(ref) == 1.0);
 160             }
 161
 162             {
 163                 user_ref<user_term<double> const &> const ref =
 164                     bh::front(plus_expr.elements);
 165                 BOOST_MPL_ASSERT((std::is_same<
 166                                   decltype(yap::deref(ref)),
 167                                   user_term<double> const &>));
 168                 BOOST_CHECK(yap::value(ref) == 1.0);
 169             }
 170         }
 171     }
 172
 173     return 0;
 174 }