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

Subject: [Boost-commit] svn:boost r64128 - sandbox/opaque/boost/opaque
From: vicente.botet_at_[hidden]
Date: 2010-07-18 11:36:24

Author: viboes
Date: 2010-07-18 11:36:24 EDT (Sun, 18 Jul 2010)
New Revision: 64128
URL: http://svn.boost.org/trac/boost/changeset/64128

Log:
development continue
Text files modified: 
   sandbox/opaque/boost/opaque/opaque.hpp |   278 +++++++++++++++++++++++---------------- 
   1 files changed, 163 insertions(+), 115 deletions(-)

Modified: sandbox/opaque/boost/opaque/opaque.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/opaque.hpp	(original)
+++ sandbox/opaque/boost/opaque/opaque.hpp	2010-07-18 11:36:24 EDT (Sun, 18 Jul 2010)
@@ -15,57 +15,94 @@
 
 #include <boost/config.hpp>
 #include <boost/operators.hpp>
-
-namespace boost {
-    template <typename Final, typename T, bool Convertible=true>
-    class opaque_type;
-
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/single_view.hpp>
+#include <boost/mpl/push_back.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/empty_sequence.hpp>
+#include <boost/mpl/contains.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_fundamental.hpp>
 
     //~ *  totally_ordered<OT>
     //~ * integer_arithmetic<OT>
     //~ * bitwise<OT>
     //~ * unit_steppable<OT>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/bool.hpp>
+#define BOOST_OPAQUE_STATIC_ASSERT(CND, MSG, TYPES)                                 \
+    BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
+    
+namespace boost {
 
-    //~ * totally_ordered<UT, OT>
-    //~ * integer_arithmetic<UT, OT>
-    //~ * bitwise<UT, OT>
+    class base_public_opaque_type {};
+    class base_private_opaque_type {};
+        
+        
+    template <typename T, bool B>
+    struct get_substituables;
 
-    template <typename Final, typename T>
-    class public_opaque_type
+    template <typename T>
+    struct get_substituables<T,true> {
+        typedef typename mpl::push_front<typename T::substituables, T>::type type; 
+    };
+
+    template <typename T>
+    struct get_substituables<T,false> {
+        //~ typedef typename mpl::push_front<mpl::empty_sequence, T>::type type; 
+        typedef mpl::vector<T> type; 
+        //~ typedef mpl::single_view<T> type; 
+    };
+
+    template <typename Final, typename T, typename Base=base_private_opaque_type>
+    class opaque_type
         : boost::totally_ordered< Final
-        , boost::integer_arithmetic< Final
-        , boost::bitwise< Final
-        , boost::unit_steppable< Final
-        , boost::totally_ordered< T, Final  // public specific conversions
-        , boost::integer_arithmetic< T, Final // public specific conversions
-        , boost::bitwise< T, Final // public specific conversions
-        > > > > > > >
+          , boost::integer_arithmetic< Final
+            , boost::bitwise< Final
+              , boost::unit_steppable< Final
+                , Base
+              >
+            >
+          >
+        >
     {
     protected:
         T val_;
-        typedef public_opaque_type opaque_type;
     public:
         typedef T underlying_type;
-        //~ Can instances of UT be explicitly converted to instances of OT?
-        //~ Proposed answer: yes.
-        //~ Can instances of UT be implicitly converted to instances of OT?
-        //~ Proposed answer: no.
-
-        explicit public_opaque_type(const T v)
+        typedef typename get_substituables<T,
+                mpl::and_<is_class<T>, is_base_of<base_public_opaque_type,T> >::value 
+                 >::type substituables;
+    
+        template <typename W>
+        explicit opaque_type(const W v, enable_if<mpl::contains<substituables,W> >*dummy =0)
             : val_(v)
-        {};
-        public_opaque_type()
-        {};
-        public_opaque_type(const opaque_type & rhs)
+        {}
+
+        opaque_type()
+        {}
+
+        opaque_type(const opaque_type & rhs)
             : val_(rhs.val_)
         {}
-        public_opaque_type & operator=(const opaque_type & rhs) {
+    protected:            
+        opaque_type & operator=(const opaque_type & rhs) {
             val_ = rhs.val_; return *this;
         }
-        public_opaque_type & operator=(const T rhs) {
-            val_ = rhs; return *this;
-        }
+        //~ opaque_type & operator=(const T rhs) {
+            //~ val_ = rhs; return *this;
+        //~ }
 
+        template <typename W>
+        typename enable_if<mpl::contains<substituables,W>, opaque_type &>::type
+        operator=(const W rhs) {
+            val_ = rhs;
+            return *this;
+        }
+    public:            
         T const& underlying() const {
             return val_;
         }
@@ -73,18 +110,9 @@
             return val_;
         }
 
-        // public specific conversions
-        operator const T & () const {
-            return val_;
-        }
-        operator T & () {
-            return val_;
-        }
-#if 0
         bool operator==(const opaque_type & rhs) const {
             return val_ == rhs.val_;
         }
-#endif
         bool operator<(const Final & rhs) const {
             return val_ < rhs.val_;
         }
@@ -110,16 +138,71 @@
         }
     };
 
+
+
+
+    template <typename Final, typename T>
+    class public_opaque_type
+        : public opaque_type< Final, T, base_public_opaque_type>
+    {
+    protected:
+        typedef public_opaque_type opaque_type_t;
+    public:
+        typedef T underlying_type;
+        typedef typename opaque_type< Final, T, base_public_opaque_type>::substituables substituables; 
+        //~ Can instances of UT be explicitly converted to instances of OT?
+        //~ Proposed answer: yes.
+        //~ Can instances of UT be implicitly converted to instances of OT?
+        //~ Proposed answer: no.
+
+        template <typename W>
+        explicit public_opaque_type(const W v, enable_if<mpl::contains<substituables,W> >*dummy =0)
+            : opaque_type< Final, T, base_public_opaque_type>(v)
+        {}
+
+        public_opaque_type()
+        {}
+
+        public_opaque_type(const opaque_type_t & rhs)
+            : opaque_type< Final, T, base_public_opaque_type>(rhs.val_)
+        {}
+        public_opaque_type & operator=(const opaque_type_t & rhs) {
+            this->val_ = rhs.val_; return *this;
+        }
+        
+        //~ template <typename W>
+        //~ typename enable_if<mpl::contains<substituables,W>, public_opaque_type &>::type
+        //~ operator=(const W rhs) {
+            //~ this->operator=(rhs);
+            //~ return *this;
+        //~ }
+
+
+        // public specific conversions
+        operator const T & () const {
+            return this->val_;
+        }
+        operator T & () {
+            return this->val_;
+        }
+        
+        //~ template <typename W>
+        //~ operator const W & () const {
+            //~ return W(this->val_);
+        //~ }
+        //~ template <typename W>
+        //~ operator W & () {
+            //~ return W(this->val_);
+        //~ }
+
+    };
+
     template <typename Final, typename T>
     class private_opaque_type
-        : boost::totally_ordered< Final
-        , boost::integer_arithmetic< Final
-        , boost::bitwise< Final
-        , boost::unit_steppable< Final
-        > > > >
+        : public opaque_type< Final, T, base_private_opaque_type>
     {
-        T val_;
-        typedef private_opaque_type opaque_type;
+    protected:
+        typedef private_opaque_type opaque_type_t;
     public:
         typedef T underlying_type;
         //~ Can instances of UT be explicitly converted to instances of OT?
@@ -128,24 +211,18 @@
         //~ Proposed answer: no.
 
         explicit private_opaque_type(const T v)
-            : val_(v)
+            : opaque_type< Final, T, base_private_opaque_type>(v)
         {};
         private_opaque_type()
         {};
-        private_opaque_type(const opaque_type & rhs)
-            : val_(rhs.val_)
+        private_opaque_type(const opaque_type_t & rhs)
+            : opaque_type< Final, T, base_private_opaque_type>(rhs.val_)
         {}
-        private_opaque_type & operator=(const opaque_type & rhs) {
-            val_ = rhs.val_; return *this;
-        }
+        //~ private_opaque_type & operator=(const opaque_type_t & rhs) {
+            //~ val_ = rhs.val_; return *this;
+        //~ }
+
 
-        T underlying() const {
-            return val_;
-        }
-        T& underlying() {
-            return val_;
-        }
-        
         //~ // public specific conversions
         //~ operator const T & () const {
             //~ return val_;
@@ -153,39 +230,14 @@
         //~ operator T & () {
             //~ return val_;
         //~ }
-        bool operator==(const Final & rhs) const {
-            return val_ == rhs.val_;
-        }
-        bool operator<(const Final & rhs) const {
-            return val_ < rhs.val_;
-        }
-        Final& operator+=(const Final & rhs) {
-            val_ += rhs.val_;
-            return static_cast<Final&>(*this);
-        }
-        Final& operator-=(const Final & rhs) {
-            val_ -= rhs.val_;
-            return static_cast<Final&>(*this);
-        }
-        Final& operator*=(const Final & rhs) {
-            val_ *= rhs.val_;
-            return static_cast<Final&>(*this);
-        }
-        Final& operator/=(const Final & rhs) {
-            val_ /= rhs.val_;
-            return static_cast<Final&>(*this);
-        }
-        Final& operator%=(const Final & rhs) {
-            val_ %= rhs.val_;
-            return static_cast<Final&>(*this);
-        }
     };
 
     template <typename T, typename U>
     T opaque_static_cast(U v)    {
-        return static_castT<T>(v);
+        return static_cast<T>(v);
     }
-    
+
+    #if 0
     template <typename T, typename UT, typename OT>
     T opaque_static_cast<T, private_opaque_type<OT,UT> >(
         private_opaque_type<OT,UT> const&ot)    {
@@ -196,17 +248,17 @@
         T t)    {
         return private_opaque_type<OT,UT>(static_cast<UT>(t));
     }
-    
+
     template <typename T, typename UT, typename OT>
     T opaque_static_cast<UT,public_opaque_type<OT,UT>>(private_opaque_type<OT,UT> const&ot)    {
         return static_cast<T>(ot.underlying());
     }
-    
+
     template <typename UT, typename OT>
     UT opaque_static_cast<UT,private_opaque_type<OT,UT>>(private_opaque_type<OT,UT> const&ot)    {
         return ot.underlying();
     }
-    
+
     template <typename X, typename Y>
     OT opaque_dynamic_cast(Y y)    {
         return dynamic_cast<X>(y);
@@ -215,42 +267,38 @@
     UT opaque_dynamic_cast<X,private_opaque_type<OT,UT> >(private_opaque_type<OT,UT> *ot)    {
         return dynamic_cast<X>(&ot->underlying());
     }
-    
+    #endif
 }
 
-#define BOOST_OPAQUE_PUBLIC_FORWARD_CONSTRUCTORS(OT, UT) \
-    OT(){}\
-    template <typename T> explicit OT(T v) : boost::public_opaque_type<OT, UT>(v) {}
-
-#define BOOST_OPAQUE_PUBLIC_OPERATIONS(OT, UT) \
-    BOOST_OPAQUE_FORWARD_CONSTRUCTORS(OT,OT);\
-    bool operator<(const OT & rhs) const {\
-        return val_ < rhs.val_;\
-    }\
-
-    //~ OT& operator+=(const OT & rhs) {
-        //~ val_ += rhs.val_;
-        //~ return *this;
-    //~ }
-
-#define BOOST_OPAQUE_PRIVATE_FORWARD_CONSTRUCTORS(OT, UT) \
-    OT(){}\
-    template <typename T> explicit OT(T v) : boost::private_opaque_type<OT, UT>(v) {}
+#define BOOST_OPAQUE_PUBLIC_FORWARD_CONSTRUCTORS(UT, OT) \
+    OT(){} \
+    explicit OT(UT w) \
+        : boost::public_opaque_type<OT, UT>(w) \
+    {}
 
-#define BOOST_OPAQUE_PRIVATE_OPERATIONS(OT, UT) \
-    BOOST_OPAQUE_PRIVATE_FORWARD_CONSTRUCTORS(OT, UT)
+#define BOOST_OPAQUE_PUBLIC_OPERATIONS(UT, OT) \
+    BOOST_OPAQUE_PUBLIC_FORWARD_CONSTRUCTORS(UT,OT)\
 
 #define BOOST_OPAQUE_PUBLIC_TYPEDEF(UT, OT) \
 struct OT: boost::public_opaque_type<OT, UT> \
 {\
-    BOOST_OPAQUE_PUBLIC_OPERATIONS(OT,UT);\
+    BOOST_OPAQUE_PUBLIC_OPERATIONS(UT,OT);\
 }
 
 
+#define BOOST_OPAQUE_PRIVATE_FORWARD_CONSTRUCTORS(UT, OT) \
+    OT(){}\
+    template <typename T> explicit OT(T v) : boost::private_opaque_type<OT, UT>(v) {}
+
+#define BOOST_OPAQUE_PRIVATE_OPERATIONS(UT, OT) \
+    BOOST_OPAQUE_PRIVATE_FORWARD_CONSTRUCTORS(UT, OT)
+
+
+
 #define BOOST_OPAQUE_PRIVATE_TYPEDEF(UT, OT) \
 struct OT: boost::private_opaque_type<OT, UT> \
 {\
-    BOOST_OPAQUE_PRIVATE_OPERATIONS(OT,UT);\
+    BOOST_OPAQUE_PRIVATE_OPERATIONS(UT,OT);\
 }
 
 #endif