R>>typedef right_enum<color_def> color;
I>

#define explicit_enum(enum_name)\
struct enum_name { \
    enum type; \
    enum_name( type v ) : m_v( v ) {} \
  type m_v; \
    operator type() const { return m_v; } \
}; \
    enum enum_name::type


explicit_enum( Colors )
{
  Red,
  Green,
  Blue
};
    
...

Colors color = Colors::Red;

struct Log
{
    BOOST_ENUM_VALUES(Level, const char*,
        (Abort)("unrecoverable problem") 
        (Error)("recoverable problem")   
        (Alert)("unexpected behavior") 
        (Info) ("expected behavior") 
        (Trace)("normal flow of execution") 
        (Debug)("detailed object state listings") 
    )
};

BOOST_ENUM(boolean, 
    (False)
    (True) 
)

BOOST_ENUM_VALUES(VirtualKey, int,
    (Zero) (0)
    (Space)(0x20)
    (Prior)(0x21)
    (Next) (0x22)
    (End)  (0x23)
    (Home) (0x24)
)

BOOST_BITFIELD(MouseKey, 
    (LeftButton)  (0x0001)
    (RightButton) (0x0002)
    (Shift)       (0x0004)
    (Control)     (0x0008)
    (MiddleButton)(0x0010)
)

ПС>Потерялось отладочное удобство встроенного enum-а: если в MSVC6-отладчике навести курсор на enum-переменную, то отладчик покажет значение переменной в символьном виде. С Вашим power-enum-ом так легко не получится .

namespace detail
{
    template <bool cond, typename T1, typename T2>
    struct if_
    {
        typedef T1 type;
    };

    template <typename T1, typename T2>
    struct if_<false, T1, T2>
    {
        typedef T2 type;
    };
}

template <typename T, typename InternalType = int>
class enum_class : public T
{
    typedef typename T::type    enum_t;
    typedef InternalType        internal_t;
    typedef typename detail::if_<sizeof(enum_t) == sizeof(internal_t), enum_t, internal_t>::type
        debug_helper_t;

public:
    enum_class(enum_t val = enum_t())
        : val_(val)
    {}

#define DEFINE_BINARY_OP(op)                            \
    bool operator op(enum_class const & other) const    \
    {                                                   \
        return val_ op other.val_;                      \
    }                                                   \

    DEFINE_BINARY_OP(==);
    DEFINE_BINARY_OP(!=);
    DEFINE_BINARY_OP(<);
    DEFINE_BINARY_OP(<=);
    DEFINE_BINARY_OP(>);
    DEFINE_BINARY_OP(>=);

#undef DEFINE_BINARY_OP

    enum_class & operator++()
    {
        ++val_;
        return *this;
    }

    enum_class operator++(int)
    {
        enum_class copy(*this);
        ++(*this);
        return copy;
    }

    enum_class & operator--()
    {
        --val_;
        return *this;
    }

    enum_class operator--(int)
    {
        enum_class copy(*this);
        --(*this);
        return copy;
    }

    enum_t get() const
    {
        return enum_t(val_);
    }

private:
    union
    {
        internal_t      val_;
        debug_helper_t  debug_helper_;
    };
};

template <class Int>
struct EnumBase
 {
  Int val;

  explicit EnumBase(Int val_) : val(val_) {}

  operator Int() const { return val; }
 };

struct MyEnum : EnumBase<int>
 {
  enum Type
   { 
    A=100,
    B,
    C 
   };

  explicit MyEnum(int x) : EnumBase<int>(x) {}

  MyEnum(Type x) : EnumBase<int>(x) {}
 };

struct MyEnumExt : MyEnum
 {
  enum Type
   { 
    P=200,
    Q,
    R 
   };

  explicit MyEnumExt(int x) : MyEnum(x) {}

  MyEnumExt(MyEnum::Type x) : MyEnum(x) {}

  MyEnumExt(Type x) : MyEnum(x) {}
 };

S>>      NamedEnumPair<Enum> const* pairs = typename Base_t::enum_pairs();
S>>

 namespace internal
 {
   struct MyEnumWrapper
   {
     enum Enum{a, b, c};
  
     static NamedEnumPair<Enum> const*
     enum_pairs()
     {
       static NamedEnumPair<Enum> const pairs[] =
       {
         NamedEnumPair<Enum>(a, "A"),
         NamedEnumPair<Enum>(b, "B"),
         NamedEnumPair<Enum>(c, "C")
       };
       return pairs;
     }

     static size_t
     size() { return 3; }
   };
 }
 typedef NamedEnumWrapper<Internal::MyEnumWrapper> MyNamedEnum;

E>А так не так уж и плохо, ИМХО

MyEnum enum = MyEnum::a;
logger << "Запрос параметра: " << enum

ПС>>Потерялось отладочное удобство встроенного enum-а: если в MSVC6-отладчике навести курсор на enum-переменную, то отладчик покажет значение переменной в символьном виде. С Вашим power-enum-ом так легко не получится .

right_enum<*>{
preview([(type)($e.v)])
}