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_greater_equal has_greater_equal]
9   template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
10   struct has_greater_equal : 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_greater_equal<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_greater_equal.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
30
31__examples
32
33[:`has_greater_equal<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
34[:`has_greater_equal<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
35[:`has_greater_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
36[:`has_greater_equal<long>` inherits from `__true_type`.]
37
38[:`has_greater_equal<int, int, bool>` inherits from `__true_type`.]
39[:`has_greater_equal<int, double, bool>` inherits from `__true_type`.]
40[:`has_greater_equal<const int>` inherits from `__true_type`.]
41
42[:`has_greater_equal<int*, int>` inherits from `__false_type`.]
43[:`has_greater_equal<int*, double*>` inherits from `__false_type`.]
44[:`has_greater_equal<int, int, std::string>` inherits from `__false_type`.]
45
46
47[*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
48
49[*Limitation:]
50
51* Requires a compiler with working SFINAE.
52
53[*Known issues:]
54
55* This trait cannot detect whether binary `operator>=` is public or not:
56if `operator>=` is defined as a private member of `Lhs` then
57instantiating `has_greater_equal<Lhs>` will produce a compiler error.
58For this reason `has_greater_equal` cannot be used to determine whether a type has a public `operator>=` or not.
59``
60struct A { private: void operator>=(const A&); };
61boost::has_greater_equal<A>::value; // error: A::operator>=(const A&) is private
62``
63
64* There is an issue if the operator exists only for type `A` and `B` is
65convertible to `A`. In this case, the compiler will report an ambiguous overload.
66``
67struct A { };
68void operator>=(const A&, const A&);
69struct B { operator A(); };
70boost::has_greater_equal<A>::value; // this is fine
71boost::has_greater_equal<B>::value; // error: ambiguous overload
72``
73
74* There is an issue when applying this trait to template classes.
75If `operator>=` is defined but does not bind for a given template type,
76it is still detected by the trait which returns `true` instead of `false`.
77Example:
78``
79#include <boost/type_traits/has_greater_equal.hpp>
80#include <iostream>
81
82template <class T>
83struct contains { T data; };
84
85template <class T>
86bool operator>=(const contains<T> &lhs, const contains<T> &rhs) {
87	return f(lhs.data, rhs.data);
88}
89
90class bad { };
91class good { };
92bool f(const good&, const good&) { }
93
94int main() {
95	std::cout<<std::boolalpha;
96	// works fine for contains<good>
97	std::cout<<boost::has_greater_equal< contains< good > >::value<<'\n'; // true
98	contains<good> g;
99	g>=g; // ok
100	// does not work for contains<bad>
101	std::cout<<boost::has_greater_equal< contains< bad > >::value<<'\n'; // true, should be false
102	contains<bad> b;
103	b>=b; // compile time error
104	return 0;
105}
106``
107
108* `volatile` qualifier is not properly handled and would lead to undefined behavior
109
110[endsect]
111
112