aboutsummaryrefslogtreecommitdiff
path: root/cutl/details/boost/type_traits/is_enum.hpp
blob: a837de5d9c300bfa001bc520dcd7ff75d3214d4b (plain)
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

//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard
//  Hinnant & John Maddock 2000.  
//  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.


#ifndef BOOST_TT_IS_ENUM_HPP_INCLUDED
#define BOOST_TT_IS_ENUM_HPP_INCLUDED

#include <cutl/details/boost/type_traits/intrinsics.hpp>
#ifndef BOOST_IS_ENUM
#include <cutl/details/boost/type_traits/add_reference.hpp>
#include <cutl/details/boost/type_traits/is_arithmetic.hpp>
#include <cutl/details/boost/type_traits/is_reference.hpp>
#include <cutl/details/boost/type_traits/is_convertible.hpp>
#include <cutl/details/boost/type_traits/is_array.hpp>
#ifdef __GNUC__
#include <cutl/details/boost/type_traits/is_function.hpp>
#endif
#include <cutl/details/boost/type_traits/config.hpp>
#if defined(BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION) 
#  include <cutl/details/boost/type_traits/is_class.hpp>
#  include <cutl/details/boost/type_traits/is_union.hpp>
#endif
#endif

// should be the last #include
#include <cutl/details/boost/type_traits/detail/bool_trait_def.hpp>

namespace cutl_details_boost {

#ifndef BOOST_IS_ENUM
#if !(defined(__BORLANDC__) && (__BORLANDC__ <= 0x551))

namespace detail {

#if defined(BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION) 

template <typename T>
struct is_class_or_union
{
   BOOST_STATIC_CONSTANT(bool, value =
      (::cutl_details_boost::type_traits::ice_or<
           ::cutl_details_boost::is_class<T>::value
         , ::cutl_details_boost::is_union<T>::value
      >::value));
};

#else

template <typename T>
struct is_class_or_union
{
# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))// we simply can't detect it this way.
    BOOST_STATIC_CONSTANT(bool, value = false);
# else
    template <class U> static ::cutl_details_boost::type_traits::yes_type is_class_or_union_tester(void(U::*)(void));

#  if BOOST_WORKAROUND(BOOST_MSVC, == 1300)                 \
    || BOOST_WORKAROUND(__MWERKS__, <= 0x3000) // no SFINAE
    static ::cutl_details_boost::type_traits::no_type is_class_or_union_tester(...);
    BOOST_STATIC_CONSTANT(
        bool, value = sizeof(is_class_or_union_tester(0)) == sizeof(::cutl_details_boost::type_traits::yes_type));
#  else
    template <class U>
    static ::cutl_details_boost::type_traits::no_type is_class_or_union_tester(...);
    BOOST_STATIC_CONSTANT(
        bool, value = sizeof(is_class_or_union_tester<T>(0)) == sizeof(::cutl_details_boost::type_traits::yes_type));
#  endif
# endif
};
#endif

struct int_convertible
{
    int_convertible(int);
};

// Don't evaluate convertibility to int_convertible unless the type
// is non-arithmetic. This suppresses warnings with GCC.
template <bool is_typename_arithmetic_or_reference = true>
struct is_enum_helper
{
    template <typename T> struct type
    {
        BOOST_STATIC_CONSTANT(bool, value = false);
    };
};

template <>
struct is_enum_helper<false>
{
    template <typename T> struct type
       : public ::cutl_details_boost::is_convertible<typename cutl_details_boost::add_reference<T>::type,::cutl_details_boost::detail::int_convertible>
    {
    };
};

template <typename T> struct is_enum_impl
{
   //typedef ::cutl_details_boost::add_reference<T> ar_t;
   //typedef typename ar_t::type r_type;

#if defined(__GNUC__)

#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION
    
   // We MUST check for is_class_or_union on conforming compilers in
   // order to correctly deduce that noncopyable types are not enums
   // (dwa 2002/04/15)...
   BOOST_STATIC_CONSTANT(bool, selector =
      (::cutl_details_boost::type_traits::ice_or<
           ::cutl_details_boost::is_arithmetic<T>::value
         , ::cutl_details_boost::is_reference<T>::value
         , ::cutl_details_boost::is_function<T>::value
         , is_class_or_union<T>::value
         , is_array<T>::value
      >::value));
#else
   // ...however, not checking is_class_or_union on non-conforming
   // compilers prevents a dependency recursion.
   BOOST_STATIC_CONSTANT(bool, selector =
      (::cutl_details_boost::type_traits::ice_or<
           ::cutl_details_boost::is_arithmetic<T>::value
         , ::cutl_details_boost::is_reference<T>::value
         , ::cutl_details_boost::is_function<T>::value
         , is_array<T>::value
      >::value));
#endif // BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION

#else // !defined(__GNUC__):
    
   BOOST_STATIC_CONSTANT(bool, selector =
      (::cutl_details_boost::type_traits::ice_or<
           ::cutl_details_boost::is_arithmetic<T>::value
         , ::cutl_details_boost::is_reference<T>::value
         , is_class_or_union<T>::value
         , is_array<T>::value
      >::value));
    
#endif

#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
    typedef ::cutl_details_boost::detail::is_enum_helper<
          ::cutl_details_boost::detail::is_enum_impl<T>::selector
        > se_t;
#else
    typedef ::cutl_details_boost::detail::is_enum_helper<selector> se_t;
#endif

    typedef typename se_t::template type<T> helper;
    BOOST_STATIC_CONSTANT(bool, value = helper::value);
};

// these help on compilers with no partial specialization support:
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void,false)
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void const volatile,false)
#endif

} // namespace detail

BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_enum,T,::cutl_details_boost::detail::is_enum_impl<T>::value)

#else // __BORLANDC__
//
// buggy is_convertible prevents working
// implementation of is_enum:
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_enum,T,false)

#endif

#else // BOOST_IS_ENUM

BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_enum,T,BOOST_IS_ENUM(T))

#endif

} // namespace cutl_details_boost

#include <cutl/details/boost/type_traits/detail/bool_trait_undef.hpp>

#endif // BOOST_TT_IS_ENUM_HPP_INCLUDED