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

Subject: [Boost-commit] svn:boost r65697 - sandbox/opaque/boost/opaque
From: vicente.botet_at_[hidden]
Date: 2010-09-30 16:28:37

Author: viboes
Date: 2010-09-30 16:28:36 EDT (Thu, 30 Sep 2010)
New Revision: 65697
URL: http://svn.boost.org/trac/boost/changeset/65697

Log:
Opaque: 
* Parameterize the boolean type resulting from relational operators.
* Add opaque boolean

Added:
   sandbox/opaque/boost/opaque/boolean.hpp   (contents, props changed)
Text files modified: 
   sandbox/opaque/boost/opaque/combined_operators.hpp |   182 +++++++++++++++++++++++---------------- 
   sandbox/opaque/boost/opaque/opaque.hpp             |     1                                         
   sandbox/opaque/boost/opaque/operators.hpp          |    68 ++++++++------                          
   3 files changed, 147 insertions(+), 104 deletions(-)

Added: sandbox/opaque/boost/opaque/boolean.hpp
==============================================================================
--- (empty file)
+++ sandbox/opaque/boost/opaque/boolean.hpp	2010-09-30 16:28:36 EDT (Thu, 30 Sep 2010)
@@ -0,0 +1,43 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Vicente J. Botet Escriba 2010.
+// Distributed under the Boost
+// Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/opaque for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_OPAQUE_BOOLEAN_HPP
+#define BOOST_OPAQUE_BOOLEAN_HPP
+
+
+namespace boost {
+namespace opaque {
+
+    class boolean {
+        bool val_;
+        typedef bool boolean::*unspecified_bool_type;
+    public:
+        explicit boolean(const bool b) : val_(b) {}
+
+        operator unspecified_bool_type() const
+        { return val_ ? &boolean::val_ : 0; }
+        boolean operator!() const {
+            return boolean(!val_);
+        }
+        boolean operator&&(boolean rhs) const {
+            return boolean(val_&&rhs.val_);
+        }
+        boolean operator||(boolean rhs) const {
+            return boolean(val_||rhs.val_);
+        }
+    };
+    const boolean true_=boolean(true);
+    const boolean false_=boolean(false);
+}
+}
+
+#endif

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 16:28:36 EDT (Thu, 30 Sep 2010)
@@ -20,38 +20,40 @@
 
 namespace opaque {
 
-#define BOOST_OPAQUE_EQUALITY_COMPARABLE1(Final) \
-        BOOST_OPAQUE_USING_EQUAL(Final) \
-        BOOST_OPAQUE_USING_NOT_EQUAL(Final)
+#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>
         struct type : Base {
-            BOOST_OPAQUE_EQUALITY_COMPARABLE1(Final)
+            BOOST_OPAQUE_EQUALITY_COMPARABLE1(Final,Bool)
         };
     };
 
-    template <typename Final, typename Base>
+    template <typename Final, typename Base, typename Bool=bool>
     struct equality_comparable1 : Base {
-        BOOST_OPAQUE_EQUALITY_COMPARABLE1(Final)
+        BOOST_OPAQUE_EQUALITY_COMPARABLE1(Final,Bool)
     };
 
-#define BOOST_OPAQUE_LESS_THAN_COMPARABLE1(Final) \
-        BOOST_OPAQUE_USING_LESS_THAN(Final) \
-        BOOST_OPAQUE_USING_LESS_THAN_EQUAL(Final) \
-        BOOST_OPAQUE_USING_GREATER_THAN(Final) \
-        BOOST_OPAQUE_USING_GREATER_THAN_EQUAL(Final)
+#define BOOST_OPAQUE_LESS_THAN_COMPARABLE1(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_less_than_comparable1 {
         template <typename Final, typename UT, typename Base>
         struct type : Base {
-        BOOST_OPAQUE_LESS_THAN_COMPARABLE1(Final)
+            BOOST_OPAQUE_LESS_THAN_COMPARABLE1(Final,Bool)
         };
     };
     
-    template <typename Final, typename Base>
+    template <typename Final, typename Base, typename Bool=bool>
     struct less_than_comparable1 : Base {
-        BOOST_OPAQUE_LESS_THAN_COMPARABLE1(Final)
+        BOOST_OPAQUE_LESS_THAN_COMPARABLE1(Final,Bool)
     };
 
 
@@ -114,7 +116,7 @@
     struct using_dividable1 {
         template <typename Final, typename UT, typename Base>
         struct type : Base {
-            BOOST_OPAQUE_MULTIPLIABLE1(Final)
+            BOOST_OPAQUE_DIVIDABLE1(Final)
         };
     };
         
@@ -165,154 +167,188 @@
     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) \
+        BOOST_OPAQUE_LESS_THAN_COMPARABLE1(Final,Bool)
 
-    template <class T, class UT, class B = base_new_type >
-    struct totally_ordered1
-        : opaque::less_than_comparable1<T
-        //~ , opaque::equality_comparable1<T, B
-        , opaque::using_equality_comparable1::template type<T, UT, B
-          > > {};
+    template <typename Bool=bool>
+    struct using_totally_ordered1 {
+        template <typename Final, typename UT, typename Base>
+        struct type : Base {
+            BOOST_OPAQUE_TOTALY_ORDERED1(Final,Bool)
+        };
+    };
+        
+    template <class Final, class UT, class Base, typename Bool=bool >
+    struct totally_ordered1 : Base 
+    {
+        BOOST_OPAQUE_TOTALY_ORDERED1(Final,Bool)
+    };
 
-    //~ template <class T, class U, class B = base_new_type >
+    //~ template <class T, class U, class Base = base_new_type >
     //~ struct additive2
         //~ : opaque::addable2<T, U
-        //~ , opaque::subtractable2<T, U, B
+        //~ , opaque::subtractable2<T, U, Base
           //~ > > {};
 
-    template <class T, class B = base_new_type >
-    struct additive1
-        : opaque::addable1<T
-        , opaque::subtractable1<T, B
-          > > {};
+    #define BOOST_OPAQUE_ADDITIVE1(Final) \
+        BOOST_OPAQUE_ADDABLE1(Final) \
+        BOOST_OPAQUE_SUBTRACTABLE1(Final)
+
 
-    //~ template <class T, class U, class B = base_new_type >
+    struct using_additive1 {
+        template <typename Final, typename UT, typename Base>
+        struct type : Base {
+            BOOST_OPAQUE_ADDITIVE1(Final)
+        };
+    };
+
+    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
-        //~ , opaque::dividable2<T, U, B
+        //~ , opaque::dividable2<T, U, Base
           //~ > > {};
 
-    template <class T, class B = base_new_type >
-    struct multiplicative1
-        : opaque::multipliable1<T
-        , opaque::dividable1<T, B
-          > > {};
+    #define BOOST_OPAQUE_MULTIPLICATIVE1(Final) \
+        BOOST_OPAQUE_MULTIPLIABLE1(Final) \
+        BOOST_OPAQUE_DIVIDABLE1(Final)
+
+
+    struct using_multiplicative1 {
+        template <typename Final, typename UT, typename Base>
+        struct type : Base {
+            BOOST_OPAQUE_MULTIPLICATIVE1(Final)
+        };
+    };
+    
+    template <class Final, class Base = base_new_type >
+    struct multiplicative1 : Base
+    {
+            BOOST_OPAQUE_MULTIPLICATIVE1(Final)
+    };
 
-    //~ template <class T, class U, class B = base_new_type >
+    //~ template <class T, class U, class Base = base_new_type >
     //~ struct integer_multiplicative2
         //~ : opaque::multiplicative2<T, U
-        //~ , opaque::modable2<T, U, B
+        //~ , opaque::modable2<T, U, Base
           //~ > > {};
 
-    template <class T, class B = base_new_type >
+    template <class T, class Base = base_new_type >
     struct integer_multiplicative1
         : opaque::multiplicative1<T
-        , opaque::modable1<T, B
+        , opaque::modable1<T, Base
           > > {};
 
-    //~ template <class T, class U, class B = base_new_type >
+    //~ template <class T, class U, class Base = base_new_type >
     //~ struct arithmetic2
         //~ : opaque::additive2<T, U
-        //~ , opaque::multiplicative2<T, U, B
+        //~ , opaque::multiplicative2<T, U, Base
           //~ > > {};
 
-    template <class T, class B = base_new_type >
+    template <class T, class Base = base_new_type >
     struct arithmetic1
         : opaque::additive1<T
-        , opaque::multiplicative1<T, B
+        , opaque::multiplicative1<T, Base
           > > {};
 
-    //~ template <class T, class U, class B = base_new_type >
+    //~ template <class T, class U, class Base = base_new_type >
     //~ struct integer_arithmetic2
         //~ : additive2<T, U
-        //~ , integer_multiplicative2<T, U, B
+        //~ , integer_multiplicative2<T, U, Base
           //~ > > {};
 
-    template <class T, class B = base_new_type >
+    template <class T, class Base = base_new_type >
     struct integer_arithmetic1
         : opaque::additive1<T
-        , opaque::integer_multiplicative1<T, B
+        , opaque::integer_multiplicative1<T, Base
           > > {};
 
-    //~ template <class T, class U, class B = base_new_type >
+    //~ template <class T, class U, class Base = base_new_type >
     //~ struct bitwise2
         //~ : opaque::xorable2<T, U
         //~ , opaque::andable2<T, U
-        //~ , opaque::orable2<T, U, B
+        //~ , opaque::orable2<T, U, Base
           //~ > > > {};
 
-    template <class T, class B = base_new_type >
+    template <class T, class Base = base_new_type >
     struct bitwise1
         : opaque::xorable1<T
         , opaque::andable1<T
-        , opaque::orable1<T, B
+        , opaque::orable1<T, Base
           > > > {};
 
-    template <class T, class B = base_new_type >
+    template <class T, class Base = base_new_type >
     struct unit_steppable
         : opaque::incrementable<T
-        , opaque::decrementable<T, B
+        , opaque::decrementable<T, Base
           > > {};
 
-    //~ template <class T, class U, class B = base_new_type >
+    //~ template <class T, class U, class Base = base_new_type >
     //~ struct shiftable2
         //~ : opaque::left_shiftable2<T, U
-        //~ , opaque::right_shiftable2<T, U, B
+        //~ , opaque::right_shiftable2<T, U, Base
           //~ > > {};
 
-    template <class T, class B = base_new_type >
+    template <class T, class Base = base_new_type >
     struct shiftable1
         : opaque::left_shiftable1<T
-        , opaque::right_shiftable1<T, B
+        , opaque::right_shiftable1<T, Base
           > > {};
 
-    //~ template <class T, class U, class B = base_new_type >
+    //~ template <class T, class U, class Base = base_new_type >
     //~ struct ring_operators2
         //~ : opaque::additive2<T, U
         //~ , opaque::subtractable2_left<T, U
-        //~ , opaque::multipliable2<T, U, B
+        //~ , opaque::multipliable2<T, U, Base
           //~ > > > {};
 
-    template <class T, class B = base_new_type >
+    template <class T, class Base = base_new_type >
     struct ring_operators1
         : opaque::additive1<T
-        , opaque::multipliable1<T, B
+        , opaque::multipliable1<T, Base
           > > {};
 
-    //~ template <class T, class U, class B = base_new_type >
+    //~ template <class T, class U, class Base = base_new_type >
     //~ struct ordered_ring_operators2
         //~ : opaque::ring_operators2<T, U
-        //~ , opaque::totally_ordered2<T, U, B
+        //~ , opaque::totally_ordered2<T, U, Base
           //~ > > {};
 
-    template <class T, class UT, class B = base_new_type >
+    template <class T, class UT, class Base = base_new_type >
     struct ordered_ring_operators1
         : opaque::ring_operators1<T
-        , opaque::totally_ordered1<T, UT, B
+        , opaque::totally_ordered1<T, UT, Base
           > > {};
 
-    //~ template <class T, class U, class B = base_new_type >
+    //~ template <class T, class U, class Base = base_new_type >
     //~ struct field_operators2
         //~ : opaque::ring_operators2<T, U
         //~ , opaque::dividable2<T, U
-        //~ , opaque::dividable2_left<T, U, B
+        //~ , opaque::dividable2_left<T, U, Base
           //~ > > > {};
 
-    template <class T, class B = base_new_type >
+    template <class T, class Base = base_new_type >
     struct field_operators1
         : opaque::ring_operators1<T
-        , opaque::dividable1<T, B
+        , opaque::dividable1<T, Base
           > > {};
 
-    //~ template <class T, class U, class B = base_new_type >
+    //~ template <class T, class U, class Base = base_new_type >
     //~ struct ordered_field_operators2
         //~ : opaque::field_operators2<T, U
-        //~ , opaque::totally_ordered2<T, U, B
+        //~ , opaque::totally_ordered2<T, U, Base
           //~ > > {};
 
-    template <class T, class UT, class B = base_new_type >
+    template <class T, class UT, class Base = base_new_type >
     struct ordered_field_operators1
         : opaque::field_operators1<T
-        , opaque::totally_ordered1<T, UT, B
+        , opaque::totally_ordered1<T, UT, Base
           > > {};
 
 

Modified: sandbox/opaque/boost/opaque/opaque.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/opaque.hpp	(original)
+++ sandbox/opaque/boost/opaque/opaque.hpp	2010-09-30 16:28:36 EDT (Thu, 30 Sep 2010)
@@ -20,6 +20,7 @@
 #include <boost/opaque/private_opaque_class.hpp>
 #include <boost/opaque/public_opaque_type.hpp>
 #include <boost/opaque/public_opaque_class.hpp>
+#include <boost/opaque/boolean.hpp>
 #include <boost/opaque/macros.hpp>
 
 #include <boost/mpl/bool.hpp>

Modified: sandbox/opaque/boost/opaque/operators.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/operators.hpp	(original)
+++ sandbox/opaque/boost/opaque/operators.hpp	2010-09-30 16:28:36 EDT (Thu, 30 Sep 2010)
@@ -56,95 +56,101 @@
         };
     };
 
-#define BOOST_OPAQUE_USING_LESS_THAN(Final) \
+#define BOOST_OPAQUE_USING_LESS_THAN(Final, Bool) \
     public :\
-        bool operator<(const Final& rhs) const  { \
-            return Final::underlying(this) < rhs.underlying();\
+        Bool operator<(const Final& rhs) const  { \
+            return Bool(Final::underlying(this) < rhs.underlying());\
         }
 
-    template <typename Final, typename Base>
+    template <typename Final, typename Base, typename Bool=bool>
     struct less_than : Base {
-        BOOST_OPAQUE_USING_LESS_THAN(Final)
+        BOOST_OPAQUE_USING_LESS_THAN(Final, Bool)
     };
-
+    
+    template <typename Bool=bool>
     struct using_less_than {
         template <typename Final, typename UT, typename Base>
         struct type: Base {
-            BOOST_OPAQUE_USING_LESS_THAN(Final)
+            BOOST_OPAQUE_USING_LESS_THAN(Final,Bool)
         };
     };
 
-#define BOOST_OPAQUE_USING_LESS_THAN_EQUAL(Final) \
+#define BOOST_OPAQUE_USING_LESS_THAN_EQUAL(Final,Bool) \
     public :\
-        bool operator<=(const Final& rhs) const  { \
-            return Final::underlying(this) <= rhs.underlying();\
+        Bool operator<=(const Final& rhs) const  { \
+            return Bool(Final::underlying(this) <= rhs.underlying());\
         }
 
+    template <typename Bool=bool>
     struct using_less_than_equal {
         template <typename Final, typename UT, typename Base>
         struct type: Base {
-            BOOST_OPAQUE_USING_LESS_THAN_EQUAL(Final)
+            BOOST_OPAQUE_USING_LESS_THAN_EQUAL(Final,Bool)
         };
     };
 
-#define BOOST_OPAQUE_USING_GREATER_THAN(Final) \
+#define BOOST_OPAQUE_USING_GREATER_THAN(Final,Bool) \
     public :\
-        bool operator>(const Final& rhs) const  { \
-            return Final::underlying(this) > rhs.underlying();\
+        Bool operator>(const Final& rhs) const  { \
+            return Bool(Final::underlying(this) > rhs.underlying());\
         }
 
+    template <typename Bool=bool>
     struct using_greater_than {
         template <typename Final, typename UT, typename Base>
         struct type: Base {
-            BOOST_OPAQUE_USING_GREATER_THAN(Final)
+            BOOST_OPAQUE_USING_GREATER_THAN(Final,Bool)
         };
     };
 
-#define BOOST_OPAQUE_USING_GREATER_THAN_EQUAL(Final) \
+#define BOOST_OPAQUE_USING_GREATER_THAN_EQUAL(Final,Bool) \
     public :\
-        bool operator>=(const Final& rhs) const  { \
-            return Final::underlying(this) >= rhs.underlying();\
+        Bool operator>=(const Final& rhs) const  { \
+            return Bool(Final::underlying(this) >= rhs.underlying());\
         }
 
+    template <typename Bool=bool>
     struct using_greater_than_equal {
         template <typename Final, typename UT, typename Base>
         struct type: Base {
-            BOOST_OPAQUE_USING_GREATER_THAN_EQUAL(Final)
+            BOOST_OPAQUE_USING_GREATER_THAN_EQUAL(Final,Bool)
         };
     };
 
-#define BOOST_OPAQUE_USING_EQUAL(Final) \
+#define BOOST_OPAQUE_USING_EQUAL(Final,Bool) \
     public :\
-        bool operator==(const Final& rhs) const  { \
-            return Final::underlying(this) == rhs.underlying();\
+        Bool operator==(const Final& rhs) const  { \
+            return Bool(Final::underlying(this) == rhs.underlying());\
         }
 
-    template <typename Final, typename Base>
+    template <typename Final, typename Base, typename Bool=bool>
     struct equal : Base {
-        BOOST_OPAQUE_USING_EQUAL(Final)
+        BOOST_OPAQUE_USING_EQUAL(Final,Bool)
     };
+    template <typename Bool=bool>
     struct using_equal {
         template <typename Final, typename UT, typename Base>
         struct type: Base {
-            BOOST_OPAQUE_USING_EQUAL(Final)
+            BOOST_OPAQUE_USING_EQUAL(Final,Bool)
         };
     };
 
-#define BOOST_OPAQUE_USING_NOT_EQUAL(Final) \
+#define BOOST_OPAQUE_USING_NOT_EQUAL(Final,Bool) \
     public :\
-        bool operator!=(const Final& rhs) const  { \
-            return Final::underlying(this) != rhs.underlying();\
+        Bool operator!=(const Final& rhs) const  { \
+            return Bool(Final::underlying(this) != rhs.underlying());\
         }
 
 
-    template <typename Final, typename Base>
+    template <typename Final, typename Base, typename Bool=bool>
     struct not_equal : Base {
-        BOOST_OPAQUE_USING_NOT_EQUAL(Final)
+        BOOST_OPAQUE_USING_NOT_EQUAL(Final,Bool)
     };
+    template <typename Bool=bool>
     struct using_not_equal {
         template <typename Final, typename UT, typename Base>
         struct type: Base {
-            BOOST_OPAQUE_USING_NOT_EQUAL(Final)
+            BOOST_OPAQUE_USING_NOT_EQUAL(Final,Bool)
         };
     };