|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r70023 - sandbox/enums/boost/enums
From: vicente.botet_at_[hidden]
Date: 2011-03-16 16:56:19
Author: viboes
Date: 2011-03-16 16:56:18 EDT (Wed, 16 Mar 2011)
New Revision: 70023
URL: http://svn.boost.org/trac/boost/changeset/70023
Log:
Enums: Fix issue with oprators for enum type
Added:
sandbox/enums/boost/enums/scoping_type.hpp
- copied, changed from r70004, /sandbox/enums/boost/enums/emulator_type.hpp
Removed:
sandbox/enums/boost/enums/emulator_type.hpp
Text files modified:
sandbox/enums/boost/enums/default_value.hpp | 2
sandbox/enums/boost/enums/emulation.hpp | 24 +++++++++++++-------
sandbox/enums/boost/enums/enum_class_cons.hpp | 30 ++++++++++++++++---------
sandbox/enums/boost/enums/enum_class_no_cons.hpp | 39 +++++++++++++++++++++++++--------
sandbox/enums/boost/enums/enum_subrange.hpp | 8 +++---
sandbox/enums/boost/enums/enum_subrange_traiter.hpp | 8 +++---
sandbox/enums/boost/enums/enum_type_cons.hpp | 46 ++++++++++++++++++++++++++++-----------
sandbox/enums/boost/enums/enum_type_no_cons.hpp | 40 ++++++++++++++++++++++++++--------
sandbox/enums/boost/enums/scoping_type.hpp | 10 ++++----
9 files changed, 140 insertions(+), 67 deletions(-)
Modified: sandbox/enums/boost/enums/default_value.hpp
==============================================================================
--- sandbox/enums/boost/enums/default_value.hpp (original)
+++ sandbox/enums/boost/enums/default_value.hpp 2011-03-16 16:56:18 EDT (Wed, 16 Mar 2011)
@@ -13,7 +13,7 @@
#ifndef BOOST_ENUMS_DEFAULT_VALUE_HPP
#define BOOST_ENUMS_DEFAULT_VALUE_HPP
-#include <boost/config.hpp>
+#include <boost/enums/config.hpp>
namespace boost {
namespace enums {
Modified: sandbox/enums/boost/enums/emulation.hpp
==============================================================================
--- sandbox/enums/boost/enums/emulation.hpp (original)
+++ sandbox/enums/boost/enums/emulation.hpp 2011-03-16 16:56:18 EDT (Wed, 16 Mar 2011)
@@ -15,7 +15,7 @@
#include <boost/enums/underlying_type.hpp>
#include <boost/enums/enum_type.hpp>
-#include <boost/enums/emulator_type.hpp>
+#include <boost/enums/scoping_type.hpp>
#include <boost/enums/default_value.hpp>
#include <boost/enums/enum_value.hpp>
#include <boost/enums/underlying_value.hpp>
@@ -65,11 +65,11 @@
#endif // !defined(BOOST_NO_SCOPED_ENUMS) && ! defined(BOOST_NO_SCOPED_ENUMS_COMPARE)
- #define BOOST_ENUMS_DETAIL_EMULATOR_TYPE_SPEC(EC) \
+ #define BOOST_ENUMS_DETAIL_SCOPING_TYPE_SPEC(EC) \
namespace boost { \
namespace enums { \
template <> \
- struct emulator_type<enum_type<EC>::type> \
+ struct scoping_type<enum_type<EC>::type> \
{ \
typedef EC type; \
}; \
@@ -126,7 +126,6 @@
#define BOOST_ENUMS_DETAIL_CONVERSIONS(EC, UT) \
- operator underlying_type() { return val_; } \
operator type() { return type(val_); }
@@ -197,9 +196,7 @@
{ \
return val_; \
} \
- BOOST_ENUMS_DETAIL_COMPARAISON_OPERATORS(EC, UT) \
- BOOST_ENUMS_DETAIL_FRIEND_CONVERSIONS(EC, UT) \
-};
+ BOOST_ENUMS_DETAIL_FRIEND_CONVERSIONS(EC, UT)
#endif
@@ -264,35 +261,44 @@
#define BOOST_ENUM_CLASS_END(EC, UT) \
BOOST_ENUMS_DETAIL_END_1(EC, UT) \
BOOST_ENUMS_DETAIL_END_2(EC, UT) \
+ BOOST_ENUMS_DETAIL_COMPARAISON_OPERATORS(EC, UT) \
+ };
+
#define BOOST_ENUM_TYPE_END(EC, UT) \
BOOST_ENUMS_DETAIL_END_1(EC, UT) \
BOOST_ENUMS_DETAIL_CONVERSIONS(EC, UT) \
BOOST_ENUMS_DETAIL_END_2(EC, UT) \
+ };
#define BOOST_ENUM_CLASS_NO_CONS_END(EC, UT) \
BOOST_ENUMS_DETAIL_END_1(EC, UT) \
BOOST_ENUMS_DETAIL_END_2(EC, UT) \
+ BOOST_ENUMS_DETAIL_COMPARAISON_OPERATORS(EC, UT) \
+ };
#define BOOST_ENUM_TYPE_NO_CONS_END(EC, UT) \
BOOST_ENUMS_DETAIL_END_1(EC, UT) \
BOOST_ENUMS_DETAIL_CONVERSIONS(EC, UT) \
BOOST_ENUMS_DETAIL_END_2(EC, UT) \
+ };
#define BOOST_ENUM_CLASS_CONS_END(EC, UT) \
BOOST_ENUMS_DETAIL_END_1(EC, UT) \
BOOST_ENUMS_DETAIL_CONSTRUCTORS(EC, UT) \
BOOST_ENUMS_DETAIL_END_2(EC, UT) \
+ BOOST_ENUMS_DETAIL_COMPARAISON_OPERATORS(EC, UT) \
+ };
#define BOOST_ENUM_TYPE_CONS_END(EC, UT) \
BOOST_ENUMS_DETAIL_END_1(EC, UT) \
BOOST_ENUMS_DETAIL_CONSTRUCTORS(EC, UT) \
BOOST_ENUMS_DETAIL_CONVERSIONS(EC, UT) \
BOOST_ENUMS_DETAIL_END_2(EC, UT) \
-
+ };
#define BOOST_ENUMS_SPECIALIZATIONS(EC, UT) \
- BOOST_ENUMS_DETAIL_EMULATOR_TYPE_SPEC(EC)
+ BOOST_ENUMS_DETAIL_SCOPING_TYPE_SPEC(EC)
#endif // BOOST_NO_SCOPED_ENUMS
Deleted: sandbox/enums/boost/enums/emulator_type.hpp
==============================================================================
--- sandbox/enums/boost/enums/emulator_type.hpp 2011-03-16 16:56:18 EDT (Wed, 16 Mar 2011)
+++ (empty file)
@@ -1,42 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Vicente J. Botet Escriba 2011.
-// 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)
-//
-// See http://www.boost.org/libs/enums for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-/*!
- \file
- \brief
- The header \c <boost/enums/emulator_type.hpp> defines the declaration of emulator_type<> meta-function.
- */
-
-#ifndef BOOST_ENUMS_EMULATOR_TYPE_HPP
-#define BOOST_ENUMS_EMULATOR_TYPE_HPP
-
-#include <boost/config.hpp>
-
-namespace boost
-{
- namespace enums
- {
- /*! meta-function used to get the wrapping class of an enum when emulation
- is used or the enum class itself when available.
- This meta-function must be specialized for each enum class.
- */
- template <typename EC_type>
- struct emulator_type
- {
- //! Depending on whethere the compiler supports scoped enums or nor the nested type must be the same type or the emulated one.
- //! By default this metafunction defines it as if scoped enums where supported so the specialization will be needed only when emulation is needed.
- typedef EC_type type;
- };
- }
-}
-
-#endif // BOOST_ENUMS_EMULATOR_TYPE_HPP
Modified: sandbox/enums/boost/enums/enum_class_cons.hpp
==============================================================================
--- sandbox/enums/boost/enums/enum_class_cons.hpp (original)
+++ sandbox/enums/boost/enums/enum_class_cons.hpp 2011-03-16 16:56:18 EDT (Wed, 16 Mar 2011)
@@ -25,43 +25,51 @@
{
namespace enums
{
- template <typename ScopedEnum, typename UT=typename ScopedEnum::type>
+ //! scoped enum class with constructors
+
+ //! param @c ScopedEnum : Struct scoping the enum.\n
+ //! param @c UT : the underlaying storage type.\n
+ //! pre @c ScopedEnum must have a nested C++98 enum @c type.\n
+
+ template <typename ScopedEnum, typename UT=int>
class enum_class_cons : public ScopedEnum
{
- public:
- typedef typename ScopedEnum::type type;
+ public:
+ //! c++98 enum type
+ typedef typename ScopedEnum::type type;
+ //! underlying type
typedef UT underlying_type;
private:
underlying_type val_;
public:
- // default constructor
+ //! default constructor
enum_class_cons()
: val_(static_cast<underlying_type>(type()))
{
}
- // explicit constructor from underlying type
+ //! explicit constructor from underlying type
explicit enum_class_cons(underlying_type v)
: val_(v)
{
}
- // constructor from enum type
+ //! constructor from enum type
enum_class_cons(type v)
: val_(static_cast<underlying_type>(v))
{
}
- // assignment
+ //! assignment
enum_class_cons& operator=(enum_class_cons rhs)
{
val_=rhs.val_;
return *this;
}
- // assignment from enum literals
+ //! assignment from enum literals
enum_class_cons& operator=(type rhs)
{
val_=static_cast<underlying_type>(rhs);
return *this;
}
- // workaround when there are no constructors
+ //! workaround when there are no constructors
static enum_class_cons default_value()
{
enum_class_cons res;
@@ -82,12 +90,12 @@
res.val_=static_cast<underlying_type>(v);
return res;
}
- // explicit conversion function to enum type
+ //! explicit conversion function to enum type
type enum_value() const
{
return type(val_);
}
- // explicit conversion function to underlying_type
+ //! explicit conversion function to underlying_type
underlying_type underlying_value() const
{
return val_;
Modified: sandbox/enums/boost/enums/enum_class_no_cons.hpp
==============================================================================
--- sandbox/enums/boost/enums/enum_class_no_cons.hpp (original)
+++ sandbox/enums/boost/enums/enum_class_no_cons.hpp 2011-03-16 16:56:18 EDT (Wed, 16 Mar 2011)
@@ -25,34 +25,44 @@
{
namespace enums
{
- template <typename ScopedEnum, typename UT=typename ScopedEnum::type>
+ //! scoped enum class without constructors
+
+ //! param @c ScopedEnum : Struct scoping the enum.\n
+ //! param @c UT : the underlaying storage type.\n
+ //! pre @c ScopedEnum must have a nested C++98 enum @c type.\n
+ template <typename ScopedEnum, typename UT=int>
class enum_class_no_cons : public ScopedEnum
{
- public:
- typedef typename ScopedEnum::type type;
+ public:
+ //! c++98 enum type
+ typedef typename ScopedEnum::type type;
+ //! underlying type
typedef UT underlying_type;
private:
underlying_type val_;
public:
- // assignment
+ //! assignment
enum_class_no_cons& operator=(enum_class_no_cons rhs)
{
val_=rhs.val_;
return *this;
}
- // assignment from enum literals
+
+ //! assignment from enum literals
enum_class_no_cons& operator=(type rhs)
{
val_=static_cast<underlying_type>(rhs);
return *this;
}
- // workaround when there are no constructors
+
+ //! workaround when there are no constructors
static enum_class_no_cons default_value()
{
enum_class_no_cons res;
res.val_=static_cast<underlying_type>(type());
return res;
}
+
static enum_class_no_cons convert_to(underlying_type v)
{
enum_class_no_cons res;
@@ -60,22 +70,26 @@
return res;
}
+
static enum_class_no_cons convert_to(type v)
{
enum_class_no_cons res;
res.val_=static_cast<underlying_type>(v);
return res;
}
- // explicit conversion function to enum type
+
+ //! explicit conversion function to enum type
type enum_value() const
{
return type(val_);
}
- // explicit conversion function to underlying_type
+
+ //! explicit conversion function to underlying_type
underlying_type underlying_value() const
{
return val_;
}
+
//! equal operator
friend bool operator==(enum_class_no_cons lhs, enum_class_no_cons rhs)
{
@@ -167,15 +181,16 @@
return lhs.val_ > rhs;
}
- // friend conversions to follow the Boost.Conversion protocol
+ //! conversions from underlying_type to enum_type_cons following the Boost.Conversion protocol
friend enum_class_no_cons convert_to(underlying_type v,
boost::dummy::type_tag<enum_class_no_cons> const&)
{
enum_class_no_cons res;
res.val_=v;
return res;
-
}
+
+ //! friend conversions from type to enum_type_cons following the Boost.Conversion protocol
friend enum_class_no_cons convert_to(type v,
boost::dummy::type_tag<enum_class_no_cons> const&)
{
@@ -183,11 +198,15 @@
res.val_=static_cast<underlying_type>(v);
return res;
}
+
+ //! conversions from enum_type_cons to underlying_type following the Boost.Conversion protocol
friend underlying_type convert_to(enum_class_no_cons v,
boost::dummy::type_tag<underlying_type> const&)
{
return boost::enums::underlying_value(v);
}
+
+ //! conversions from enum_type_cons to type following the Boost.Conversion protocol
friend type convert_to(enum_class_no_cons v,
boost::dummy::type_tag<type> const&)
{
Modified: sandbox/enums/boost/enums/enum_subrange.hpp
==============================================================================
--- sandbox/enums/boost/enums/enum_subrange.hpp (original)
+++ sandbox/enums/boost/enums/enum_subrange.hpp 2011-03-16 16:56:18 EDT (Wed, 16 Mar 2011)
@@ -16,18 +16,18 @@
#include <boost/enums/pos.hpp>
#include <boost/enums/first.hpp>
#include <boost/enums/last.hpp>
-#include <boost/enums/emulator_type.hpp>
+#include <boost/enums/scoping_type.hpp>
namespace boost {
namespace enums {
template <
typename EC_type,
- EC_type First=enums::meta::first<typename emulator_type<EC_type>::type >::value,
- EC_type Last=enums::meta::last<typename emulator_type<EC_type>::type >::value
+ EC_type First=enums::meta::first<typename scoping_type<EC_type>::type >::value,
+ EC_type Last=enums::meta::last<typename scoping_type<EC_type>::type >::value
>
struct enum_subrange
{
- typedef typename emulator_type<EC_type>::type EC;
+ typedef typename scoping_type<EC_type>::type EC;
static const std::size_t first_index = enums::meta::pos<EC,First>::value;
static const std::size_t last_index = enums::meta::pos<EC,Last>::value;
Modified: sandbox/enums/boost/enums/enum_subrange_traiter.hpp
==============================================================================
--- sandbox/enums/boost/enums/enum_subrange_traiter.hpp (original)
+++ sandbox/enums/boost/enums/enum_subrange_traiter.hpp 2011-03-16 16:56:18 EDT (Wed, 16 Mar 2011)
@@ -16,18 +16,18 @@
#include <boost/enums/pos.hpp>
#include <boost/enums/first.hpp>
#include <boost/enums/last.hpp>
-#include <boost/enums/emulator_type.hpp>
+#include <boost/enums/scoping_type.hpp>
namespace boost {
namespace enums {
template <
typename EC_type,
- EC_type First=enums::meta::first<typename emulator_type<EC_type>::type >::value,
- EC_type Last=enums::meta::last<typename emulator_type<EC_type>::type >::value
+ EC_type First=enums::meta::first<typename scoping_type<EC_type>::type >::value,
+ EC_type Last=enums::meta::last<typename scoping_type<EC_type>::type >::value
>
struct enum_subrange
{
- typedef typename emulator_type<EC_type>::type EC;
+ typedef typename scoping_type<EC_type>::type EC;
static const std::size_t first_index = enums::meta::pos<EC,First>::value;
static const std::size_t last_index = enums::meta::pos<EC,Last>::value;
Modified: sandbox/enums/boost/enums/enum_type_cons.hpp
==============================================================================
--- sandbox/enums/boost/enums/enum_type_cons.hpp (original)
+++ sandbox/enums/boost/enums/enum_type_cons.hpp 2011-03-16 16:56:18 EDT (Wed, 16 Mar 2011)
@@ -25,59 +25,73 @@
{
namespace enums
{
- template <typename ScopedEnum, typename UT=typename ScopedEnum::type>
+ //! scoped enum type with constructors
+
+ //! param @c ScopedEnum : Struct scoping the enum.\n
+ //! param @c UT : the underlaying storage type.\n
+ //! pre @c ScopedEnum must have a nested C++98 enum @c type.\n
+ template <typename ScopedEnum, typename UT=int>
class enum_type_cons : public ScopedEnum
{
- public:
- typedef typename ScopedEnum::type type;
+ public:
+ //! c++98 enum type
+ typedef typename ScopedEnum::type type;
+ //! underlying type
typedef UT underlying_type;
private:
underlying_type val_;
public:
- // default constructor
+ //! default constructor
enum_type_cons()
: val_(static_cast<underlying_type>(type()))
{
}
- // explicit constructor from underlying type
+
+ //! explicit constructor from underlying type
explicit enum_type_cons(underlying_type v)
: val_(v)
{
}
- // constructor from enum type
+
+ //! constructor from enum type
enum_type_cons(type v)
: val_(static_cast<underlying_type>(v))
{
}
- // implicit conversion to underlying_type
+
+#if 0
+ //! implicit conversion to underlying_type
operator underlying_type()
{
return val_;
}
- // implicit conversion to enum type
+#endif
+ //! implicit conversion to enum type
operator type()
{
return type(val_);
}
- // assignment
+
+ //! assignment
enum_type_cons& operator=(enum_type_cons rhs)
{
val_=rhs.val_;
return *this;
}
- // assignment from enum literals
+ //! assignment from enum literals
enum_type_cons& operator=(type rhs)
{
val_=static_cast<underlying_type>(rhs);
return *this;
}
- // workaround in case there are no constructors
+ //! workaround in case there are no constructors
static enum_type_cons default_value()
{
enum_type_cons res;
res.val_=static_cast<underlying_type>(type());
return res;
}
+
static enum_type_cons convert_to(underlying_type v)
{
enum_type_cons res;
@@ -85,21 +99,26 @@
return res;
}
+
static enum_type_cons convert_to(type v)
{
enum_type_cons res;
res.val_=static_cast<underlying_type>(v);
return res;
}
- // explicit conversion in case explicit conversions are not available
+
+ //! explicit conversion function to enum type
type enum_value() const
{
return type(val_);
}
+
+ //! explicit conversion function to underlying_type
underlying_type underlying_value() const
{
return val_;
}
+#if 0
//! equal operator
friend bool operator==(enum_type_cons lhs, enum_type_cons rhs)
{
@@ -110,6 +129,7 @@
{
return lhs == rhs.val_;
}
+
//! equal operator
friend bool operator==(enum_type_cons lhs, type rhs)
{
@@ -190,7 +210,7 @@
{
return lhs.val_ > rhs;
}
-
+#endif
#if 0
//! conversions from underlying_type to enum_type_cons following the Boost.Conversion protocol
friend enum_type_cons convert_to(underlying_type v,
Modified: sandbox/enums/boost/enums/enum_type_no_cons.hpp
==============================================================================
--- sandbox/enums/boost/enums/enum_type_no_cons.hpp (original)
+++ sandbox/enums/boost/enums/enum_type_no_cons.hpp 2011-03-16 16:56:18 EDT (Wed, 16 Mar 2011)
@@ -25,43 +25,56 @@
{
namespace enums
{
- template <typename ScopedEnum, typename UT=typename ScopedEnum::type>
+ //! scoped enum type without constructors
+
+ //! param @c ScopedEnum : Struct scoping the enum.\n
+ //! param @c UT : the underlaying storage type.\n
+ //! pre @c ScopedEnum must have a nested C++98 enum @c type.\n
+ template <typename ScopedEnum, typename UT=int>
class enum_type_no_cons : public ScopedEnum
{
- public:
- typedef typename ScopedEnum::type type;
+ public:
+ //! c++98 enum type
+ typedef typename ScopedEnum::type type;
+ //! underlying type
typedef UT underlying_type;
private:
underlying_type val_;
public:
- // implicit conversion for scoped enum type only
+ //! implicit conversion to underlying_type
operator underlying_type()
{
return val_;
}
+
+ //! implicit conversion to enum type
operator type()
{
return type(val_);
}
- // assignment
+
+ //! assignment
enum_type_no_cons& operator=(enum_type_no_cons rhs)
{
val_=rhs.val_;
return *this;
}
- // assignment from enum literals
+
+ //! assignment from enum literals
enum_type_no_cons& operator=(type rhs)
{
val_=static_cast<underlying_type>(rhs);
return *this;
}
- // workaround in case there are no constructors
+
+ //! workaround in case there are no constructors
static enum_type_no_cons default_value()
{
enum_type_no_cons res;
res.val_=static_cast<underlying_type>(type());
return res;
}
+
static enum_type_no_cons convert_to(underlying_type v)
{
enum_type_no_cons res;
@@ -69,17 +82,19 @@
return res;
}
+
static enum_type_no_cons convert_to(type v)
{
enum_type_no_cons res;
res.val_=static_cast<underlying_type>(v);
return res;
}
- // explicit conversion in case explicit conversions are not available
+ //! explicit conversion function to enum type
type enum_value() const
{
return type(val_);
}
+ //! explicit conversion function to underlying_type
underlying_type underlying_value() const
{
return val_;
@@ -175,15 +190,16 @@
return lhs.val_ > rhs;
}
- // friend conversions to follow the Boost.Conversion protocol
+ //! conversions from underlying_type to enum_type_cons following the Boost.Conversion protocol
friend enum_type_no_cons convert_to(underlying_type v,
boost::dummy::type_tag<enum_type_no_cons> const&)
{
enum_type_no_cons res;
res.val_=v;
return res;
-
}
+
+ //! friend conversions from type to enum_type_cons following the Boost.Conversion protocol
friend enum_type_no_cons convert_to(type v,
boost::dummy::type_tag<enum_type_no_cons> const&)
{
@@ -191,11 +207,15 @@
res.val_=static_cast<underlying_type>(v);
return res;
}
+
+ //! conversions from enum_type_cons to underlying_type following the Boost.Conversion protocol
friend underlying_type convert_to(enum_type_no_cons v,
boost::dummy::type_tag<underlying_type> const&)
{
return boost::enums::underlying_value(v);
}
+
+ //! conversions from enum_type_cons to type following the Boost.Conversion protocol
friend type convert_to(enum_type_no_cons v,
boost::dummy::type_tag<type> const&)
{
Copied: sandbox/enums/boost/enums/scoping_type.hpp (from r70004, /sandbox/enums/boost/enums/emulator_type.hpp)
==============================================================================
--- /sandbox/enums/boost/enums/emulator_type.hpp (original)
+++ sandbox/enums/boost/enums/scoping_type.hpp 2011-03-16 16:56:18 EDT (Wed, 16 Mar 2011)
@@ -13,11 +13,11 @@
/*!
\file
\brief
- The header \c <boost/enums/emulator_type.hpp> defines the declaration of emulator_type<> meta-function.
+ The header \c <boost/enums/scoping_type.hpp> defines the declaration of scoping_type<> meta-function.
*/
-#ifndef BOOST_ENUMS_EMULATOR_TYPE_HPP
-#define BOOST_ENUMS_EMULATOR_TYPE_HPP
+#ifndef BOOST_ENUMS_SCOPING_TYPE_HPP
+#define BOOST_ENUMS_SCOPING_TYPE_HPP
#include <boost/config.hpp>
@@ -30,7 +30,7 @@
This meta-function must be specialized for each enum class.
*/
template <typename EC_type>
- struct emulator_type
+ struct scoping_type
{
//! Depending on whethere the compiler supports scoped enums or nor the nested type must be the same type or the emulated one.
//! By default this metafunction defines it as if scoped enums where supported so the specialization will be needed only when emulation is needed.
@@ -39,4 +39,4 @@
}
}
-#endif // BOOST_ENUMS_EMULATOR_TYPE_HPP
+#endif // BOOST_ENUMS_SCOPING_TYPE_HPP
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk