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

Subject: [Boost-commit] svn:boost r65611 - sandbox/opaque/boost/opaque
From: vicente.botet_at_[hidden]
Date: 2010-09-26 15:01:10

Author: viboes
Date: 2010-09-26 15:01:07 EDT (Sun, 26 Sep 2010)
New Revision: 65611
URL: http://svn.boost.org/trac/boost/changeset/65611

Log:
Opaque: Rename _type by _class and add new _type that can be used in a typedef. _class mixins are used in the inhetit part of a class

Added:
   sandbox/opaque/boost/opaque/new_class.hpp   (contents, props changed)
   sandbox/opaque/boost/opaque/private_opaque_class.hpp   (contents, props changed)
   sandbox/opaque/boost/opaque/public_opaque_class.hpp   (contents, props changed)
Text files modified: 
   sandbox/opaque/boost/opaque/combined_operators.hpp  |    38 +++++++++++++++++++++++++++-----        
   sandbox/opaque/boost/opaque/macros.hpp              |    30 ++++++++++++++++++++-----               
   sandbox/opaque/boost/opaque/new_type.hpp            |    47 +++++++++++++++++++++++++++++---------- 
   sandbox/opaque/boost/opaque/opaque.hpp              |     3 ++                                      
   sandbox/opaque/boost/opaque/opaque_type.hpp         |    18 ---------------                         
   sandbox/opaque/boost/opaque/private_opaque_type.hpp |    20 +++++++++-------                        
   sandbox/opaque/boost/opaque/public_opaque_type.hpp  |    20 +++++++++-------                        
   7 files changed, 116 insertions(+), 60 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-26 15:01:07 EDT (Sun, 26 Sep 2010)
@@ -24,6 +24,11 @@
     template <typename Final, typename Base=base_new_type>
     struct equality_comparable1 : boost::equality_comparable1<Final, ope::equal<Final, Base> > {};
 
+    struct using_equality_comparable1 {
+        template <typename Final, typename UT, typename Base=base_new_type>
+        struct type : boost::equality_comparable1<Final, ope::equal<Final, Base> > {};
+    };
+
     template <typename Final, typename Base=base_new_type>
     struct less_than_comparable1 : boost::less_than_comparable1<Final, ope::less_than<Final, Base> > {};
 
@@ -67,10 +72,11 @@
     struct partially_ordered1 : boost::less_than_comparable1<Final, ope::less_than<Final, Base> > {};
 
 
-    template <class T, class B = base_new_type >
+    template <class T, class UT, class B = base_new_type >
     struct totally_ordered1
         : opaque::less_than_comparable1<T
-        , opaque::equality_comparable1<T, B
+        //~ , opaque::equality_comparable1<T, B
+        , opaque::using_equality_comparable1::template type<T, UT, B
           > > {};
 
     //~ template <class T, class U, class B = base_new_type >
@@ -184,10 +190,10 @@
         //~ , opaque::totally_ordered2<T, U, B
           //~ > > {};
 
-    template <class T, class B = base_new_type >
+    template <class T, class UT, class B = base_new_type >
     struct ordered_ring_operators1
         : opaque::ring_operators1<T
-        , opaque::totally_ordered1<T, B
+        , opaque::totally_ordered1<T, UT, B
           > > {};
 
     //~ template <class T, class U, class B = base_new_type >
@@ -209,14 +215,34 @@
         //~ , opaque::totally_ordered2<T, U, B
           //~ > > {};
 
-    template <class T, class B = base_new_type >
+    template <class T, class UT, class B = base_new_type >
     struct ordered_field_operators1
         : opaque::field_operators1<T
-        , opaque::totally_ordered1<T, B
+        , opaque::totally_ordered1<T, UT, B
           > > {};
 
 
+              
 }
+    template <typename T>
+    struct inherited_from_undelying {
+            template <typename Final, typename UT, typename Base=base_new_type>
+            struct type :
+                opaque::totally_ordered1< Final, T
+                ,   opaque::integer_arithmetic1< Final
+                    ,   boost::bitwise1< Final
+                        ,   opaque::unit_steppable< Final
+                            ,   opaque::ope::unary_plus< Final
+                                ,   opaque::ope::unary_minus< Final
+                                    ,   Base 
+                                    >
+                                >
+                            >
+                        >
+                    >
+                >
+            {};
+    };
 }
 
 

Modified: sandbox/opaque/boost/opaque/macros.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/macros.hpp	(original)
+++ sandbox/opaque/boost/opaque/macros.hpp	2010-09-26 15:01:07 EDT (Sun, 26 Sep 2010)
@@ -13,27 +13,37 @@
 #ifndef BOOST_OPAQUE_MACROS_HPP
 #define BOOST_OPAQUE_MACROS_HPP
 
+#include <boost/config.hpp>
 #include <boost/opaque/private_opaque_type.hpp>
 #include <boost/opaque/public_opaque_type.hpp>
+#include <boost/opaque/private_opaque_class.hpp>
+#include <boost/opaque/public_opaque_class.hpp>
 
 #define BOOST_OPAQUE_PUBLIC_FORWARD_CONSTRUCTORS(UT, OT) \
     OT(){} \
     template <typename W> \
     explicit OT(W w) \
-        : boost::public_opaque_type<OT, UT>(w) \
+        : boost::public_opaque_class<OT, UT>(w) \
     {}\
     OT(OT const& r) \
-        : boost::public_opaque_type<OT, UT>(r) \
+        : boost::public_opaque_class<OT, UT>(r) \
     {}
 
 #define BOOST_OPAQUE_PUBLIC_OPERATIONS(UT, OT) \
     BOOST_OPAQUE_PUBLIC_FORWARD_CONSTRUCTORS(UT,OT)\
 
+
+#if 1
 #define BOOST_OPAQUE_PUBLIC_TYPEDEF(UT, OT) \
-struct OT: boost::public_opaque_type<OT, UT> \
+struct OT: boost::public_opaque_class<OT, UT> \
 {\
     BOOST_OPAQUE_PUBLIC_OPERATIONS(UT,OT);\
 }
+#else
+#define BOOST_OPAQUE_PUBLIC_TYPEDEF(UT, OT) \
+struct BOOST_JOIN(OT, _tag) {};\
+typedef boost::public_opaque_type<UT, BOOST_JOIN(OT, _tag)> OT
+#endif
 
 
     //~ template <typename T> explicit OT(T v) : boost::private_opaque_type<OT, UT>(v) {}
@@ -42,10 +52,10 @@
     OT(){}\
     template <typename W> \
     explicit OT(W w) \
-        : boost::private_opaque_type<OT, UT>(w) \
+        : boost::private_opaque_class<OT, UT>(w) \
     {}\
     OT(OT const& r) \
-        : boost::private_opaque_type<OT, UT>(r) \
+        : boost::private_opaque_class<OT, UT>(r) \
     {}
 
 #define BOOST_OPAQUE_PRIVATE_OPERATIONS(UT, OT) \
@@ -53,10 +63,18 @@
 
 
 
+
+#if 1
 #define BOOST_OPAQUE_PRIVATE_TYPEDEF(UT, OT) \
-struct OT: boost::private_opaque_type<OT, UT> \
+struct OT: boost::private_opaque_class<OT, UT> \
 {\
     BOOST_OPAQUE_PRIVATE_OPERATIONS(UT,OT);\
 }
+#else
+#define BOOST_OPAQUE_PRIVATE_TYPEDEF(UT, OT) \
+struct BOOST_JOIN(OT, _tag) {};\
+typedef boost::private_opaque_type<UT, BOOST_JOIN(OT, _tag)> OT
+#endif
+
 
 #endif

Added: sandbox/opaque/boost/opaque/new_class.hpp
==============================================================================
--- (empty file)
+++ sandbox/opaque/boost/opaque/new_class.hpp	2010-09-26 15:01:07 EDT (Sun, 26 Sep 2010)
@@ -0,0 +1,75 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_NEW_CLASS_HPP
+#define BOOST_OPAQUE_NEW_CLASS_HPP
+
+#include <boost/opaque/new_type.hpp>
+
+namespace boost {
+
+    template <typename Final, typename T, typename Base=base_new_type >
+    class new_class : public Base
+    {
+    public:
+        typedef T underlying_type;
+
+        template <typename W>
+        explicit new_class(W v) : val_(v) {}
+        new_class(){}
+        new_class(const new_class & rhs) : val_(rhs.val_) {}
+        explicit new_class(T v) : val_(v) {}
+    protected:
+        T val_;
+        new_class & operator=(const new_class & rhs) {
+            val_ = rhs.val_; return *this;
+        }
+
+    public:
+        underlying_type const& underlying() const {
+            return val_;
+        }
+        underlying_type& underlying() {
+            return val_;
+        }
+
+        template<typename F>
+        static underlying_type& underlying(F* f){
+            return final(f).underlying();
+        }
+
+        template<typename F>
+        static underlying_type const& underlying(F const* f){
+            return final(f).underlying();
+        }
+
+        template<typename F>
+        static Final const& final(F const* f)  {
+            return static_cast<Final const&>(*f);
+        }
+        template<typename F>
+        Final& final(F* f) {
+            return static_cast<Final&>(*f);
+        }
+
+    };
+
+    template <typename T, typename Final, typename UT, typename Base >
+    T opaque_static_cast(new_class<Final, UT, Base> const& v)
+    {
+        return static_cast<T>(v.underlying());
+    }
+
+}
+
+
+#endif

Modified: sandbox/opaque/boost/opaque/new_type.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/new_type.hpp	(original)
+++ sandbox/opaque/boost/opaque/new_type.hpp	2010-09-26 15:01:07 EDT (Sun, 26 Sep 2010)
@@ -13,15 +13,38 @@
 #ifndef BOOST_OPAQUE_NEW_TYPE_HPP
 #define BOOST_OPAQUE_NEW_TYPE_HPP
 
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/fold.hpp>
+
 namespace boost {
 
     class base_new_type {};
 
+    ////// implementation //////
+    namespace detail{
+
+    template<typename NT, typename UT, typename State, typename Concept>
+    struct do_inhetit : Concept::template type<NT, UT, State> {
+    };
+
+    template<typename NT, typename UT>
+    struct inherit {
+        template<typename State, typename Concept>
+        struct apply{
+            typedef do_inhetit<NT, UT, State, Concept> type;
+        };
+    };
 
-    // T the underlying type must be regular
-    template <typename Final, typename T, typename Base=base_new_type >
-    class new_type : public Base
+    }
+    template <typename T, typename Tag, typename Concepts=boost::mpl::vector0<>, typename Base=base_new_type>
+    class new_type 
+        : public 
+            boost::mpl::fold<Concepts, Base, detail::inherit<new_type<T, Tag, Concepts, Base>, T> >::type
     {
+        typedef typename 
+            boost::mpl::fold<Concepts, Base, detail::inherit<new_type<T, Tag, Concepts, Base>, T> >::type
+        base_type;
+
     public:
         typedef T underlying_type;
 
@@ -30,11 +53,11 @@
         new_type(){}
         new_type(const new_type & rhs) : val_(rhs.val_) {}
         explicit new_type(T v) : val_(v) {}
+        //~ new_type & operator=(const new_type & rhs) {
+            //~ val_ = rhs.val_; return *this;
+        //~ }
     protected:
         T val_;
-        new_type & operator=(const new_type & rhs) {
-            val_ = rhs.val_; return *this;
-        }
 
     public:
         underlying_type const& underlying() const {
@@ -55,18 +78,18 @@
         }
 
         template<typename F>
-        static Final const& final(F const* f)  {
-            return static_cast<Final const&>(*f);
+        static new_type const& final(F const* f)  {
+            return static_cast<new_type const&>(*f);
         }
         template<typename F>
-        Final& final(F* f) {
-            return static_cast<Final&>(*f);
+        new_type& final(F* f) {
+            return static_cast<new_type&>(*f);
         }
 
     };
 
-    template <typename T, typename Final, typename UT, typename Base >
-    T opaque_static_cast(new_type<Final, UT, Base> const& v)
+    template <typename T, typename UT, typename Base, typename Tag >
+    T opaque_static_cast(new_type<UT, Base,Tag> const& v)
     {
         return static_cast<T>(v.underlying());
     }

Modified: sandbox/opaque/boost/opaque/opaque.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/opaque.hpp	(original)
+++ sandbox/opaque/boost/opaque/opaque.hpp	2010-09-26 15:01:07 EDT (Sun, 26 Sep 2010)
@@ -14,10 +14,13 @@
 #define BOOST_OPAQUE_OPAQUE_HPP
 
 #include <boost/opaque/new_type.hpp>
+#include <boost/opaque/new_class.hpp>
 #include <boost/opaque/operators.hpp>
 #include <boost/opaque/opaque_type.hpp>
 #include <boost/opaque/private_opaque_type.hpp>
+#include <boost/opaque/private_opaque_class.hpp>
 #include <boost/opaque/public_opaque_type.hpp>
+#include <boost/opaque/public_opaque_class.hpp>
 #include <boost/opaque/macros.hpp>
 
 #include <boost/mpl/bool.hpp>

Modified: sandbox/opaque/boost/opaque/opaque_type.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/opaque_type.hpp	(original)
+++ sandbox/opaque/boost/opaque/opaque_type.hpp	2010-09-26 15:01:07 EDT (Sun, 26 Sep 2010)
@@ -18,24 +18,6 @@
 
 namespace boost {
 
-    template <typename T, typename Final, typename Base>
-    struct inherited_from_undelying {
-        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 
-                                >
-                            >
-                        >
-                    >
-                >
-            >
-        {};
-    };
 
 }
 

Added: sandbox/opaque/boost/opaque/private_opaque_class.hpp
==============================================================================
--- (empty file)
+++ sandbox/opaque/boost/opaque/private_opaque_class.hpp	2010-09-26 15:01:07 EDT (Sun, 26 Sep 2010)
@@ -0,0 +1,63 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_PRIVATE_OPAQUE_CLASS_HPP
+#define BOOST_OPAQUE_PRIVATE_OPAQUE_CLASS_HPP
+
+#include <boost/opaque/combined_operators.hpp>
+#include <boost/opaque/private_opaque_type.hpp>
+
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/mpl/and.hpp>
+
+namespace boost {
+
+        
+    template <typename Final, typename T, typename Base=base_private_opaque_type>
+    class private_opaque_class : public 
+            new_class< Final, T, 
+                transitive_explicit_substituable<Final, T, 
+                    typename inherited_from_undelying<T>::template type<Final, T, Base>
+                >
+            >
+    {
+        typedef 
+            new_class< Final, T, 
+                transitive_explicit_substituable<Final, T, 
+                    typename inherited_from_undelying<T>::template type<Final, T, Base>
+                >
+            >
+        base_type;
+    protected:
+        typedef private_opaque_class opaque_class_t;
+    public:
+        //~ Can instances of UT be explicitly converted to instances of OT? Yes
+        //~ Can instances of UT be implicitly converted to instances of OT? No
+        //~ Can instances of OT be explicitly converted to instances of UT? Yes. 
+            //~ Waiting for explicit conversion operators,, the explicit conversion must be done through the underlying function
+        //~ Can instances of OT be implicitly converted to instances of UT? No
+
+        private_opaque_class() {};
+        private_opaque_class(const opaque_class_t & rhs) : base_type(rhs.val_) {}
+        private_opaque_class(const Final & rhs) : base_type(rhs.val_) {}
+        explicit private_opaque_class(T v) : base_type(v) {};
+        template <typename W>
+        explicit private_opaque_class(W v)
+            : base_type(v)
+        {}
+    };
+
+}
+
+
+#endif

Modified: sandbox/opaque/boost/opaque/private_opaque_type.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/private_opaque_type.hpp	(original)
+++ sandbox/opaque/boost/opaque/private_opaque_type.hpp	2010-09-26 15:01:07 EDT (Sun, 26 Sep 2010)
@@ -13,7 +13,8 @@
 #ifndef BOOST_OPAQUE_PRIVATE_OPAQUE_TYPE_HPP
 #define BOOST_OPAQUE_PRIVATE_OPAQUE_TYPE_HPP
 
-#include <boost/opaque/opaque_type.hpp>
+#include <boost/opaque/combined_operators.hpp>
+#include <boost/opaque/new_class.hpp>
 
 #include <boost/type_traits/is_class.hpp>
 #include <boost/type_traits/is_base_of.hpp>
@@ -54,18 +55,20 @@
     };
 #endif    
         
-    template <typename Final, typename T, typename Base=base_private_opaque_type>
+    template <typename T, typename Base=base_private_opaque_type, typename Tag=void>
     class private_opaque_type : public 
-            new_type< Final, T, 
-                transitive_explicit_substituable<Final, T, 
-                    typename inherited_from_undelying<T, Final, Base>::type 
+            new_class< private_opaque_type<T,Base,Tag >, T, 
+                transitive_explicit_substituable<private_opaque_type<T,Base,Tag >, T, 
+                    //~ typename inherited_from_undelying<T, private_opaque_type<T,Base,Tag>, Base>::type 
+                    typename inherited_from_undelying<T>::template type<private_opaque_type<T,Base,Tag>, T, Base>
                 >
             >
     {
         typedef 
-            new_type< Final, T, 
-                transitive_explicit_substituable<Final, T, 
-                    typename inherited_from_undelying<T, Final, Base>::type 
+            new_class< private_opaque_type<T,Base,Tag >, T, 
+                transitive_explicit_substituable<private_opaque_type<T,Base,Tag >, T, 
+                    //~ typename inherited_from_undelying<T, private_opaque_type<T,Base,Tag >, Base>::type 
+                    typename inherited_from_undelying<T>::template type<private_opaque_type<T,Base,Tag>, T, Base>
                 >
             >
         base_type;
@@ -80,7 +83,6 @@
 
         private_opaque_type() {};
         private_opaque_type(const opaque_type_t & rhs) : base_type(rhs.val_) {}
-        private_opaque_type(const Final & rhs) : base_type(rhs.val_) {}
         explicit private_opaque_type(T v) : base_type(v) {};
         template <typename W>
         explicit private_opaque_type(W v)

Added: sandbox/opaque/boost/opaque/public_opaque_class.hpp
==============================================================================
--- (empty file)
+++ sandbox/opaque/boost/opaque/public_opaque_class.hpp	2010-09-26 15:01:07 EDT (Sun, 26 Sep 2010)
@@ -0,0 +1,70 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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_PUBLIC_OPAQUE_CLASS_HPP
+#define BOOST_OPAQUE_PUBLIC_OPAQUE_CLASS_HPP
+
+#include <boost/opaque/combined_operators.hpp>
+#include <boost/opaque/public_opaque_type.hpp>
+
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/vector.hpp>
+
+namespace boost {
+
+
+    template <typename Final, typename T, typename Base=base_public_opaque_type>
+    class public_opaque_class
+        : public
+            new_class< Final, T, 
+                transitive_substituable<Final, T, 
+                    typename inherited_from_undelying<T>::template type<Final, T, Base>
+                > 
+            >
+
+    {
+        typedef
+            new_class< Final, T, 
+                transitive_substituable<Final, T, 
+                    typename inherited_from_undelying<T>::template type<Final, T, Base>
+                > 
+            >
+        base_type;
+
+    protected:
+        typedef public_opaque_class opaque_class_t;
+    public:
+        typedef typename get_substituables<T,
+                mpl::and_<is_class<T>, is_base_of<base_public_opaque_type,T> >::value
+                 >::type substituables;
+
+        //~ Can instances of UT be explicitly converted to instances of OT? Yes
+        //~ Can instances of UT be implicitly converted to instances of OT? No
+        //~ Can instances of OT be explicitly converted to instances of UT? Yes
+        //~ Can instances of OT be implicitly converted to instances of UT? Yes
+
+        public_opaque_class() {}
+        public_opaque_class(const opaque_class_t & rhs) : base_type(rhs.val_){}
+        public_opaque_class(const Final & rhs) : base_type(rhs.val_){}
+        explicit public_opaque_class(T v) : base_type(v) {}
+        template <typename W>
+        explicit public_opaque_class(W v) : base_type(v) {}
+
+    };
+
+}
+
+
+#endif

Modified: sandbox/opaque/boost/opaque/public_opaque_type.hpp
==============================================================================
--- sandbox/opaque/boost/opaque/public_opaque_type.hpp	(original)
+++ sandbox/opaque/boost/opaque/public_opaque_type.hpp	2010-09-26 15:01:07 EDT (Sun, 26 Sep 2010)
@@ -13,7 +13,8 @@
 #ifndef BOOST_OPAQUE_PUBLIC_OPAQUE_TYPE_HPP
 #define BOOST_OPAQUE_PUBLIC_OPAQUE_TYPE_HPP
 
-#include <boost/opaque/opaque_type.hpp>
+#include <boost/opaque/combined_operators.hpp>
+#include <boost/opaque/new_class.hpp>
 
 #include <boost/type_traits/is_class.hpp>
 #include <boost/type_traits/is_base_of.hpp>
@@ -65,20 +66,22 @@
         }
     };
 
-    template <typename Final, typename T, typename Base=base_public_opaque_type>
+    template <typename T, typename Base=base_public_opaque_type, typename Tag=void>
     class public_opaque_type
         : public
-            new_type< Final, T, 
-                transitive_substituable<Final, T, 
-                    typename inherited_from_undelying<T, Final, Base>::type 
+            new_class< public_opaque_type<T,Base,Tag >, T, 
+                transitive_substituable<public_opaque_type<T,Base,Tag >, T, 
+                    //~ typename inherited_from_undelying<T, public_opaque_type<T,Base,Tag >, Base>::type 
+                    typename inherited_from_undelying<T>::template type<public_opaque_type<T,Base,Tag>, T, Base>
                 > 
             >
 
     {
         typedef
-            new_type< Final, T, 
-                transitive_substituable<Final, T, 
-                    typename inherited_from_undelying<T, Final, Base>::type 
+            new_class< public_opaque_type<T,Base,Tag >, T, 
+                transitive_substituable<public_opaque_type<T,Base,Tag >, T, 
+                    //~ typename inherited_from_undelying<T, public_opaque_type<T,Base,Tag >, Base>::type 
+                    typename inherited_from_undelying<T>::template type<public_opaque_type<T,Base,Tag>, T, Base>
                 > 
             >
         base_type;
@@ -97,7 +100,6 @@
 
         public_opaque_type() {}
         public_opaque_type(const opaque_type_t & rhs) : base_type(rhs.val_){}
-        public_opaque_type(const Final & rhs) : base_type(rhs.val_){}
         explicit public_opaque_type(T v) : base_type(v) {}
         template <typename W>
         explicit public_opaque_type(W v) : base_type(v) {}