From 7a071a5918d2b16b0b03ebe16c85cb5886172fa7 Mon Sep 17 00:00:00 2001 From: Glen Fernandes Date: Sun, 31 May 2020 02:49:03 -0400 Subject: [PATCH] Implement is_scoped_enum and is_unscoped_enum --- doc/is_scoped_enum.qbk | 45 +++++++++++++++++++ doc/is_unscoped_enum.qbk | 45 +++++++++++++++++++ doc/type_traits.qbk | 4 ++ include/boost/type_traits.hpp | 2 + include/boost/type_traits/is_scoped_enum.hpp | 26 +++++++++++ .../boost/type_traits/is_unscoped_enum.hpp | 25 +++++++++++ test/is_scoped_enum_test.cpp | 36 +++++++++++++++ test/is_unscoped_enum_test.cpp | 36 +++++++++++++++ 8 files changed, 219 insertions(+) create mode 100644 doc/is_scoped_enum.qbk create mode 100644 doc/is_unscoped_enum.qbk create mode 100644 include/boost/type_traits/is_scoped_enum.hpp create mode 100644 include/boost/type_traits/is_unscoped_enum.hpp create mode 100644 test/is_scoped_enum_test.cpp create mode 100644 test/is_unscoped_enum_test.cpp diff --git a/doc/is_scoped_enum.qbk b/doc/is_scoped_enum.qbk new file mode 100644 index 0000000..911a33d --- /dev/null +++ b/doc/is_scoped_enum.qbk @@ -0,0 +1,45 @@ +[/ +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +Distributed under 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). +] + +[section:is_scoped_enum is_scoped_enum] + + template + struct is_scoped_enum + : __tof { }; + +__inherit If T is a (possibly cv-qualified) scoped enumeration type +(`enum class` but not `enum`), then inherits from __true_type, otherwise +inherits from __false_type. + +__header `#include ` + +[all_compilers] + +__examples + +[:Given: `enum class color { red, blue };` and `enum fruit { apple, orange };`] + +[:`is_scoped_enum` inherits from `__true_type`.] + +[:`is_scoped_enum` inherits from `__false_type`.] + +[:`is_scoped_enum::type` is the type `__true_type`.] + +[:`is_scoped_enum::value` is an integral constant expression that +evaluates to /true/.] + +[:`is_scoped_enum::value` is an integral constant expression that +evaluates to /false/.] + +[:`is_scoped_enum::value` is an integral constant expression that +evaluates to /false/.] + +[:`is_scoped_enum::value_type` is the type `bool`.] + +[endsect] diff --git a/doc/is_unscoped_enum.qbk b/doc/is_unscoped_enum.qbk new file mode 100644 index 0000000..39b32e1 --- /dev/null +++ b/doc/is_unscoped_enum.qbk @@ -0,0 +1,45 @@ +[/ +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +Distributed under 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). +] + +[section:is_unscoped_enum is_unscoped_enum] + + template + struct is_unscoped_enum + : __tof { }; + +__inherit If T is a (possibly cv-qualified) unscoped enumeration type +(`enum` but not `enum class`), then inherits from __true_type, otherwise +inherits from __false_type. + +__header `#include ` + +[all_compilers] + +__examples + +[:Given: `enum color { red, blue };` and `enum class fruit { apple, orange };`] + +[:`is_unscoped_enum` inherits from `__true_type`.] + +[:`is_unscoped_enum` inherits from `__false_type`.] + +[:`is_unscoped_enum::type` is the type `__true_type`.] + +[:`is_unscoped_enum::value` is an integral constant expression that +evaluates to /true/.] + +[:`is_unscoped_enum::value` is an integral constant expression that +evaluates to /false/.] + +[:`is_unscoped_enum::value` is an integral constant expression that +evaluates to /false/.] + +[:`is_unscoped_enum::value_type` is the type `bool`.] + +[endsect] diff --git a/doc/type_traits.qbk b/doc/type_traits.qbk index b67ed55..26b1d74 100644 --- a/doc/type_traits.qbk +++ b/doc/type_traits.qbk @@ -55,6 +55,8 @@ [def __is_unbounded_array [link boost_typetraits.reference.is_unbounded_array is_unbounded_array]] [def __is_union [link boost_typetraits.reference.is_union is_union]] [def __is_class [link boost_typetraits.reference.is_class is_class]] +[def __is_scoped_enum [link boost_typetraits.reference.is_scoped_enum is_scoped_enum]] +[def __is_unscoped_enum [link boost_typetraits.reference.is_unscoped_enum is_unscoped_enum]] [def __is_enum [link boost_typetraits.reference.is_enum is_enum]] [def __is_enum [link boost_typetraits.reference.is_enum is_enum]] [def __is_function [link boost_typetraits.reference.is_function is_function]] @@ -434,10 +436,12 @@ See __has_trivial_constructor. [include is_rvalue_reference.qbk] [include is_same.qbk] [include is_scalar.qbk] +[include is_scoped_enum.qbk] [include is_signed.qbk] [include is_stateless.qbk] [include is_unbounded_array.qbk] [include is_union.qbk] +[include is_unscoped_enum.qbk] [include is_unsigned.qbk] [include is_virtual_base_of.qbk] [include is_void.qbk] diff --git a/include/boost/type_traits.hpp b/include/boost/type_traits.hpp index 052cf00..008d8b6 100644 --- a/include/boost/type_traits.hpp +++ b/include/boost/type_traits.hpp @@ -128,9 +128,11 @@ #include #include #include +#include #include #include #include +#include #include #include #include diff --git a/include/boost/type_traits/is_scoped_enum.hpp b/include/boost/type_traits/is_scoped_enum.hpp new file mode 100644 index 0000000..7566859 --- /dev/null +++ b/include/boost/type_traits/is_scoped_enum.hpp @@ -0,0 +1,26 @@ +/* +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +Distributed under 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) +*/ + +#ifndef BOOST_TT_IS_SCOPED_ENUM_HPP_INCLUDED +#define BOOST_TT_IS_SCOPED_ENUM_HPP_INCLUDED + +#include +#include +#include +#include + +namespace boost { + +template +struct is_scoped_enum + : conjunction, negation > >::type { }; + +} /* boost */ + +#endif diff --git a/include/boost/type_traits/is_unscoped_enum.hpp b/include/boost/type_traits/is_unscoped_enum.hpp new file mode 100644 index 0000000..99f9acb --- /dev/null +++ b/include/boost/type_traits/is_unscoped_enum.hpp @@ -0,0 +1,25 @@ +/* +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +Distributed under 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) +*/ + +#ifndef BOOST_TT_IS_UNSCOPED_ENUM_HPP_INCLUDED +#define BOOST_TT_IS_UNSCOPED_ENUM_HPP_INCLUDED + +#include +#include +#include + +namespace boost { + +template +struct is_unscoped_enum + : conjunction, is_convertible >::type { }; + +} /* boost */ + +#endif diff --git a/test/is_scoped_enum_test.cpp b/test/is_scoped_enum_test.cpp new file mode 100644 index 0000000..df52ead --- /dev/null +++ b/test/is_scoped_enum_test.cpp @@ -0,0 +1,36 @@ +/* +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +Distributed under 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) +*/ +#ifdef TEST_STD +#include +#else +#include +#endif +#include "check_integral_constant.hpp" + +enum Unscoped { + Constant = 1 +}; + +#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS) +enum class Scoped { + Constant = 2 +}; +#endif + +TT_TEST_BEGIN(is_scoped_enum) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scoped_enum::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scoped_enum::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scoped_enum::value, false); + +#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS) +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scoped_enum::value, true); +#endif + +TT_TEST_END diff --git a/test/is_unscoped_enum_test.cpp b/test/is_unscoped_enum_test.cpp new file mode 100644 index 0000000..5499e32 --- /dev/null +++ b/test/is_unscoped_enum_test.cpp @@ -0,0 +1,36 @@ +/* +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +Distributed under 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) +*/ +#ifdef TEST_STD +#include +#else +#include +#endif +#include "check_integral_constant.hpp" + +enum Unscoped { + Constant = 1 +}; + +#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS) +enum class Scoped { + Constant = 2 +}; +#endif + +TT_TEST_BEGIN(is_unscoped_enum) + +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unscoped_enum::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unscoped_enum::value, false); +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unscoped_enum::value, true); + +#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS) +BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unscoped_enum::value, false); +#endif + +TT_TEST_END