Le 24/01/12 22:51, Beman Dawes a écrit :
I'm currently updating some of my code to take advantage of C++0x features where available, but I also want to retain backwards compatibility with C++03. I was looking at scoped enums and noticed a thread on the mailing list by Beman Dawes discussing a scoped enum emulation implementation for Boost. I see that it's currently being used by Boost, and resides in /boost/detail/scoped_enum_emulation.hpp.
My question is, why is this an implementation detail? Would it be possible for it to be moved to Boost.Config with the other 'helper' macros like BOOST_CONSTEXPR?
Obviously it's not hard to reimplement, but I figured that it would be useful to other library users, so it would be best (imo) if it were moved somewhere public, rather than being hidden away. It isn't a full emulation of C++11's scoped enum feature. That's
On Tue, Jan 24, 2012 at 12:06 PM, Joshua Boyce <raptorfactor@raptorfactor.com> wrote: probably why it ended up in detail rather than config, although I've forgotten the detailed rationale, if there ever was any.
What do others think? Should /boost/detail/scoped_enum_emulation.hpp functionality be moved to config?
Are there any improvements that would make the emulation better, without turning something simple into something complex?
Hi, I'm working with a different emulation which uses classes. For example // enum class cv_status; BOOST_DECLARE_STRONG_ENUM_BEGIN(cv_status) { no_timeout, timeout }; BOOST_DECLARE_STRONG_ENUM_END(cv_status) The macros are defined as follows: #ifdef BOOST_NO_SCOPED_ENUMS #define BOOST_DECLARE_STRONG_ENUM_BEGIN(x) \ struct x { \ enum enum_type #define BOOST_DECLARE_STRONG_ENUM_END(x) \ enum_type v_; \ inline x() {} \ inline x(enum_type v) : v_(v) {} \ inline operator int() const {return v_;} \ friend inline bool operator ==(x lhs, int rhs) {return lhs.v_==rhs;} \ friend inline bool operator ==(int lhs, x rhs) {return lhs==rhs.v_;} \ friend inline bool operator !=(x lhs, int rhs) {return lhs.v_!=rhs;} \ friend inline bool operator !=(int lhs, x rhs) {return lhs!=rhs.v_;} \ }; #define BOOST_STRONG_ENUM_NATIVE(x) x::enum_type #else // BOOST_NO_SCOPED_ENUMS #define BOOST_DECLARE_STRONG_ENUM_BEGIN(x) enum class x #define BOOST_DECLARE_STRONG_ENUM_END(x) #define BOOST_STRONG_ENUM_NATIVE(x) x #endif // BOOST_NO_SCOPED_ENUMS While this is not yet a complete emulation of scoped enums, it has the advantage of that there is no need to use a macro to name the strong type. I don't know if it will be confusing to put provide both approaches in a single mini library. Best, Vicente