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).
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 {};
13 If (i) `lhs` of type `Lhs` and `rhs` of type `Rhs` can be used in expression `lhs>=rhs`,
14 and (ii) `Ret=dont_care` or the result of expression `lhs>=rhs` is convertible to `Ret`
15 then inherits from __true_type,
16 otherwise inherits from __false_type.
18 The default behaviour (`Ret=dont_care`) is to not check for the return value of binary `operator>=`.
19 If `Ret` is different from the default `dont_care` type, the return value is checked to be convertible to `Ret`.
20 Convertible to `Ret` means that the return value of the operator can be used as argument to a function expecting `Ret`:
25 f(lhs>=rhs); // is valid if has_greater_equal<Lhs, Rhs, Ret>::value==true
27 If `Ret=void`, the return type is checked to be exactly `void`.
29 __header `#include <boost/type_traits/has_greater_equal.hpp>` or `#include <boost/type_traits/has_operator.hpp>` or `#include <boost/type_traits.hpp>`
31 [has_binary_operator_compat]
35 [:`has_greater_equal<Lhs, Rhs, Ret>::value_type` is the type `bool`.]
36 [:`has_greater_equal<Lhs, Rhs, Ret>::value` is a `bool` integral constant expression.]
37 [:`has_greater_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
38 [:`has_greater_equal<long>` inherits from `__true_type`.]
40 [:`has_greater_equal<int, int, bool>` inherits from `__true_type`.]
41 [:`has_greater_equal<int, double, bool>` inherits from `__true_type`.]
42 [:`has_greater_equal<const int>` inherits from `__true_type`.]
44 [:`has_greater_equal<int*, int>` inherits from `__false_type`.]
45 [:`has_greater_equal<int*, double*>` inherits from `__false_type`.]
46 [:`has_greater_equal<int, int, std::string>` inherits from `__false_type`.]
49 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
53 * This trait cannot detect whether binary `operator>=` is public or not:
54 if `operator>=` is defined as a private member of `Lhs` then
55 instantiating `has_greater_equal<Lhs>` will produce a compiler error.
56 For this reason `has_greater_equal` cannot be used to determine whether a type has a public `operator>=` or not.
58 struct A { private: void operator>=(const A&); };
59 boost::has_greater_equal<A>::value; // error: A::operator>=(const A&) is private
62 * There is an issue if the operator exists only for type `A` and `B` is
63 convertible to `A`. In this case, the compiler will report an ambiguous overload.
66 void operator>=(const A&, const A&);
67 struct B { operator A(); };
68 boost::has_greater_equal<A>::value; // this is fine
69 boost::has_greater_equal<B>::value; // error: ambiguous overload
72 * There is an issue when applying this trait to template classes.
73 If `operator>=` is defined but does not bind for a given template type,
74 it is still detected by the trait which returns `true` instead of `false`.
77 #include <boost/type_traits/has_greater_equal.hpp>
81 struct contains { T data; };
84 bool operator>=(const contains<T> &lhs, const contains<T> &rhs) {
85 return f(lhs.data, rhs.data);
90 bool f(const good&, const good&) { }
93 std::cout<<std::boolalpha;
94 // works fine for contains<good>
95 std::cout<<boost::has_greater_equal< contains< good > >::value<<'\n'; // true
98 // does not work for contains<bad>
99 std::cout<<boost::has_greater_equal< contains< bad > >::value<<'\n'; // true, should be false
101 b>=b; // compile time error
106 * `volatile` qualifier is not properly handled and would lead to undefined behavior