[Boost-commit] svn:boost r65715 - sandbox/opaque/boost/opaque

Subject: [Boost-commit] svn:boost r65715 - sandbox/opaque/boost/opaque
From: vicente.botet_at_[hidden]
Date: 2010-10-01 17:50:01

Author: viboes
Date: 2010-10-01 17:50:00 EDT (Fri, 01 Oct 2010)
New Revision: 65715
URL: http://svn.boost.org/trac/boost/changeset/65715

Log:
Opaque: 
* Continue defining macros so inheritance is reduced.

Text files modified: 
   sandbox/opaque/boost/opaque/combined_operators.hpp |   362 ++++++++++++++++++++++++--------------- 
   sandbox/opaque/boost/opaque/operators.hpp          |    70 +-----                                  
   2 files changed, 242 insertions(+), 190 deletions(-)

Modified: sandbox/opaque/boost/opaque/combined_operators.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/combined_operators.hpp	(original)
+++ sandbox/opaque/boost/opaque/combined_operators.hpp	2010-10-01 17:50:00 EDT (Fri, 01 Oct 2010)
@@ -32,10 +32,10 @@
         };
     };
 
-    template <typename Final, typename Base, typename Bool=bool>
-    struct equality_comparable1 : Base {
-        BOOST_OPAQUE_EQUALITY_COMPARABLE1(Final,Bool)
-    };
+    //~ template <typename Final, typename Base, typename Bool=bool>
+    //~ struct equality_comparable1 : Base {
+        //~ BOOST_OPAQUE_EQUALITY_COMPARABLE1(Final,Bool)
+    //~ };
 
 #define BOOST_OPAQUE_LESS_THAN_COMPARABLE1(Final,Bool) \
         BOOST_OPAQUE_USING_LESS_THAN(Final,Bool) \
@@ -51,10 +51,10 @@
         };
     };
 
-    template <typename Final, typename Base, typename Bool=bool>
-    struct less_than_comparable1 : Base {
-        BOOST_OPAQUE_LESS_THAN_COMPARABLE1(Final,Bool)
-    };
+    //~ template <typename Final, typename Base, typename Bool=bool>
+    //~ struct less_than_comparable1 : Base {
+        //~ BOOST_OPAQUE_LESS_THAN_COMPARABLE1(Final,Bool)
+    //~ };
 
 
 #define BOOST_OPAQUE_ADDABLE1(Final) \
@@ -69,10 +69,10 @@
     };
 
 
-    template <typename Final, typename Base>
-    struct addable1 : Base  {
-        BOOST_OPAQUE_ADDABLE1(Final)
-    };
+    //~ template <typename Final, typename Base>
+    //~ struct addable1 : Base  {
+        //~ BOOST_OPAQUE_ADDABLE1(Final)
+    //~ };
 
 #define BOOST_OPAQUE_SUBTRACTABLE1(Final) \
         BOOST_OPAQUE_USING_MINUS_ASSIGN(Final) \
@@ -86,11 +86,11 @@
     };
 
 
-    template <typename Final, typename Base>
-    struct subtractable1 : Base
-    {
-        BOOST_OPAQUE_SUBTRACTABLE1(Final)
-    };
+    //~ template <typename Final, typename Base>
+    //~ struct subtractable1 : Base
+    //~ {
+        //~ BOOST_OPAQUE_SUBTRACTABLE1(Final)
+    //~ };
 
 
 #define BOOST_OPAQUE_MULTIPLIABLE1(Final) \
@@ -104,10 +104,10 @@
         };
     };
 
-    template <typename Final, typename Base>
-    struct multipliable1 : Base {
-            BOOST_OPAQUE_MULTIPLIABLE1(Final)
-    };
+    //~ template <typename Final, typename Base>
+    //~ struct multipliable1 : Base {
+            //~ BOOST_OPAQUE_MULTIPLIABLE1(Final)
+    //~ };
 
 #define BOOST_OPAQUE_DIVIDABLE1(Final) \
         BOOST_OPAQUE_USING_DIVIDE_ASSIGN(Final) \
@@ -120,11 +120,11 @@
         };
     };
 
-    template <typename Final, typename Base>
-    struct dividable1 : Base
-    {
-            BOOST_OPAQUE_DIVIDABLE1(Final)
-    };
+    //~ template <typename Final, typename Base>
+    //~ struct dividable1 : Base
+    //~ {
+            //~ BOOST_OPAQUE_DIVIDABLE1(Final)
+    //~ };
 
 #define BOOST_OPAQUE_MODABLE1(Final) \
         BOOST_OPAQUE_USING_MODULUS_ASSIGN(Final) \
@@ -136,64 +136,108 @@
             BOOST_OPAQUE_MODABLE1(Final)
         };
     };
-    template <typename Final, typename Base>
-    struct modable1 : Base {
-            BOOST_OPAQUE_MODABLE1(Final)
-    };
 
 #define BOOST_OPAQUE_BITWISE_XORABLE1(Final) \
         BOOST_OPAQUE_USING_BITWISE_XOR_ASSIGN(Final) \
         BOOST_OPAQUE_USING_BITWISE_XOR(Final)
 
-    struct using_xorable1 {
+    struct using_bitwise_xorable1 {
         template <typename Final, typename UT, typename Base>
         struct type : Base {
             BOOST_OPAQUE_BITWISE_XORABLE1(Final)
         };
     };
 
-    template <typename Final, typename Base>
-    struct xorable1 : boost::xorable1<Final, ope::bitwise_xor_assign<Final, Base> > {};
+    //~ template <typename Final, typename Base>
+    //~ struct bitwise_xorable1 : Base {
+        //~ BOOST_OPAQUE_BITWISE_XORABLE1(Final)
+    //~ };
 
 #define BOOST_OPAQUE_BITWISE_ANDABLE1(Final) \
         BOOST_OPAQUE_USING_BITWISE_AND_ASSIGN(Final) \
         BOOST_OPAQUE_USING_BITWISE_AND(Final)
 
-    struct using_andable1 {
+    struct using_bitwise_andable1 {
         template <typename Final, typename UT, typename Base>
         struct type : Base {
             BOOST_OPAQUE_BITWISE_ANDABLE1(Final)
         };
     };
 
-    template <typename Final, typename Base>
-    struct andable1 : boost::andable1<Final, ope::bitwise_and_assign<Final, Base> > {};
+    //~ template <typename Final, typename Base>
+    //~ struct bitwise_andable1 : Base {
+            //~ BOOST_OPAQUE_BITWISE_ANDABLE1(Final)
+    //~ };
 
 #define BOOST_OPAQUE_BITWISE_ORABLE1(Final) \
         BOOST_OPAQUE_USING_BITWISE_OR_ASSIGN(Final) \
         BOOST_OPAQUE_USING_BITWISE_OR(Final)
 
-    struct using_orable1 {
+    struct using_bitwise_orable1 {
         template <typename Final, typename UT, typename Base>
         struct type : Base {
             BOOST_OPAQUE_BITWISE_ORABLE1(Final)
         };
     };
 
-    template <typename Final, typename Base>
-    struct orable1 : boost::orable1<Final, ope::bitwise_or_assign<Final, Base> > {};
+    //~ template <typename Final, typename Base>
+    //~ struct bitwise_orable1 : Base {
+        //~ BOOST_OPAQUE_BITWISE_ORABLE1(Final)
+    //~ };
 
-    template <typename Final, typename Base>
-    struct incrementable : boost::incrementable<Final, ope::pre_increment<Final, Base> > {};
+#define BOOST_OPAQUE_INCREMENTABLE(Final) \
+        BOOST_OPAQUE_USING_PRE_INCREMENT(Final) \
+        BOOST_OPAQUE_USING_POST_INCREMENT(Final)
 
-    template <typename Final, typename Base>
-    struct decrementable : boost::decrementable<Final, ope::pre_decrement<Final, Base> > {};
+    //~ template <typename Final, typename Base>
+    //~ struct incrementable : boost::incrementable<Final, ope::pre_increment<Final, Base> > {};
 
-    template <typename Final, typename Base>
-    struct left_shiftable1 : boost::left_shiftable1<Final, ope::left_shift_assign<Final, Base> > {};
+    struct using_incrementable {
+        template <typename Final, typename UT, typename Base>
+        struct type : Base
+        {
+            BOOST_OPAQUE_INCREMENTABLE(Final)
+        };
+    };
+
+#define BOOST_OPAQUE_DECREMENTABLE(Final) \
+        BOOST_OPAQUE_USING_PRE_DECREMENT(Final) \
+        BOOST_OPAQUE_USING_POST_DECREMENT(Final)
 
-    template <typename Final, typename Base>
-    struct right_shiftable1 : boost::right_shiftable1<Final, ope::right_shift_assign<Final, Base> > {};
+    //~ template <typename Final, typename Base>
+    //~ struct decrementable : boost::decrementable<Final, ope::pre_decrement<Final, Base> > {};
+
+    struct using_decrementable {
+        template <typename Final, typename UT, typename Base>
+        struct type : Base
+        {
+            BOOST_OPAQUE_DECREMENTABLE(Final)
+        };
+    };
+        
+#define BOOST_OPAQUE_LEFT_SHIFTABLE1(Final) \
+        BOOST_OPAQUE_USING_LEFT_SHIFT_ASSIGN(Final) \
+        BOOST_OPAQUE_USING_LEFT_SHIFT1(Final)
+
+    struct using_left_shiftable1 {
+        template <typename Final, typename UT, typename Base>
+        struct type : Base
+        {
+            BOOST_OPAQUE_LEFT_SHIFTABLE1(Final)
+        };
+    };
+
+#define BOOST_OPAQUE_RIGHT_SHIFTABLE1(Final) \
+        BOOST_OPAQUE_USING_RIGHT_SHIFT_ASSIGN(Final) \
+        BOOST_OPAQUE_USING_RIGHT_SHIFT1(Final)
+
+    struct using_right_shiftable1 {
+        template <typename Final, typename UT, typename Base>
+        struct type : Base
+        {
+            BOOST_OPAQUE_RIGHT_SHIFTABLE1(Final)
+        };
+    };
 
 #define BOOST_OPAQUE_PARTIALLY_ORDERED1(Final,Bool) \
         BOOST_OPAQUE_USING_LESS_THAN(Final,Bool) \
@@ -204,13 +248,11 @@
     template <typename Bool=bool>
     struct using_partially_ordered1 {
         template <typename Final, typename UT, typename Base>
-        struct type : Base {
-            BOOST_OPAQUE_PARTIALLY_ORDERED1(Final,Bool)
+        struct type : boost::partially_ordered1<Final, Base > {
+            BOOST_OPAQUE_USING_LESS_THAN(Final,Bool)
         };
     };
 
-    template <typename Final, typename Base>
-    struct partially_ordered1 : boost::partially_ordered1<Final, ope::less_than<Final, Base> > {};
 
 #define BOOST_OPAQUE_TOTALY_ORDERED1(Final,Bool) \
         BOOST_OPAQUE_EQUALITY_COMPARABLE1(Final,Bool) \
@@ -224,12 +266,6 @@
         };
     };
 
-    template <class Final, class Base, typename Bool=bool >
-    struct totally_ordered1 : Base
-    {
-        BOOST_OPAQUE_TOTALY_ORDERED1(Final,Bool)
-    };
-
     //~ template <class T, class U, class Base = base_new_type >
     //~ struct additive2
         //~ : opaque::addable2<T, U
@@ -248,12 +284,6 @@
         };
     };
 
-    template <class Final, class Base = base_new_type >
-    struct additive1 : Base
-    {
-            BOOST_OPAQUE_ADDITIVE1(Final)
-    };
-
     //~ template <class T, class U, class Base = base_new_type >
     //~ struct multiplicative2
         //~ : opaque::multipliable2<T, U
@@ -272,12 +302,6 @@
         };
     };
 
-    template <class Final, class Base = base_new_type >
-    struct multiplicative1 : Base
-    {
-            BOOST_OPAQUE_MULTIPLICATIVE1(Final)
-    };
-
     //~ template <class T, class U, class Base = base_new_type >
     //~ struct integer_multiplicative2
         //~ : opaque::multiplicative2<T, U
@@ -285,14 +309,17 @@
           //~ > > {};
 
     #define BOOST_OPAQUE_INTEGER_MULTIPLICATIVE1(Final) \
-        BOOST_OPAQUE_MULTIPLIABLE1(Final) \
+        BOOST_OPAQUE_MULTIPLICATIVE1(Final) \
         BOOST_OPAQUE_MODABLE1(Final)
 
-    template <class T, class Base = base_new_type >
     struct integer_multiplicative1
-        : opaque::multiplicative1<T
-        , opaque::modable1<T, Base
-          > > {};
+    {    
+        template <class Final, class UT, class Base = base_new_type >
+        struct type : Base
+        {
+            BOOST_OPAQUE_INTEGER_MULTIPLICATIVE1(Final)
+        };
+    };
 
     //~ template <class T, class U, class Base = base_new_type >
     //~ struct arithmetic2
@@ -300,11 +327,19 @@
         //~ , opaque::multiplicative2<T, U, Base
           //~ > > {};
 
-    template <class Final, class Base = base_new_type >
-    struct arithmetic1
-        : opaque::additive1<Final
-        , opaque::multiplicative1<Final, Base
-          > > {};
+    #define BOOST_OPAQUE_ARITHMETIC1(Final) \
+        BOOST_OPAQUE_ADDITIVE1(Final) \
+        BOOST_OPAQUE_MULTIPLICATIVE1(Final)
+
+
+    struct using_arithmetic1
+    {    
+        template <class Final, class UT, class Base = base_new_type >
+        struct type : Base
+        {
+            BOOST_OPAQUE_ARITHMETIC1(Final)
+        };
+    };
 
     //~ template <class T, class U, class Base = base_new_type >
     //~ struct integer_arithmetic2
@@ -312,11 +347,18 @@
         //~ , integer_multiplicative2<T, U, Base
           //~ > > {};
 
-    template <class T, class Base = base_new_type >
-    struct integer_arithmetic1
-        : opaque::additive1<T
-        , opaque::integer_multiplicative1<T, Base
-          > > {};
+    #define BOOST_OPAQUE_INTEGER_ARITHMETIC1(Final) \
+        BOOST_OPAQUE_ADDITIVE1(Final) \
+        BOOST_OPAQUE_INTEGER_MULTIPLICATIVE1(Final)
+
+    struct using_integer_arithmetic1
+    {    
+        template <class Final, class UT, class Base = base_new_type >
+        struct type : Base
+        {
+            BOOST_OPAQUE_INTEGER_ARITHMETIC1(Final)
+        };
+    };
 
     //~ template <class T, class U, class Base = base_new_type >
     //~ struct bitwise2
@@ -325,18 +367,32 @@
         //~ , opaque::orable2<T, U, Base
           //~ > > > {};
 
-    template <class T, class Base = base_new_type >
-    struct bitwise1
-        : opaque::xorable1<T
-        , opaque::andable1<T
-        , opaque::orable1<T, Base
-          > > > {};
-
-    template <class T, class Base = base_new_type >
-    struct unit_steppable
-        : opaque::incrementable<T
-        , opaque::decrementable<T, Base
-          > > {};
+    #define BOOST_OPAQUE_BITWISE1(Final) \
+        BOOST_OPAQUE_BITWISE_XORABLE1(Final) \
+        BOOST_OPAQUE_BITWISE_ANDABLE1(Final) \
+        BOOST_OPAQUE_BITWISE_ORABLE1(Final)
+
+    struct using_bitwise1
+    {    
+        template <class Final, class UT, class Base = base_new_type >
+        struct type : Base
+        {
+            BOOST_OPAQUE_BITWISE1(Final)
+        };
+    };
+
+    #define BOOST_OPAQUE_UNIT_STEPABLE(Final) \
+        BOOST_OPAQUE_INCREMENTABLE(Final) \
+        BOOST_OPAQUE_DECREMENTABLE(Final)
+
+    struct using_unit_steppable
+    {    
+        template <class Final, class UT, class Base = base_new_type >
+        struct type : Base
+        {       
+            BOOST_OPAQUE_UNIT_STEPABLE(Final)
+        };
+    };
 
     //~ template <class T, class U, class Base = base_new_type >
     //~ struct shiftable2
@@ -344,11 +400,18 @@
         //~ , opaque::right_shiftable2<T, U, Base
           //~ > > {};
 
-    template <class T, class Base = base_new_type >
-    struct shiftable1
-        : opaque::left_shiftable1<T
-        , opaque::right_shiftable1<T, Base
-          > > {};
+    #define BOOST_OPAQUE_SHIFTABLE1(Final) \
+        BOOST_OPAQUE_LEFT_SHIFTABLE1(Final) \
+        BOOST_OPAQUE_RIGHT_SHIFTABLE1(Final)
+
+    struct using_shiftable1
+    {
+        template <class Final, class UT, class Base = base_new_type >
+        struct type : Base
+        {
+            BOOST_OPAQUE_SHIFTABLE1(Final)
+        };
+    };
 
     //~ template <class T, class U, class Base = base_new_type >
     //~ struct ring_operators2
@@ -357,11 +420,18 @@
         //~ , opaque::multipliable2<T, U, Base
           //~ > > > {};
 
-    template <class T, class Base = base_new_type >
-    struct ring_operators1
-        : opaque::additive1<T
-        , opaque::multipliable1<T, Base
-          > > {};
+    #define BOOST_OPAQUE_RING1(Final) \
+        BOOST_OPAQUE_ADDITIVE1(Final) \
+        BOOST_OPAQUE_MULTIPLICATIVE1(Final)
+
+    struct using_ring_operators1
+    {
+        template <class Final, class UT, class Base = base_new_type >
+        struct type: Base
+        {
+            BOOST_OPAQUE_RING1(Final)
+        };
+    };
 
     //~ template <class T, class U, class Base = base_new_type >
     //~ struct ordered_ring_operators2
@@ -369,11 +439,19 @@
         //~ , opaque::totally_ordered2<T, U, Base
           //~ > > {};
 
-    template <class T, class UT, class Base = base_new_type >
-    struct ordered_ring_operators1
-        : opaque::ring_operators1<T
-        , opaque::totally_ordered1<T, Base
-          > > {};
+    #define BOOST_OPAQUE_ORDERED_RING1(Final, Bool) \
+        BOOST_OPAQUE_RING1(Final) \
+        BOOST_OPAQUE_TOTALY_ORDERED1(Final,Bool)
+
+    template <typename Bool=bool>
+    struct using_ordered_ring_operators1 
+    {
+        template <class Final, class UT, class Base = base_new_type>
+        struct type : Base
+        {
+            BOOST_OPAQUE_ORDERED_RING1(Final,Bool)
+        };
+    };
 
     //~ template <class T, class U, class Base = base_new_type >
     //~ struct field_operators2
@@ -382,11 +460,18 @@
         //~ , opaque::dividable2_left<T, U, Base
           //~ > > > {};
 
-    template <class T, class Base = base_new_type >
-    struct field_operators1
-        : opaque::ring_operators1<T
-        , opaque::dividable1<T, Base
-          > > {};
+    #define BOOST_OPAQUE_FIELD1(Final) \
+        BOOST_OPAQUE_RING1(Final) \
+        BOOST_OPAQUE_DIVIDABLE1(Final)
+
+    struct using_field_operators1 
+    {
+        template <class Final, class Base = base_new_type>
+        struct type: Base
+        {
+            BOOST_OPAQUE_FIELD1(Final)
+        };
+    };
 
     //~ template <class T, class U, class Base = base_new_type >
     //~ struct ordered_field_operators2
@@ -394,33 +479,34 @@
         //~ , opaque::totally_ordered2<T, U, Base
           //~ > > {};
 
-    template <class T, class UT, class Base = base_new_type >
-    struct ordered_field_operators1
-        : opaque::field_operators1<T
-        , opaque::totally_ordered1<T, Base
-          > > {};
+    #define BOOST_OPAQUE_ORDERED_FIELD1(Final, Bool) \
+        BOOST_OPAQUE_FIELD1(Final) \
+        BOOST_OPAQUE_TOTALY_ORDERED1(Final,Bool)
 
+    template <typename Bool=bool>
+    struct using_ordered_field_operators1 
+    {
+        template <class Final, class UT, class Base = base_new_type>
+        struct type : Base
+        {
+            BOOST_OPAQUE_ORDERED_FIELD1(Final,Bool)
+        };
+    };
 
 
 }
-    template <typename T>
+    template <typename T, typename Bool=bool>
     struct inherited_from_undelying {
-            template <typename Final, typename UT, typename Base>
-            struct type :
-                opaque::totally_ordered1< Final
-                ,   opaque::integer_arithmetic1< Final
-                    ,   boost::bitwise1< Final
-                        ,   opaque::unit_steppable< Final
-                            ,   opaque::ope::unary_plus< Final
-                                ,   opaque::ope::unary_minus< Final
-                                    ,   Base
-                                    >
-                                >
-                            >
-                        >
-                    >
-                >
-            {};
+        template <typename Final, typename UT, typename Base>
+        struct type : Base
+        {
+            BOOST_OPAQUE_TOTALY_ORDERED1(Final,Bool)
+            BOOST_OPAQUE_INTEGER_ARITHMETIC1(Final)
+            BOOST_OPAQUE_BITWISE1(Final)
+            BOOST_OPAQUE_UNIT_STEPABLE(Final)
+            BOOST_OPAQUE_USING_UNARY_PLUS(Final)
+            BOOST_OPAQUE_USING_UNARY_MINUS(Final)
+        };
     };
 }
 

Modified: sandbox/opaque/boost/opaque/operators.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/operators.hpp	(original)
+++ sandbox/opaque/boost/opaque/operators.hpp	2010-10-01 17:50:00 EDT (Fri, 01 Oct 2010)
@@ -84,11 +84,6 @@
             return Bool(Final::underlying(this) < rhs.underlying());\
         }
 
-    template <typename Final, typename Base, typename Bool=bool>
-    struct less_than : Base {
-        BOOST_OPAQUE_USING_LESS_THAN(Final, Bool)
-    };
-
     template <typename Bool=bool>
     struct using_less_than {
         template <typename Final, typename UT, typename Base>
@@ -145,10 +140,6 @@
             return Bool(Final::underlying(this) == rhs.underlying());\
         }
 
-    template <typename Final, typename Base, typename Bool=bool>
-    struct equal : Base {
-        BOOST_OPAQUE_USING_EQUAL(Final,Bool)
-    };
     template <typename Bool=bool>
     struct using_equal {
         template <typename Final, typename UT, typename Base>
@@ -163,11 +154,6 @@
             return Bool(Final::underlying(this) != rhs.underlying());\
         }
 
-
-    template <typename Final, typename Base, typename Bool=bool>
-    struct not_equal : Base {
-        BOOST_OPAQUE_USING_NOT_EQUAL(Final,Bool)
-    };
     template <typename Bool=bool>
     struct using_not_equal {
         template <typename Final, typename UT, typename Base>
@@ -183,10 +169,6 @@
             return Final::final(this); \
         }
 
-    template <typename Final, typename Base>
-    struct plus_assign : Base {
-        BOOST_OPAQUE_USING_PLUS_ASSIGN(Final)
-    };
     struct using_plus_assign {
         template <typename Final, typename UT, typename Base>
         struct type: Base {
@@ -201,10 +183,6 @@
             return Final::final(this); \
         }
 
-    template <typename Final, typename Base>
-    struct minus_assign : Base {
-        BOOST_OPAQUE_USING_MINUS_ASSIGN(Final)
-    };
     struct using_minus_assign {
         template <typename Final, typename UT, typename Base>
         struct type: Base {
@@ -219,10 +197,6 @@
             return Final::final(this); \
         }
 
-    template <typename Final, typename Base>
-    struct multiply_assign : Base {
-        BOOST_OPAQUE_USING_MULTIPLY_ASSIGN(Final)
-    };
     struct using_multiply_assign {
         template <typename Final, typename UT, typename Base>
         struct type: Base {
@@ -237,10 +211,6 @@
             return Final::final(this); \
         }
 
-    template <typename Final, typename Base>
-    struct divide_assign : Base {
-        BOOST_OPAQUE_USING_DIVIDE_ASSIGN(Final)
-    };
     struct using_divide_assign {
         template <typename Final, typename UT, typename Base>
         struct type: Base {
@@ -255,10 +225,6 @@
             return Final::final(this); \
         }
 
-    template <typename Final, typename Base>
-    struct modulus_assign : Base {
-        BOOST_OPAQUE_USING_MODULUS_ASSIGN(Final)
-    };
     struct using_modulus_assign {
         template <typename Final, typename UT, typename Base>
         struct type: Base {
@@ -273,10 +239,6 @@
             return Final::final(this); \
         }
 
-    template <typename Final, typename Base>
-    struct bitwise_xor_assign : Base {
-        BOOST_OPAQUE_USING_BITWISE_XOR_ASSIGN(Final)
-    };
     struct using_bitwise_xor_assign {
         template <typename Final, typename UT, typename Base>
         struct type: Base {
@@ -297,10 +259,6 @@
             BOOST_OPAQUE_USING_BITWISE_AND_ASSIGN(Final)
         };
     };
-    template <typename Final, typename Base>
-    struct bitwise_and_assign : Base {
-        BOOST_OPAQUE_USING_BITWISE_AND_ASSIGN(Final)
-    };
 
 #define BOOST_OPAQUE_USING_BITWISE_OR_ASSIGN(Final) \
     public :\
@@ -315,10 +273,6 @@
             BOOST_OPAQUE_USING_BITWISE_OR_ASSIGN(Final)
         };
     };
-    template <typename Final, typename Base>
-    struct bitwise_or_assign : Base {
-        BOOST_OPAQUE_USING_BITWISE_OR_ASSIGN(Final)
-    };
 
 #define BOOST_OPAQUE_USING_LEFT_SHIFT_ASSIGN(Final) \
     public :\
@@ -459,7 +413,7 @@
     // Increment and decrement
 #define BOOST_OPAQUE_USING_PRE_INCREMENT(Final) \
     public :\
-        Final& operator++()  { \
+        Final operator++()  { \
             ++Final::underlying(this); \
             return Final::final(this); \
         }
@@ -477,7 +431,7 @@
 
 #define BOOST_OPAQUE_USING_PRE_DECREMENT(Final) \
     public :\
-        Final& operator--()  { \
+        Final operator--()  { \
             --Final::underlying(this); \
             return Final::final(this); \
         }
@@ -495,8 +449,8 @@
 
 #define BOOST_OPAQUE_USING_POST_INCREMENT(Final) \
     public :\
-        Final& operator--()  { \
-            typename Final::underlying_type nrv(*this); \
+        Final operator++(int)  { \
+            Final nrv(Final::final(this)); \
             Final::underlying(this)++; \
             return nrv; \
         }
@@ -514,8 +468,8 @@
 
 #define BOOST_OPAQUE_USING_POST_DECREMENT(Final) \
     public :\
-        Final& operator--()  { \
-            typename Final::underlying_type nrv(*this); \
+        Final operator--(int)  { \
+            Final nrv(Final::final(this)); \
             Final::underlying(this)--; \
             return nrv; \
         }
@@ -594,6 +548,18 @@
             return Final(Final::underlying(this) & rhs.underlying()); \
         }
 
+#define BOOST_OPAQUE_USING_LEFT_SHIFT1(Final) \
+    public :\
+        Final operator<<(const Final& rhs) const { \
+            return Final(Final::underlying(this) << rhs.underlying()); \
+        }
+
+#define BOOST_OPAQUE_USING_RIGHT_SHIFT1(Final) \
+    public :\
+        Final operator>>(const Final& rhs) const { \
+            return Final(Final::underlying(this) >> rhs.underlying()); \
+        }
+
 
 }