/usr/include/boost/type_traits/detail/has_prefix_operator.hpp is in libboost1.55-dev 1.55.0+dfsg-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 | // (C) Copyright 2009-2011 Frederic Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa.
//
// Use, modification and distribution are subject to 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).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#include <boost/config.hpp>
#include <boost/type_traits/ice.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_fundamental.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_void.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/remove_pointer.hpp>
#include <boost/type_traits/remove_reference.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
// cannot include this header without getting warnings of the kind:
// gcc:
// warning: value computed is not used
// warning: comparison between signed and unsigned integer expressions
// msvc:
// warning C4146: unary minus operator applied to unsigned type, result still unsigned
// warning C4804: '-' : unsafe use of type 'bool' in operation
// cannot find another implementation -> declared as system header to suppress these warnings.
#if defined(__GNUC__) && ((__GNUC__==3 && __GNUC_MINOR__>=1) || (__GNUC__>3))
# pragma GCC system_header
#elif defined(BOOST_MSVC)
# pragma warning ( push )
# pragma warning ( disable : 4146 4804 4913 4244 )
#endif
namespace boost {
namespace detail {
// This namespace ensures that argument-dependent name lookup does not mess things up.
namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
// 1. a function to have an instance of type T without requiring T to be default
// constructible
template <typename T> T &make();
// 2. we provide our operator definition for types that do not have one already
// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
// found in the type's own namespace (our own operator is used) so that we have
// a means to know that our operator was used
struct no_operator { };
// this class allows implicit conversions and makes the following operator
// definition less-preferred than any other such operators that might be found
// via argument-dependent name lookup
struct any { template <class T> any(T const&); };
// when operator BOOST_TT_TRAIT_OP is not available, this one is used
no_operator operator BOOST_TT_TRAIT_OP (const any&);
// 3. checks if the operator returns void or not
// conditions: Rhs!=void
// we first redefine "operator," so that we have no compilation error if
// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
// (BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if
// operator BOOST_TT_TRAIT_OP returns void or not:
// - operator BOOST_TT_TRAIT_OP returns void -> (BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
// - operator BOOST_TT_TRAIT_OP returns !=void -> (BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
struct returns_void_t { };
template <typename T> int operator,(const T&, returns_void_t);
template <typename T> int operator,(const volatile T&, returns_void_t);
// this intermediate trait has member value of type bool:
// - value==true -> operator BOOST_TT_TRAIT_OP returns void
// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
template < typename Rhs >
struct operator_returns_void {
// overloads of function returns_void make the difference
// yes_type and no_type have different size by construction
static ::boost::type_traits::yes_type returns_void(returns_void_t);
static ::boost::type_traits::no_type returns_void(int);
BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((BOOST_TT_TRAIT_OP make<Rhs>(),returns_void_t())))));
};
// 4. checks if the return type is Ret or Ret==dont_care
// conditions: Rhs!=void
struct dont_care { };
template < typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;
template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, true > {
BOOST_STATIC_CONSTANT(bool, value = true);
};
template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, false > {
BOOST_STATIC_CONSTANT(bool, value = true);
};
template < typename Rhs >
struct operator_returns_Ret < Rhs, void, true > {
BOOST_STATIC_CONSTANT(bool, value = true);
};
template < typename Rhs >
struct operator_returns_Ret < Rhs, void, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
template < typename Rhs, typename Ret >
struct operator_returns_Ret < Rhs, Ret, true > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
// otherwise checks if it is convertible to Ret using the sizeof trick
// based on overload resolution
// condition: Ret!=void and Ret!=dont_care and the operator does not return void
template < typename Rhs, typename Ret >
struct operator_returns_Ret < Rhs, Ret, false > {
static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise
BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_Ret(BOOST_TT_TRAIT_OP make<Rhs>()))==sizeof(::boost::type_traits::yes_type)));
};
// 5. checks for operator existence
// condition: Rhs!=void
// checks if our definition of operator BOOST_TT_TRAIT_OP is used or an other
// existing one;
// this is done with redefinition of "operator," that returns no_operator or has_operator
struct has_operator { };
no_operator operator,(no_operator, has_operator);
template < typename Rhs >
struct operator_exists {
static ::boost::type_traits::yes_type check(has_operator); // this version is preferred when operator exists
static ::boost::type_traits::no_type check(no_operator); // this version is used otherwise
BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((BOOST_TT_TRAIT_OP make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type)));
};
// 6. main trait: to avoid any compilation error, this class behaves
// differently when operator BOOST_TT_TRAIT_OP(Rhs) is forbidden by the
// standard.
// Forbidden_if is a bool that is:
// - true when the operator BOOST_TT_TRAIT_OP(Rhs) is forbidden by the standard
// (would yield compilation error if used)
// - false otherwise
template < typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;
template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, true > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, false > {
BOOST_STATIC_CONSTANT(bool,
value = (
::boost::type_traits::ice_and<
operator_exists < Rhs >::value,
operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value
>::value
)
);
};
// specialization needs to be declared for the special void case
template < typename Ret >
struct trait_impl1 < void, Ret, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
// defines some typedef for convenience
template < typename Rhs, typename Ret >
struct trait_impl {
typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
BOOST_STATIC_CONSTANT(bool, value = (trait_impl1 < Rhs_noref, Ret, BOOST_TT_FORBIDDEN_IF >::value));
};
} // namespace impl
} // namespace detail
// this is the accessible definition of the trait to end user
BOOST_TT_AUX_BOOL_TRAIT_DEF2(BOOST_TT_TRAIT_NAME, Rhs, Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::trait_impl < Rhs, Ret >::value))
} // namespace boost
#if defined(BOOST_MSVC)
# pragma warning ( pop )
#endif
#include <boost/type_traits/detail/bool_trait_undef.hpp>
|