• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
main()15 int main(){ return 0; }
16 #else
17 
18 struct foo {};
19 
20 template<typename T>
assert_lvalue_qualified()21 void assert_lvalue_qualified() {
22 
23     CT_ASSERT( is_lvalue_reference_member<T>());
24 }
25 
26 
27 template<typename T>
assert_not_lvalue_qualified()28 void assert_not_lvalue_qualified() {
29 
30     CT_ASSERT(! is_lvalue_reference_member<T>());
31 }
32 
main()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
127