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