[Boost-commit] svn:boost r70759 - sandbox/opaque/boost/opaque/meta_mixin

Subject: [Boost-commit] svn:boost r70759 - sandbox/opaque/boost/opaque/meta_mixin
From: vicente.botet_at_[hidden]
Date: 2011-03-30 16:31:45

Author: viboes
Date: 2011-03-30 16:31:44 EDT (Wed, 30 Mar 2011)
New Revision: 70759
URL: http://svn.boost.org/trac/boost/changeset/70759

Log:
Opaque: remove template parameter from 2 macros
Text files modified: 
   sandbox/opaque/boost/opaque/meta_mixin/combined_operators.hpp |   151 ++++++++++++--------------              
   sandbox/opaque/boost/opaque/meta_mixin/operators.hpp          |   220 +++++++++++++++++++++++++-------------- 
   2 files changed, 208 insertions(+), 163 deletions(-)

Modified: sandbox/opaque/boost/opaque/meta_mixin/combined_operators.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/meta_mixin/combined_operators.hpp	(original)
+++ sandbox/opaque/boost/opaque/meta_mixin/combined_operators.hpp	2011-03-30 16:31:44 EDT (Wed, 30 Mar 2011)
@@ -63,17 +63,17 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_LESS_THAN_COMPARABLE2(Final, U, Bool) \
-        BOOST_OPAQUE_USING_LESS_THAN2(Final, U,Bool) \
-        BOOST_OPAQUE_USING_LESS_THAN_EQUAL2(Final, U,Bool) \
-        BOOST_OPAQUE_USING_GREATER_THAN2(Final, U,Bool) \
-        BOOST_OPAQUE_USING_GREATER_THAN_EQUAL2(Final, U,Bool)
+#define BOOST_OPAQUE_USING_LESS_THAN_COMPARABLE2(Final, Bool) \
+        BOOST_OPAQUE_USING_LESS_THAN2(Final,Bool) \
+        BOOST_OPAQUE_USING_LESS_THAN_EQUAL2(Final,Bool) \
+        BOOST_OPAQUE_USING_GREATER_THAN2(Final,Bool) \
+        BOOST_OPAQUE_USING_GREATER_THAN_EQUAL2(Final,Bool)
 
-    template <typename U, typename Bool=bool>
+    template <typename Bool=bool>
     struct using_less_than_comparable2 {
         template <typename Final, typename Base>
         struct type : Base {
-            BOOST_OPAQUE_USING_LESS_THAN_COMPARABLE2(Final, U, Bool)
+            BOOST_OPAQUE_USING_LESS_THAN_COMPARABLE2(Final, Bool)
         };
     };
 
@@ -90,15 +90,14 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_ADDABLE2(Final,U) \
+#define BOOST_OPAQUE_USING_ADDABLE2(Final) \
         BOOST_OPAQUE_USING_PLUS_ASSIGN(Final) \
-        BOOST_OPAQUE_USING_PLUS2(Final,U)
+        BOOST_OPAQUE_USING_PLUS2(Final)
 
-    template <typename U>
     struct using_addable2 {
         template <typename Final, typename Base>
         struct type : Base {
-        BOOST_OPAQUE_USING_ADDABLE2(Final, U)
+        BOOST_OPAQUE_USING_ADDABLE2(Final)
         };
     };
 
@@ -115,15 +114,14 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_SUBTRACTABLE2(Final, U) \
+#define BOOST_OPAQUE_USING_SUBTRACTABLE2(Final) \
         BOOST_OPAQUE_USING_MINUS_ASSIGN(Final) \
-        BOOST_OPAQUE_USING_MINUS2(Final, U)
+        BOOST_OPAQUE_USING_MINUS2(Final)
 
-    template <typename U>
     struct using_subtractable2 {
         template <typename Final, typename Base>
         struct type : Base {
-            BOOST_OPAQUE_USING_SUBTRACTABLE2(Final, U)
+            BOOST_OPAQUE_USING_SUBTRACTABLE2(Final)
         };
     };
 
@@ -140,15 +138,14 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_MULTIPLIABLE2(Final, U) \
+#define BOOST_OPAQUE_USING_MULTIPLIABLE2(Final) \
         BOOST_OPAQUE_USING_MULTIPLY_ASSIGN(Final) \
-        BOOST_OPAQUE_USING_MULTIPLY2(Final, U)
+        BOOST_OPAQUE_USING_MULTIPLY2(Final)
 
-    template <typename U>
     struct using_multipliable2 {
         template <typename Final, typename Base>
         struct type : Base {
-            BOOST_OPAQUE_USING_MULTIPLIABLE2(Final, U)
+            BOOST_OPAQUE_USING_MULTIPLIABLE2(Final)
         };
     };
 
@@ -165,15 +162,14 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_DIVIDABLE2(Final, U) \
+#define BOOST_OPAQUE_USING_DIVIDABLE2(Final) \
         BOOST_OPAQUE_USING_DIVIDE_ASSIGN(Final) \
-        BOOST_OPAQUE_USING_DIVIDE2(Final, U)
+        BOOST_OPAQUE_USING_DIVIDE2(Final)
 
-    template <typename U>
     struct using_dividable2 {
         template <typename Final, typename Base>
         struct type : Base {
-            BOOST_OPAQUE_USING_DIVIDABLE2(Final, U)
+            BOOST_OPAQUE_USING_DIVIDABLE2(Final)
         };
     };
 
@@ -203,15 +199,14 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_BITWISE_XORABLE2(Final, U) \
+#define BOOST_OPAQUE_USING_BITWISE_XORABLE2(Final) \
         BOOST_OPAQUE_USING_BITWISE_XOR_ASSIGN(Final) \
-        BOOST_OPAQUE_USING_BITWISE_XOR2(Final, U)
+        BOOST_OPAQUE_USING_BITWISE_XOR2(Final)
 
-    template <typename U>
     struct using_bitwise_xorable2 {
         template <typename Final, typename Base>
         struct type : Base {
-            BOOST_OPAQUE_USING_BITWISE_XORABLE2(Final, U)
+            BOOST_OPAQUE_USING_BITWISE_XORABLE2(Final)
         };
     };
 
@@ -228,15 +223,14 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_BITWISE_ANDABLE2(Final, U) \
+#define BOOST_OPAQUE_USING_BITWISE_ANDABLE2(Final) \
         BOOST_OPAQUE_USING_BITWISE_AND_ASSIGN(Final) \
-        BOOST_OPAQUE_USING_BITWISE_AND2(Final, U)
+        BOOST_OPAQUE_USING_BITWISE_AND2(Final)
 
-    template <typename U>
     struct using_bitwise_andable2 {
         template <typename Final, typename Base>
         struct type : Base {
-            BOOST_OPAQUE_USING_BITWISE_ANDABLE2(Final, U)
+            BOOST_OPAQUE_USING_BITWISE_ANDABLE2(Final)
         };
     };
 
@@ -253,15 +247,14 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_BITWISE_ORABLE2(Final, U) \
+#define BOOST_OPAQUE_USING_BITWISE_ORABLE2(Final) \
         BOOST_OPAQUE_USING_BITWISE_OR_ASSIGN(Final) \
-        BOOST_OPAQUE_USING_BITWISE_OR2(Final, U)
+        BOOST_OPAQUE_USING_BITWISE_OR2(Final)
 
-    template <typename U>
     struct using_bitwise_orable2 {
         template <typename Final, typename Base>
         struct type : Base {
-            BOOST_OPAQUE_USING_BITWISE_ORABLE2(Final, U)
+            BOOST_OPAQUE_USING_BITWISE_ORABLE2(Final)
         };
     };
 
@@ -352,15 +345,15 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_TOTALY_ORDERED2(Final, U, Bool) \
+#define BOOST_OPAQUE_USING_TOTALY_ORDERED2(Final, Bool) \
         BOOST_OPAQUE_USING_EQUALITY_COMPARABLE(Final, Bool) \
-        BOOST_OPAQUE_USING_LESS_THAN_COMPARABLE2(Final, U, Bool)
+        BOOST_OPAQUE_USING_LESS_THAN_COMPARABLE2(Final, Bool)
 
-    template <typename U, typename Bool=bool>
+    template <typename Bool=bool>
     struct using_totally_ordered2 {
         template <typename Final, typename Base>
         struct type : Base {
-            BOOST_OPAQUE_USING_TOTALY_ORDERED2(Final, U, Bool)
+            BOOST_OPAQUE_USING_TOTALY_ORDERED2(Final, Bool)
         };
     };
 
@@ -377,15 +370,14 @@
         };
     };
 
-    #define BOOST_OPAQUE_USING_ADDITIVE2(Final, U) \
-      BOOST_OPAQUE_USING_ADDABLE2(Final, U) \
-      BOOST_OPAQUE_USING_SUBTRACTABLE2(Final, U)
+    #define BOOST_OPAQUE_USING_ADDITIVE2(Final) \
+      BOOST_OPAQUE_USING_ADDABLE2(Final) \
+      BOOST_OPAQUE_USING_SUBTRACTABLE2(Final)
 
-    template <typename U>
     struct using_additive2 {
       template <typename Final, typename Base>
       struct type : Base {
-        BOOST_OPAQUE_USING_ADDITIVE2(Final, U)
+        BOOST_OPAQUE_USING_ADDITIVE2(Final)
       };
     };
 
@@ -404,15 +396,14 @@
         };
     };
 
-    #define BOOST_OPAQUE_USING_MULTIPLICATIVE2(Final, U) \
-      BOOST_OPAQUE_USING_MULTIPLIABLE2(Final, U) \
-      BOOST_OPAQUE_USING_DIVIDABLE2(Final, U)
+    #define BOOST_OPAQUE_USING_MULTIPLICATIVE2(Final) \
+      BOOST_OPAQUE_USING_MULTIPLIABLE2(Final) \
+      BOOST_OPAQUE_USING_DIVIDABLE2(Final)
 
-    template <typename U>
     struct using_multiplicative2 {
       template <typename Final, typename Base>
       struct type : Base {
-        BOOST_OPAQUE_USING_MULTIPLICATIVE2(Final, U)
+        BOOST_OPAQUE_USING_MULTIPLICATIVE2(Final)
       };
     };
 
@@ -446,17 +437,16 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_ARITHMETIC2(Final, U) \
-    BOOST_OPAQUE_USING_ADDITIVE2(Final, U) \
-    BOOST_OPAQUE_USING_MULTIPLICATIVE2(Final, U)
+#define BOOST_OPAQUE_USING_ARITHMETIC2(Final) \
+    BOOST_OPAQUE_USING_ADDITIVE2(Final) \
+    BOOST_OPAQUE_USING_MULTIPLICATIVE2(Final)
 
-    template <typename U>
 struct using_arithmetic2
 {
     template <typename Final, typename Base = base_opaque_type >
     struct type : Base
     {
-        BOOST_OPAQUE_USING_ARITHMETIC2(Final, U)
+        BOOST_OPAQUE_USING_ARITHMETIC2(Final)
     };
 };
 
@@ -479,8 +469,8 @@
 
     //~ template <class T, class U, typename Base = base_opaque_type >
     //~ struct bitwise2
-        //~ : opaque::xorable2<T, U
-        //~ , opaque::andable2<T, U
+        //~ : opaque::xorable2<T
+        //~ , opaque::andable2<T
         //~ , opaque::orable2<T, U, Base
           //~ > > > {};
 
@@ -500,18 +490,17 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_BITWISE2(Final, U) \
-    BOOST_OPAQUE_USING_BITWISE_XORABLE2(Final, U) \
-    BOOST_OPAQUE_USING_BITWISE_ANDABLE2(Final, U) \
-    BOOST_OPAQUE_USING_BITWISE_ORABLE2(Final, U)
+#define BOOST_OPAQUE_USING_BITWISE2(Final) \
+    BOOST_OPAQUE_USING_BITWISE_XORABLE2(Final) \
+    BOOST_OPAQUE_USING_BITWISE_ANDABLE2(Final) \
+    BOOST_OPAQUE_USING_BITWISE_ORABLE2(Final)
 
-    template <typename U>
 struct using_bitwise2
 {
     template <typename Final, typename Base = base_opaque_type >
     struct type : Base
     {
-        BOOST_OPAQUE_USING_BITWISE2(Final, U)
+        BOOST_OPAQUE_USING_BITWISE2(Final)
     };
 };
 
@@ -568,17 +557,16 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_RING_OPERATORS2(Final, U) \
-    BOOST_OPAQUE_USING_ADDITIVE2(Final, U) \
-    BOOST_OPAQUE_USING_MULTIPLIABLE2(Final, U)
+#define BOOST_OPAQUE_USING_RING_OPERATORS2(Final) \
+    BOOST_OPAQUE_USING_ADDITIVE2(Final) \
+    BOOST_OPAQUE_USING_MULTIPLIABLE2(Final)
 
-    template <typename U>
 struct using_ring_operators2
 {
     template <typename Final, typename Base = base_opaque_type >
     struct type: Base
     {
-      BOOST_OPAQUE_USING_RING_OPERATORS2(Final, U)
+      BOOST_OPAQUE_USING_RING_OPERATORS2(Final)
     };
 };
 
@@ -599,17 +587,17 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_ORDERED_RING_OPERATORS2(Final, U, Bool) \
-    BOOST_OPAQUE_USING_RING_OPERATORS2(Final, U) \
-    BOOST_OPAQUE_USING_TOTALY_ORDERED2(Final, U,Bool)
+#define BOOST_OPAQUE_USING_ORDERED_RING_OPERATORS2(Final, Bool) \
+    BOOST_OPAQUE_USING_RING_OPERATORS2(Final) \
+    BOOST_OPAQUE_USING_TOTALY_ORDERED2(Final,Bool)
 
-template <typename U, typename Bool=bool>
+template <typename Bool=bool>
 struct using_ordered_ring_operators2
 {
     template <typename Final, typename Base = base_opaque_type>
     struct type : Base
     {
-        BOOST_OPAQUE_USING_ORDERED_RING_OPERATORS2(Final, U,Bool)
+        BOOST_OPAQUE_USING_ORDERED_RING_OPERATORS2(Final,Bool)
     };
 };
 
@@ -637,17 +625,16 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_FIELD_OPERATORS2(Final, U) \
-     BOOST_OPAQUE_USING_RING_OPERATORS2(Final, U) \
-     BOOST_OPAQUE_USING_DIVIDABLE2(Final, U)
+#define BOOST_OPAQUE_USING_FIELD_OPERATORS2(Final) \
+     BOOST_OPAQUE_USING_RING_OPERATORS2(Final) \
+     BOOST_OPAQUE_USING_DIVIDABLE2(Final)
 
-    template <typename U>
  struct using_field_operators2
  {
      template <typename Final, typename Base = base_opaque_type>
      struct type: Base
      {
-         BOOST_OPAQUE_USING_FIELD_OPERATORS2(Final, U)
+         BOOST_OPAQUE_USING_FIELD_OPERATORS2(Final)
      };
  };
 //////////////////////////////////////////////////////////////////////////////
@@ -674,17 +661,17 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_ORDERED_FIELD_OPERATORS2(Final, U, Bool) \
-    BOOST_OPAQUE_USING_FIELD_OPERATORS2(Final, U) \
-    BOOST_OPAQUE_USING_TOTALY_ORDERED2(Final, U, Bool)
+#define BOOST_OPAQUE_USING_ORDERED_FIELD_OPERATORS2(Final, Bool) \
+    BOOST_OPAQUE_USING_FIELD_OPERATORS2(Final) \
+    BOOST_OPAQUE_USING_TOTALY_ORDERED2(Final, Bool)
 
-template <typename U, typename Bool=bool>
+template <typename Bool=bool>
 struct using_ordered_field_operators2
 {
     template <typename Final, typename Base = base_opaque_type>
     struct type : Base
     {
-        BOOST_OPAQUE_USING_ORDERED_FIELD_OPERATORS2(Final, U, Bool)
+        BOOST_OPAQUE_USING_ORDERED_FIELD_OPERATORS2(Final, Bool)
     };
 };
 

Modified: sandbox/opaque/boost/opaque/meta_mixin/operators.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/meta_mixin/operators.hpp	(original)
+++ sandbox/opaque/boost/opaque/meta_mixin/operators.hpp	2011-03-30 16:31:44 EDT (Wed, 30 Mar 2011)
@@ -63,7 +63,6 @@
 #define BOOST_OPAQUE_OPERATORS_HPP
 #if !defined(BOOST_OPAQUE_DOXYGEN_INVOKED)
 
-//#include <boost/operators.hpp>
 #include <boost/config.hpp>
 #include <boost/conversion/convert_to.hpp>
 
@@ -192,40 +191,46 @@
         Bool operator OP (const Final& rhs) const; \
       }; \
     }; \
-    template <typename U, typename Bool=bool> \
+    template <typename Bool=bool> \
     struct BOOST_JOIN(BOOST_JOIN(using_,NAME),2) \
     { \
       template <typename Final, typename Base> \
       struct type: Base \
       { \
       private:\
+        template <typename U> \
         static Bool BOOST_OPAQUE_INTERNAL_NAME(NAME) (const Final& lhs, const U& rhs)  \
         { \
           return Bool(lhs.underlying() OP rhs);\
         } \
+        template <typename U> \
         static Bool BOOST_OPAQUE_INTERNAL_NAME(NAME) (const U& lhs, const Final& rhs)   \
         { \
           return Bool(lhs OP rhs.underlying());\
         } \
       public:\
+        template <typename U> \
         friend Bool operator OP (const Final& lhs, const U& rhs)  \
         { \
           return Final::BOOST_OPAQUE_INTERNAL_NAME(NAME)(lhs, rhs);\
         } \
+        template <typename U> \
         friend Bool operator OP (const U& lhs, const Final& rhs)   \
         { \
           return Final::BOOST_OPAQUE_INTERNAL_NAME(NAME)(lhs, rhs);\
         } \
       }; \
     }; \
-    template <typename U, typename Bool=bool> \
+    template <typename Bool=bool> \
     struct BOOST_JOIN(BOOST_JOIN(hiding,NAME),2)  \
     { \
         template <typename Final, typename Base> \
         struct type: Base \
         { \
         private :\
+          template <typename U> \
           static Bool BOOST_JOIN(BOOST_JOIN(using_,NAME),_op) (const Final& lhs, const U& rhs);  \
+          template <typename U> \
           static Bool BOOST_JOIN(BOOST_JOIN(using_,NAME),_op) (const U& lhs, const Final& rhs);   \
         }; \
     }; \
@@ -240,19 +245,23 @@
         Bool operator OP(const Final& rhs) const;\
     public :
 
-#define BOOST_OPAQUE_USING_REL_OP2(Final, U, Bool, OP) \
+#define BOOST_OPAQUE_USING_REL_OP2(Final, Bool, OP) \
+    template <typename U> \
     friend Bool operator OP (const Final& lhs, const U& rhs)  \
     { \
       return Bool(lhs.underlying() OP rhs);\
     } \
+    template <typename U> \
     friend Bool operator OP (const U& lhs, const Final& rhs)   \
     { \
       return Bool(lhs OP rhs.underlying());\
     }
 
-#define BOOST_OPAQUE_HIDING_REL_OP2(Final, U, Bool, OP) \
+#define BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, OP) \
     private :\
+      template <typename U> \
       friend Bool operator OP (const Final& lhs, const U& rhs);  \
+      template <typename U> \
       friend Bool operator OP (const U& lhs, const Final& rhs);   \
     public :
 
@@ -340,45 +349,106 @@
       static Final BOOST_OPAQUE_INTERNAL_NAME(NAME) (const Final& lhs, const Final& rhs);  \
     public :
 
-#define BOOST_OPAQUE_USING_BINARY_OP2(Final, U, OP, NAME) \
+#define BOOST_OPAQUE_USING_BINARY_OP2(Final, OP, NAME) \
     private:\
+      template <typename U> \
       static Final BOOST_OPAQUE_INTERNAL_NAME(NAME) (const Final& lhs, const U& rhs)  \
       { \
         return Final(lhs.underlying() OP rhs);\
       } \
+      template <typename U> \
       static Final BOOST_OPAQUE_INTERNAL_NAME(NAME) (const U& lhs, const Final& rhs)   \
       { \
         return Final(lhs OP rhs.underlying());\
       } \
     public:\
+      template <typename U> \
       friend Final operator OP (const Final& lhs, const U& rhs)  \
       { \
         return Final::BOOST_OPAQUE_INTERNAL_NAME(NAME)(lhs, rhs);\
       } \
+      template <typename U> \
       friend Final operator OP (const U& lhs, const Final& rhs)   \
       { \
         return Final::BOOST_OPAQUE_INTERNAL_NAME(NAME)(lhs, rhs);\
       } \
 
-#define BOOST_OPAQUE_HIDING_BINARY_OP2(Final, U, OP, NAME) \
+#define BOOST_OPAQUE_HIDING_BINARY_OP2(Final, OP, NAME) \
     private :\
+      template <typename U> \
       static Final BOOST_OPAQUE_INTERNAL_NAME(NAME) (const Final& lhs, const U& rhs);  \
+      template <typename U> \
       static Final BOOST_OPAQUE_INTERNAL_NAME(NAME) (const U& lhs, const Final& rhs);   \
     public :
 
 //////////////////////////////////////////////////////////////////////////////
 
+
+    #define BOOST_OPAQUE_DCL_META_MIXIN_BINARY_EX(OP, NAME) \
+        struct BOOST_JOIN(using_,NAME) \
+        { \
+          template <typename Final, typename Base> \
+          struct type: Base \
+          { \
+          private:\
+          template <typename U> \
+            static Final BOOST_OPAQUE_INTERNAL_NAME(NAME) (const Final& lhs, const U& rhs)  \
+            { \
+              return Final(lhs.underlying() OP rhs);\
+            } \
+          public:\
+          template <typename U> \
+            friend Final operator OP (const Final& lhs, const U& rhs)  \
+            { \
+              return Final::BOOST_OPAQUE_INTERNAL_NAME(NAME)(lhs, rhs);\
+            } \
+          }; \
+        }; \
+        struct BOOST_JOIN(BOOST_JOIN(hiding,NAME),2)  \
+        { \
+            template <typename Final, typename Base> \
+            struct type: Base \
+            { \
+            private :\
+            template <typename U> \
+              static Final BOOST_JOIN(BOOST_JOIN(using_,NAME),_op) (const Final& lhs, const U& rhs);  \
+            }; \
+        }; \
+
+
+    #define BOOST_OPAQUE_USING_BINARY_OP_EX(Final, OP, NAME) \
+        private:\
+        template <typename U> \
+          static Final BOOST_OPAQUE_INTERNAL_NAME(NAME) (const Final& lhs, const U& rhs)  \
+          { \
+            return Final(lhs.underlying() OP rhs);\
+          } \
+        public:\
+        template <typename U> \
+          friend Final operator OP (const Final& lhs, const U& rhs)  \
+          { \
+            return Final::BOOST_OPAQUE_INTERNAL_NAME(NAME)(lhs, rhs);\
+          } \
+
+    #define BOOST_OPAQUE_HIDING_BINARY_OP_EX(Final, OP, NAME) \
+        private :\
+        template <typename U> \
+          static Final BOOST_OPAQUE_INTERNAL_NAME(NAME) (const Final& lhs, const U& rhs);  \
+        public :
+
+/////////////////////////////////////////////////////////////////////////////
+
 #define BOOST_OPAQUE_USING_LESS_THAN(Final, Bool) \
     BOOST_OPAQUE_USING_REL_OP(Final, Bool, <)
 
 #define BOOST_OPAQUE_HIDING_LESS_THAN(Final, Bool) \
     BOOST_OPAQUE_HIDING_REL_OP(Final, Bool, <)
 
-#define BOOST_OPAQUE_USING_LESS_THAN2(Final, U, Bool) \
-    BOOST_OPAQUE_USING_REL_OP2(Final, U, Bool, <)
+#define BOOST_OPAQUE_USING_LESS_THAN2(Final, Bool) \
+    BOOST_OPAQUE_USING_REL_OP2(Final, Bool, <)
 
-#define BOOST_OPAQUE_HIDING_LESS_THAN2(Final, U, Bool) \
-    BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, U, <)
+#define BOOST_OPAQUE_HIDING_LESS_THAN2(Final, Bool) \
+    BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, <)
 
 BOOST_OPAQUE_DCL_META_MIXIN_REL(<, less_than)
 
@@ -391,11 +461,11 @@
 #define BOOST_OPAQUE_HIDING_LESS_THAN_EQUAL(Final, Bool) \
     BOOST_OPAQUE_HIDING_REL_OP(Final, Bool, <=)
 
-#define BOOST_OPAQUE_USING_LESS_THAN_EQUAL2(Final, U, Bool) \
-    BOOST_OPAQUE_USING_REL_OP2(Final, U, Bool, <=)
+#define BOOST_OPAQUE_USING_LESS_THAN_EQUAL2(Final, Bool) \
+    BOOST_OPAQUE_USING_REL_OP2(Final, Bool, <=)
 
-#define BOOST_OPAQUE_HIDING_LESS_THAN_EQUAL2(Final, U, Bool) \
-    BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, U, <=)
+#define BOOST_OPAQUE_HIDING_LESS_THAN_EQUAL2(Final, Bool) \
+    BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, <=)
 
 BOOST_OPAQUE_DCL_META_MIXIN_REL(<=, less_than_equal)
 
@@ -407,11 +477,11 @@
 #define BOOST_OPAQUE_HIDING_GREATER_THAN(Final, Bool) \
     BOOST_OPAQUE_HIDING_REL_OP(Final, Bool, >)
 
-#define BOOST_OPAQUE_USING_GREATER_THAN2(Final, U, Bool) \
-    BOOST_OPAQUE_USING_REL_OP2(Final, U, Bool, >)
+#define BOOST_OPAQUE_USING_GREATER_THAN2(Final, Bool) \
+    BOOST_OPAQUE_USING_REL_OP2(Final, Bool, >)
 
-#define BOOST_OPAQUE_HIDING_GREATER_THAN2(Final, U, Bool) \
-    BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, U, >)
+#define BOOST_OPAQUE_HIDING_GREATER_THAN2(Final, Bool) \
+    BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, >)
 
 BOOST_OPAQUE_DCL_META_MIXIN_REL(>, greater_than)
 
@@ -423,11 +493,11 @@
 #define BOOST_OPAQUE_HIDING_GREATER_THAN_EQUAL(Final, Bool) \
     BOOST_OPAQUE_HIDING_REL_OP(Final, Bool, >=)
 
-#define BOOST_OPAQUE_USING_GREATER_THAN_EQUAL2(Final, U, Bool) \
-    BOOST_OPAQUE_USING_REL_OP2(Final, U, Bool, >=)
+#define BOOST_OPAQUE_USING_GREATER_THAN_EQUAL2(Final, Bool) \
+    BOOST_OPAQUE_USING_REL_OP2(Final, Bool, >=)
 
-#define BOOST_OPAQUE_HIDING_GREATER_THAN_EQUAL2(Final, U, Bool) \
-    BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, U, >=)
+#define BOOST_OPAQUE_HIDING_GREATER_THAN_EQUAL2(Final, Bool) \
+    BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, >=)
 
 BOOST_OPAQUE_DCL_META_MIXIN_REL(>=, greater_than_equal)
 
@@ -439,11 +509,11 @@
 #define BOOST_OPAQUE_HIDING_EQUAL(Final, Bool) \
     BOOST_OPAQUE_HIDING_REL_OP(Final, Bool, ==)
 
-#define BOOST_OPAQUE_USING_EQUAL2(Final, U, Bool) \
-    BOOST_OPAQUE_USING_REL_OP2(Final, U, Bool, ==)
+#define BOOST_OPAQUE_USING_EQUAL2(Final, Bool) \
+    BOOST_OPAQUE_USING_REL_OP2(Final, Bool, ==)
 
-#define BOOST_OPAQUE_HIDING_EQUAL2(Final, U, Bool) \
-    BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, U, ==)
+#define BOOST_OPAQUE_HIDING_EQUAL2(Final, Bool) \
+    BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, ==)
 
 BOOST_OPAQUE_DCL_META_MIXIN_REL(==, equal)
 
@@ -455,11 +525,11 @@
 #define BOOST_OPAQUE_HIDING_NOT_EQUAL(Final, Bool) \
     BOOST_OPAQUE_HIDING_REL_OP(Final, Bool, !=)
 
-#define BOOST_OPAQUE_USING_NOT_EQUAL2(Final, U, Bool) \
-    BOOST_OPAQUE_USING_REL_OP2(Final, U, Bool, !=)
+#define BOOST_OPAQUE_USING_NOT_EQUAL2(Final, Bool) \
+    BOOST_OPAQUE_USING_REL_OP2(Final, Bool, !=)
 
-#define BOOST_OPAQUE_HIDING_NOT_EQUAL2(Final, U, Bool) \
-    BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, U, !=)
+#define BOOST_OPAQUE_HIDING_NOT_EQUAL2(Final, Bool) \
+    BOOST_OPAQUE_HIDING_REL_OP2(Final, Bool, !=)
 
 BOOST_OPAQUE_DCL_META_MIXIN_REL(!=, not_equal)
 
@@ -872,11 +942,11 @@
 #define BOOST_OPAQUE_HIDING_PLUS(Final) \
     BOOST_OPAQUE_HIDING_BINARY_OP(Final, +, plus)
 
-#define BOOST_OPAQUE_USING_PLUS2(Final, U) \
-    BOOST_OPAQUE_USING_BINARY_OP2(Final, U, +, plus)
+#define BOOST_OPAQUE_USING_PLUS2(Final) \
+    BOOST_OPAQUE_USING_BINARY_OP2(Final, +, plus)
 
-#define BOOST_OPAQUE_HIDING_PLUS2(Final, U) \
-    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, U, +, plus)
+#define BOOST_OPAQUE_HIDING_PLUS2(Final) \
+    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, +, plus)
 
 BOOST_OPAQUE_DCL_META_MIXIN_BINARY(+, plus)
 
@@ -888,11 +958,11 @@
 #define BOOST_OPAQUE_HIDING_MINUS(Final) \
     BOOST_OPAQUE_HIDING_BINARY_OP(Final, -, minus)
 
-#define BOOST_OPAQUE_USING_MINUS2(Final, U) \
-    BOOST_OPAQUE_USING_BINARY_OP2(Final, U, -, minus)
+#define BOOST_OPAQUE_USING_MINUS2(Final) \
+    BOOST_OPAQUE_USING_BINARY_OP2(Final, -, minus)
 
-#define BOOST_OPAQUE_HIDING_MINUS2(Final, U) \
-    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, U, -, minus)
+#define BOOST_OPAQUE_HIDING_MINUS2(Final) \
+    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, -, minus)
 
 BOOST_OPAQUE_DCL_META_MIXIN_BINARY(-, minus)
 
@@ -904,11 +974,11 @@
 #define BOOST_OPAQUE_HIDING_MULTIPLY(Final) \
     BOOST_OPAQUE_HIDING_BINARY_OP(Final, *, multiply)
 
-#define BOOST_OPAQUE_USING_MULTIPLY2(Final, U) \
-    BOOST_OPAQUE_USING_BINARY_OP2(Final, U, *, multiply)
+#define BOOST_OPAQUE_USING_MULTIPLY2(Final) \
+    BOOST_OPAQUE_USING_BINARY_OP2(Final, *, multiply)
 
-#define BOOST_OPAQUE_HIDING_MULTIPLY2(Final, U) \
-    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, U, *, multiply)
+#define BOOST_OPAQUE_HIDING_MULTIPLY2(Final) \
+    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, *, multiply)
 
 BOOST_OPAQUE_DCL_META_MIXIN_BINARY(*, multiply)
 
@@ -921,11 +991,11 @@
 #define BOOST_OPAQUE_HIDING_DIVIDE(Final) \
     BOOST_OPAQUE_HIDING_BINARY_OP(Final, /, divide)
 
-#define BOOST_OPAQUE_USING_DIVIDE2(Final, U) \
-    BOOST_OPAQUE_USING_BINARY_OP2(Final, U, /, divide)
+#define BOOST_OPAQUE_USING_DIVIDE2(Final) \
+    BOOST_OPAQUE_USING_BINARY_OP2(Final, /, divide)
 
-#define BOOST_OPAQUE_HIDING_DIVIDE2(Final, U) \
-    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, U, /, divide)
+#define BOOST_OPAQUE_HIDING_DIVIDE2(Final) \
+    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, /, divide)
 
 BOOST_OPAQUE_DCL_META_MIXIN_BINARY(/, divide)
 
@@ -937,11 +1007,11 @@
 #define BOOST_OPAQUE_HIDING_MODULUS(Final) \
     BOOST_OPAQUE_HIDING_BINARY_OP(Final, %, modulus)
 
-#define BOOST_OPAQUE_USING_MODULUS2(Final, U) \
-    BOOST_OPAQUE_USING_BINARY_OP2(Final, U, %, modulus)
+#define BOOST_OPAQUE_USING_MODULUS2(Final) \
+    BOOST_OPAQUE_USING_BINARY_OP2(Final, %, modulus)
 
-#define BOOST_OPAQUE_HIDING_MODULUS2(Final, U) \
-    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, U, %, modulus)
+#define BOOST_OPAQUE_HIDING_MODULUS2(Final) \
+    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, %, modulus)
 
 BOOST_OPAQUE_DCL_META_MIXIN_BINARY(%, modulus)
 
@@ -953,11 +1023,11 @@
 #define BOOST_OPAQUE_HIDING_BITWISE_XOR(Final) \
     BOOST_OPAQUE_HIDING_BINARY_OP(Final, ^, bitwise_xor)
 
-#define BOOST_OPAQUE_USING_BITWISE_XOR2(Final, U) \
-    BOOST_OPAQUE_USING_BINARY_OP2(Final, U, ^, bitwise_xor)
+#define BOOST_OPAQUE_USING_BITWISE_XOR2(Final) \
+    BOOST_OPAQUE_USING_BINARY_OP2(Final, ^, bitwise_xor)
 
-#define BOOST_OPAQUE_HIDING_BITWISE_XOR2(Final, U) \
-    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, U, ^, bitwise_xor)
+#define BOOST_OPAQUE_HIDING_BITWISE_XOR2(Final) \
+    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, ^, bitwise_xor)
 
 BOOST_OPAQUE_DCL_META_MIXIN_BINARY(^, bitwise_xor)
 
@@ -969,11 +1039,11 @@
 #define BOOST_OPAQUE_HIDING_BITWISE_OR(Final) \
     BOOST_OPAQUE_HIDING_BINARY_OP(Final, |, bitwise_or)
 
-#define BOOST_OPAQUE_USING_BITWISE_OR2(Final, U) \
-    BOOST_OPAQUE_USING_BINARY_OP2(Final, U, |, bitwise_or)
+#define BOOST_OPAQUE_USING_BITWISE_OR2(Final) \
+    BOOST_OPAQUE_USING_BINARY_OP2(Final, |, bitwise_or)
 
-#define BOOST_OPAQUE_HIDING_BITWISE_OR2(Final, U) \
-    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, U, |, bitwise_or)
+#define BOOST_OPAQUE_HIDING_BITWISE_OR2(Final) \
+    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, |, bitwise_or)
 
 BOOST_OPAQUE_DCL_META_MIXIN_BINARY(|, bitwise_or)
 
@@ -985,46 +1055,34 @@
 #define BOOST_OPAQUE_HIDING_BITWISE_AND(Final) \
     BOOST_OPAQUE_HIDING_BINARY_OP(Final, &, bitwise_and)
 
-#define BOOST_OPAQUE_USING_BITWISE_AND2(Final, U) \
-    BOOST_OPAQUE_USING_BINARY_OP2(Final, U, &, bitwise_and)
+#define BOOST_OPAQUE_USING_BITWISE_AND2(Final) \
+    BOOST_OPAQUE_USING_BINARY_OP2(Final, &, bitwise_and)
 
-#define BOOST_OPAQUE_HIDING_BITWISE_AND2(Final, U) \
-    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, U, &, bitwise_and)
+#define BOOST_OPAQUE_HIDING_BITWISE_AND2(Final) \
+    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, &, bitwise_and)
 
 BOOST_OPAQUE_DCL_META_MIXIN_BINARY(&, bitwise_and)
     
 //////////////////////////////////////////////////////////////////////////////
 
 #define BOOST_OPAQUE_USING_LEFT_SHIFT(Final) \
-    BOOST_OPAQUE_USING_BINARY_OP(Final, <<, left_shift)
+    BOOST_OPAQUE_USING_BINARY_OP_EX(Final, <<, left_shift)
 
 #define BOOST_OPAQUE_HIDING_LEFT_SHIFT(Final) \
-    BOOST_OPAQUE_HIDING_BINARY_OP(Final, <<, left_shift)
+    BOOST_OPAQUE_HIDING_BINARY_OP_EX(Final, <<, left_shift)
 
-#define BOOST_OPAQUE_USING_LEFT_SHIFT2(Final, U) \
-    BOOST_OPAQUE_USING_BINARY_OP2(Final, U, <<, left_shift)
-
-#define BOOST_OPAQUE_HIDING_LEFT_SHIFT2(Final, U) \
-    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, U, <<, left_shift)
-
-BOOST_OPAQUE_DCL_META_MIXIN_BINARY(<<, left_shift)
+BOOST_OPAQUE_DCL_META_MIXIN_BINARY_EX(<<, left_shift)
 
     
 //////////////////////////////////////////////////////////////////////////////
 
 #define BOOST_OPAQUE_USING_RIGHT_SHIFT(Final) \
-    BOOST_OPAQUE_USING_BINARY_OP(Final, >>, right_shift)
+    BOOST_OPAQUE_USING_BINARY_OP_EX(Final, >>, right_shift)
 
 #define BOOST_OPAQUE_HIDING_RIGHT_SHIFT(Final) \
-    BOOST_OPAQUE_HIDING_BINARY_OP(Final, >>, right_shift)
-
-#define BOOST_OPAQUE_USING_RIGHT_SHIFT2(Final, U) \
-    BOOST_OPAQUE_USING_BINARY_OP2(Final, U, >>, right_shift)
-
-#define BOOST_OPAQUE_HIDING_RIGHT_SHIFT2(Final, U) \
-    BOOST_OPAQUE_HIDING_BINARY_OP2(Final, U, >>, right_shift)
+    BOOST_OPAQUE_HIDING_BINARY_OP_EX(Final, >>, right_shift)
 
-BOOST_OPAQUE_DCL_META_MIXIN_BINARY(>>, right_shift)
+BOOST_OPAQUE_DCL_META_MIXIN_BINARY_EX(>>, right_shift)
     
 }
 }