1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
[/
(C) Copyright 2009-2011 Frederic Bron.
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt).
]
[section:has_bit_and has_bit_and]
template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
struct has_bit_and : public __tof {};
__inherit
If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs&rhs`,
and (ii) `Ret=dont_care` or the result of expression `lhs&rhs` is convertible to `Ret`
then inherits from __true_type,
otherwise inherits from __false_type.
The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator&`.
If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
``
void f(Ret);
Lhs lhs;
Rhs rhs;
f(lhs&rhs); // is valid if has_bit_and<Lhs, Rhs, Ret>::value==true
``
If `Ret=void`, the return type is checked to be exactly `void`.
__header `#include <boost/type_traits/has_bit_and.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
__examples
[:`has_bit_and<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
[:`has_bit_and<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
[:`has_bit_and<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
[:`has_bit_and<long>` inherits from `__true_type`.]
[:`has_bit_and<int, int, int>` inherits from `__true_type`.]
[:`has_bit_and<const int, int>` inherits from `__true_type`.]
[:`has_bit_and<int, double, bool>` inherits from `__false_type`.]
[:`has_bit_and<int, int, std::string>` inherits from `__false_type`.]
[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
[*Limitation:]
* Requires a compiler with working SFINAE.
[*Known issues:]
* This trait cannot detect whether binary `operator&` is public or not:
if `operator&` is defined as a private member of `Lhs` then
instantiating `has_bit_and<Lhs>` will produce a compiler error.
For this reason `has_bit_and` cannot be used to determine whether a type has a public `operator&` or not.
``
struct A { private: void operator&(const A&); };
boost::has_bit_and<A>::value; // error: A::operator&(const A&) is private
``
* There is an issue if the operator exists only for type `A` and `B` is
convertible to `A`. In this case, the compiler will report an ambiguous overload.
``
struct A { };
void operator&(const A&, const A&);
struct B { operator A(); };
boost::has_bit_and<A>::value; // this is fine
boost::has_bit_and<B>::value; // error: ambiguous overload
``
* There is an issue when applying this trait to template classes.
If `operator&` is defined but does not bind for a given template type,
it is still detected by the trait which returns `true` instead of `false`.
Example:
``
#include <boost/type_traits/has_bit_and.hpp>
#include <iostream>
template <class T>
struct contains { T data; };
template <class T>
bool operator&(const contains<T> &lhs, const contains<T> &rhs) {
return f(lhs.data, rhs.data);
}
class bad { };
class good { };
bool f(const good&, const good&) { }
int main() {
std::cout<<std::boolalpha;
// works fine for contains<good>
std::cout<<boost::has_bit_and< contains< good > >::value<<'\n'; // true
contains<good> g;
g&g; // ok
// does not work for contains<bad>
std::cout<<boost::has_bit_and< contains< bad > >::value<<'\n'; // true, should be false
contains<bad> b;
b&b; // compile time error
return 0;
}
``
* `volatile` qualifier is not properly handled and would lead to undefined behavior
[endsect]
|
