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

Subject: [Boost-commit] svn:boost r65701 - sandbox/opaque/boost/opaque
From: vicente.botet_at_[hidden]
Date: 2010-09-30 18:32:16

Author: viboes
Date: 2010-09-30 18:32:14 EDT (Thu, 30 Sep 2010)
New Revision: 65701
URL: http://svn.boost.org/trac/boost/changeset/65701

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

Text files modified: 
   sandbox/opaque/boost/opaque/combined_operators.hpp |    93 ++++++++++++++++++++++++++++++--------- 
   sandbox/opaque/boost/opaque/operators.hpp          |    52 +++++++++++++++++++--                   
   2 files changed, 117 insertions(+), 28 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-09-30 18:32:14 EDT (Thu, 30 Sep 2010)
@@ -23,7 +23,7 @@
 #define BOOST_OPAQUE_EQUALITY_COMPARABLE1(Final,Bool) \
         BOOST_OPAQUE_USING_EQUAL(Final,Bool) \
         BOOST_OPAQUE_USING_NOT_EQUAL(Final,Bool)
-    
+
     template <typename Bool=bool>
     struct using_equality_comparable1 {
         template <typename Final, typename UT, typename Base>
@@ -50,7 +50,7 @@
             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)
@@ -67,7 +67,7 @@
         BOOST_OPAQUE_ADDABLE1(Final)
         };
     };
-        
+
 
     template <typename Final, typename Base>
     struct addable1 : Base  {
@@ -84,15 +84,15 @@
             BOOST_OPAQUE_SUBTRACTABLE1(Final)
         };
     };
-        
-    
+
+
     template <typename Final, typename Base>
-    struct subtractable1 : Base 
+    struct subtractable1 : Base
     {
         BOOST_OPAQUE_SUBTRACTABLE1(Final)
     };
 
-    
+
 #define BOOST_OPAQUE_MULTIPLIABLE1(Final) \
         BOOST_OPAQUE_USING_MULTIPLY_ASSIGN(Final) \
         BOOST_OPAQUE_USING_MULTIPLY(Final)
@@ -103,7 +103,7 @@
             BOOST_OPAQUE_MULTIPLIABLE1(Final)
         };
     };
-        
+
     template <typename Final, typename Base>
     struct multipliable1 : Base {
             BOOST_OPAQUE_MULTIPLIABLE1(Final)
@@ -119,11 +119,9 @@
             BOOST_OPAQUE_DIVIDABLE1(Final)
         };
     };
-        
+
     template <typename Final, typename Base>
-    struct dividable1
-    //~ : boost::dividable1<Final, ope::divide_assign<Final, Base> >
-    : Base 
+    struct dividable1 : Base
     {
             BOOST_OPAQUE_DIVIDABLE1(Final)
     };
@@ -143,12 +141,45 @@
             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 {
+        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> > {};
 
+#define BOOST_OPAQUE_BITWISE_ANDABLE1(Final) \
+        BOOST_OPAQUE_USING_BITWISE_AND_ASSIGN(Final) \
+        BOOST_OPAQUE_USING_BITWISE_AND(Final)
+
+    struct using_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> > {};
 
+#define BOOST_OPAQUE_BITWISE_ORABLE1(Final) \
+        BOOST_OPAQUE_USING_BITWISE_OR_ASSIGN(Final) \
+        BOOST_OPAQUE_USING_BITWISE_OR(Final)
+
+    struct using_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> > {};
 
@@ -164,6 +195,20 @@
     template <typename Final, typename Base>
     struct right_shiftable1 : boost::right_shiftable1<Final, ope::right_shift_assign<Final, Base> > {};
 
+#define BOOST_OPAQUE_PARTIALLY_ORDERED1(Final,Bool) \
+        BOOST_OPAQUE_USING_LESS_THAN(Final,Bool) \
+        BOOST_OPAQUE_USING_LESS_THAN_EQUAL(Final,Bool) \
+        BOOST_OPAQUE_USING_GREATER_THAN(Final,Bool) \
+        BOOST_OPAQUE_USING_GREATER_THAN_EQUAL(Final,Bool)
+
+    template <typename Bool=bool>
+    struct using_partially_ordered1 {
+        template <typename Final, typename UT, typename Base>
+        struct type : Base {
+            BOOST_OPAQUE_PARTIALLY_ORDERED1(Final,Bool)
+        };
+    };
+
     template <typename Final, typename Base>
     struct partially_ordered1 : boost::partially_ordered1<Final, ope::less_than<Final, Base> > {};
 
@@ -178,9 +223,9 @@
             BOOST_OPAQUE_TOTALY_ORDERED1(Final,Bool)
         };
     };
-        
-    template <class Final, class UT, class Base, typename Bool=bool >
-    struct totally_ordered1 : Base 
+
+    template <class Final, class Base, typename Bool=bool >
+    struct totally_ordered1 : Base
     {
         BOOST_OPAQUE_TOTALY_ORDERED1(Final,Bool)
     };
@@ -226,7 +271,7 @@
             BOOST_OPAQUE_MULTIPLICATIVE1(Final)
         };
     };
-    
+
     template <class Final, class Base = base_new_type >
     struct multiplicative1 : Base
     {
@@ -239,6 +284,10 @@
         //~ , opaque::modable2<T, U, Base
           //~ > > {};
 
+    #define BOOST_OPAQUE_INTEGER_MULTIPLICATIVE1(Final) \
+        BOOST_OPAQUE_MULTIPLIABLE1(Final) \
+        BOOST_OPAQUE_MODABLE1(Final)
+
     template <class T, class Base = base_new_type >
     struct integer_multiplicative1
         : opaque::multiplicative1<T
@@ -251,10 +300,10 @@
         //~ , opaque::multiplicative2<T, U, Base
           //~ > > {};
 
-    template <class T, class Base = base_new_type >
+    template <class Final, class Base = base_new_type >
     struct arithmetic1
-        : opaque::additive1<T
-        , opaque::multiplicative1<T, Base
+        : opaque::additive1<Final
+        , opaque::multiplicative1<Final, Base
           > > {};
 
     //~ template <class T, class U, class Base = base_new_type >
@@ -323,7 +372,7 @@
     template <class T, class UT, class Base = base_new_type >
     struct ordered_ring_operators1
         : opaque::ring_operators1<T
-        , opaque::totally_ordered1<T, UT, Base
+        , opaque::totally_ordered1<T, Base
           > > {};
 
     //~ template <class T, class U, class Base = base_new_type >
@@ -348,7 +397,7 @@
     template <class T, class UT, class Base = base_new_type >
     struct ordered_field_operators1
         : opaque::field_operators1<T
-        , opaque::totally_ordered1<T, UT, Base
+        , opaque::totally_ordered1<T, Base
           > > {};
 
 
@@ -358,7 +407,7 @@
     struct inherited_from_undelying {
             template <typename Final, typename UT, typename Base>
             struct type :
-                opaque::totally_ordered1< Final, T
+                opaque::totally_ordered1< Final
                 ,   opaque::integer_arithmetic1< Final
                     ,   boost::bitwise1< Final
                         ,   opaque::unit_steppable< Final

Modified: sandbox/opaque/boost/opaque/operators.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/operators.hpp	(original)
+++ sandbox/opaque/boost/opaque/operators.hpp	2010-09-30 18:32:14 EDT (Thu, 30 Sep 2010)
@@ -13,7 +13,6 @@
 #ifndef BOOST_OPAQUE_OPERATORS_HPP
 #define BOOST_OPAQUE_OPERATORS_HPP
 
-//~ #include <boost/opaque/new_type.hpp>
 #include <boost/operators.hpp>
 
 namespace boost {
@@ -56,6 +55,29 @@
         };
     };
 
+    template <typename T>
+    struct using_conversion_to {
+        template <typename Final, typename UT, typename Base>
+        struct type: Base {
+            operator T() const{
+                return T(Final::underlying(this));
+            }
+        };
+    };
+
+    struct using_conversion_safe_bool {
+        template <typename Final, typename UT, typename Base>
+        struct type: Base {
+            typedef typename Final::underlying_type const& (Final::*unspecified_bool_type)() const;
+
+            operator unspecified_bool_type() const
+              { return Final::underlying(this) ? &Final::underlying : 0; }
+            //~ BOOST_OPAQUE_USING_CONVERSION(Final,UT)
+        };
+    };
+
+
+
 #define BOOST_OPAQUE_USING_LESS_THAN(Final, Bool) \
     public :\
         Bool operator<(const Final& rhs) const  { \
@@ -66,7 +88,7 @@
     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>
@@ -383,7 +405,7 @@
             BOOST_OPAQUE_USING_UNARY_MINUS(Final)
         };
     };
-    
+
     template <typename Final, typename Base>
     struct unary_minus : Base {
         BOOST_OPAQUE_USING_UNARY_MINUS(Final)
@@ -508,10 +530,10 @@
     struct post_decrement : Base {
         BOOST_OPAQUE_USING_POST_DECREMENT(Final)
     };
-    
+
 #if 0
 // I don't know why this doesn't works :(
-    
+
 #define BOOST_OPAQUE_USING_PLUS(Final) \
     public :\
         Final operator+(const Final& rhs) const { \
@@ -554,7 +576,25 @@
             return Final(Final::underlying(this) % rhs.underlying()); \
         }
 
-    
+#define BOOST_OPAQUE_USING_BITWISE_XOR(Final) \
+    public :\
+        Final operator^(const Final& rhs) const { \
+            return Final(Final::underlying(this) ^ rhs.underlying()); \
+        }
+
+#define BOOST_OPAQUE_USING_BITWISE_OR(Final) \
+    public :\
+        Final operator|(const Final& rhs) const { \
+            return Final(Final::underlying(this) | rhs.underlying()); \
+        }
+
+#define BOOST_OPAQUE_USING_BITWISE_AND(Final) \
+    public :\
+        Final operator&(const Final& rhs) const { \
+            return Final(Final::underlying(this) & rhs.underlying()); \
+        }
+
+
 }
 
 }