Boost logo

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