ceph/src/boost/libs/callable_traits/test/is_lvalue_reference_member.cpp

   1 /*
   2 Copyright Barrett Adair 2016-2017
   3 Distributed under the Boost Software License, Version 1.0.
   4 (See accompanying file LICENSE.md or copy at http ://boost.org/LICENSE_1_0.txt)
   5 */
   6
   7 #include <type_traits>
   8 #include <functional>
   9 #include <utility>
  10 #include <boost/callable_traits/is_lvalue_reference_member.hpp>
  11 #include "test.hpp"
  12
  13
  14 #ifdef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS
  15 int main(){ return 0; }
  16 #else
  17
  18 struct foo {};
  19
  20 template<typename T>
  21 void assert_lvalue_qualified() {
  22
  23     CT_ASSERT( is_lvalue_reference_member<T>());
  24 }
  25
  26
  27 template<typename T>
  28 void assert_not_lvalue_qualified() {
  29
  30     CT_ASSERT(! is_lvalue_reference_member<T>());
  31 }
  32
  33 int main() {
  34
  35     {
  36         using f   = void(foo::*)();
  37         using l   = void(foo::*)() &;
  38         using r   = void(foo::*)() && ;
  39         using c   = void(foo::*)() const;
  40         using cl  = void(foo::*)() const &;
  41         using cr  = void(foo::*)() const &&;
  42         using v   = void(foo::*)() volatile;
  43         using vl  = void(foo::*)() volatile &;
  44         using vr  = void(foo::*)() volatile &&;
  45         using cv  = void(foo::*)() const volatile;
  46         using cvl = void(foo::*)() const volatile &;
  47         using cvr = void(foo::*)() const volatile &&;
  48
  49         assert_not_lvalue_qualified<f>();
  50         assert_lvalue_qualified<l>();
  51         assert_not_lvalue_qualified<r>();
  52         assert_not_lvalue_qualified<c>();
  53         assert_lvalue_qualified<cl>();
  54         assert_not_lvalue_qualified<cr>();
  55         assert_not_lvalue_qualified<v>();
  56         assert_lvalue_qualified<vl>();
  57         assert_not_lvalue_qualified<vr>();
  58         assert_not_lvalue_qualified<cv>();
  59         assert_lvalue_qualified<cvl>();
  60         assert_not_lvalue_qualified<cvr>();
  61     }
  62
  63     {
  64         struct f   { int operator()() { return 0; } };
  65         struct l   { int operator()() & { return 0; } };
  66         struct r   { int operator()() && { return 0; } };
  67         struct c   { int operator()() const { return 0; } };
  68         struct cl  { int operator()() const & { return 0; } };
  69         struct cr  { int operator()() const && { return 0; } };
  70         struct v   { int operator()() volatile { return 0; } };
  71         struct vl  { int operator()() volatile & { return 0; } };
  72         struct vr  { int operator()() volatile && { return 0; } };
  73         struct cv  { int operator()() const volatile { return 0; } };
  74         struct cvl { int operator()() const volatile & { return 0; } };
  75         struct cvr { int operator()() const volatile && { return 0; } };
  76
  77         assert_not_lvalue_qualified<f>();
  78         assert_lvalue_qualified<l>();
  79         assert_not_lvalue_qualified<r>();
  80         assert_not_lvalue_qualified<c>();
  81         assert_lvalue_qualified<cl>();
  82         assert_not_lvalue_qualified<cr>();
  83         assert_not_lvalue_qualified<v>();
  84         assert_lvalue_qualified<vl>();
  85         assert_not_lvalue_qualified<vr>();
  86         assert_not_lvalue_qualified<cv>();
  87         assert_lvalue_qualified<cvl>();
  88         assert_not_lvalue_qualified<cvr>();
  89     }
  90
  91     {
  92         using f   = void();
  93         using l   = void() &;
  94         using r   = void() && ;
  95         using c   = void() const;
  96         using cl  = void() const &;
  97         using cr  = void() const &&;
  98         using v   = void() volatile;
  99         using vl  = void() volatile &;
 100         using vr  = void() volatile &&;
 101         using cv  = void() const volatile;
 102         using cvl = void() const volatile &;
 103         using cvr = void() const volatile &&;
 104
 105         CT_ASSERT(! is_lvalue_reference_member<f>());
 106         CT_ASSERT( is_lvalue_reference_member<l>());
 107         CT_ASSERT(! is_lvalue_reference_member<r>());
 108         CT_ASSERT(! is_lvalue_reference_member<c>());
 109         CT_ASSERT( is_lvalue_reference_member<cl>());
 110         CT_ASSERT(! is_lvalue_reference_member<cr>());
 111         CT_ASSERT(! is_lvalue_reference_member<v>());
 112         CT_ASSERT( is_lvalue_reference_member<vl>());
 113         CT_ASSERT(! is_lvalue_reference_member<vr>());
 114         CT_ASSERT(! is_lvalue_reference_member<cv>());
 115         CT_ASSERT( is_lvalue_reference_member<cvl>());
 116         CT_ASSERT(! is_lvalue_reference_member<cvr>());
 117     }
 118
 119     using f_ptr = void(*)();
 120     assert_not_lvalue_qualified<f_ptr>();
 121     assert_not_lvalue_qualified<f_ptr foo::*>();
 122     assert_not_lvalue_qualified<int foo::*>();
 123     assert_not_lvalue_qualified<void(&)()>();
 124 }
 125
 126 #endif //#ifdef BOOST_CLBL_TRTS_DISABLE_REFERENCE_QUALIFIERS