From b9aa8033c7e8a5fc7a1d533deb53f4c8a6ab137a Mon Sep 17 00:00:00 2001
From: Ichthyostega <prg@ichthyostega.de>
Date: Sat, 25 Apr 2015 18:51:49 +0200
Subject: [PATCH] Ticket #141: rewrite of AccessCasted -- cover the basics

get the param handling straight, including rvalue references.
We do not want to allow any dangerous combinations anymore.
---
 src/lib/access-casted.hpp                 | 136 +++++++---------------
 tests/library/meta/access-casted-test.cpp |  87 +++++++-------
 2 files changed, 93 insertions(+), 130 deletions(-)

diff --git a/src/lib/access-casted.hpp b/src/lib/access-casted.hpp
index ec7761dd6..1880f3709 100644
--- a/src/lib/access-casted.hpp
+++ b/src/lib/access-casted.hpp
@@ -43,132 +43,86 @@
 #ifndef UTIL_ACCESS_CASTED_H
 #define UTIL_ACCESS_CASTED_H
 
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_polymorphic.hpp>
-#include <boost/type_traits/is_base_of.hpp>
+#include "lib/error.hpp"
+
+#include <type_traits>
+#include <utility>
 
 
 
 namespace util {
-  using boost::remove_pointer;
-  using boost::remove_reference;
-  using boost::is_convertible;
-  using boost::is_polymorphic;
-  using boost::is_base_of;
-  using boost::enable_if;
-  
-  
-  template <typename SRC, typename TAR>
-  struct can_cast : boost::false_type {};
-  
-  template <typename SRC, typename TAR>
-  struct can_cast<SRC*,TAR*>          { enum { value = is_base_of<SRC,TAR>::value };};
-  
-  template <typename SRC, typename TAR>
-  struct can_cast<SRC*&,TAR*>         { enum { value = is_base_of<SRC,TAR>::value };};
-  
-  template <typename SRC, typename TAR>
-  struct can_cast<SRC&,TAR&>          { enum { value = is_base_of<SRC,TAR>::value };};
+  using std::remove_pointer;
+  using std::remove_reference;
   
   
   template <typename T>
   struct has_RTTI
     {
-      typedef typename remove_pointer<
-              typename remove_reference<T>::type>::type TPlain;
+      using PlainType = typename remove_pointer<
+                        typename remove_reference<T>::type>::type;
     
-      enum { value = is_polymorphic<TPlain>::value };
+      static constexpr bool value = std::is_polymorphic<PlainType>::value;
     };
   
   template <typename SRC, typename TAR>
-  struct use_dynamic_downcast
+  struct can_downcast
     {
-      enum { value = can_cast<SRC,TAR>::value
-                     &&  has_RTTI<SRC>::value
-                     &&  has_RTTI<TAR>::value
-           };
+      using PlainSRC = typename remove_pointer<
+                       typename remove_reference<SRC>::type>::type;
+      using PlainTAR = typename remove_pointer<
+                       typename remove_reference<TAR>::type>::type;
+    
+      static constexpr bool value = std::is_base_of<PlainSRC, PlainTAR>::value;
     };
   
   template <typename SRC, typename TAR>
-  struct use_static_downcast
+  struct can_use_dynamic_downcast
     {
-      enum { value = can_cast<SRC,TAR>::value
-                  && (  !has_RTTI<SRC>::value
-                     || !has_RTTI<TAR>::value
-                     )
-           };
+      static constexpr bool value =  !std::is_convertible<SRC,TAR>::value
+                                   && can_downcast<SRC,TAR>::value
+                                   && has_RTTI<TAR>::value;
     };
   
   template <typename SRC, typename TAR>
-  struct use_conversion
-    {
-      enum { value = is_convertible<SRC,TAR>::value
-                  && !( use_static_downcast<SRC,TAR>::value
-                      ||use_dynamic_downcast<SRC,TAR>::value
-                      )
-           };
-    };
+  struct can_use_conversion
+    : std::is_convertible<SRC,TAR>
+    { };
   
   
+  template <typename SRC, typename TAR>
+  struct if_can_use_dynamic_downcast
+    : std::enable_if< can_use_dynamic_downcast<SRC,TAR>::value, TAR>
+    { };
   
-                                ////////////////////////////////TODO: use lib::NullValue instead
-  template<typename X>
-  struct EmptyVal
-    {
-      static X create()    { return X(); }
-    };
-  template<typename X>
-  struct EmptyVal<X*&>
-    {
-      static X*& create()  { static X* nullP(0); return nullP; }
-    };
+  template <typename SRC, typename TAR>
+  struct if_can_use_conversion
+    : std::enable_if< can_use_conversion<SRC,TAR>::value, TAR>
+    { };
+    
   
-  
-  
-  
-  
-  template<typename RET>
-  struct NullAccessor
-    {
-      typedef RET Ret;
       
-      static RET access  (...) { return ifEmpty(); }
-      static RET ifEmpty ()    { return EmptyVal<RET>::create(); }
-    };
-  
   template<typename TAR>
-  struct AccessCasted : NullAccessor<TAR>
+  struct AccessCasted
     {
-      using NullAccessor<TAR>::access;
+      typedef TAR Ret;
       
-      template<typename ELM>
-      static  typename enable_if< use_dynamic_downcast<ELM&,TAR>,
-      TAR     >::type
-      access (ELM& elem)
+      template<typename SRC>
+      static  typename if_can_use_dynamic_downcast<SRC&&,TAR>::type
+      access (SRC&& elem)
         {
-          return dynamic_cast<TAR> (elem);
+          std::cerr << "downcast-"<<lib::test::showRefKind<SRC>()<<" && ->"<<lib::test::showRefKind<SRC&&>()<<std::endl;
+          return dynamic_cast<TAR> (std::forward<SRC>(elem));
         }
       
-      template<typename ELM>
-      static  typename enable_if< use_static_downcast<ELM&,TAR>,
-      TAR     >::type
-      access (ELM& elem)
+      template<typename SRC>
+      static  typename if_can_use_conversion<SRC&&,TAR>::type
+      access (SRC&& elem)
         {
-          return static_cast<TAR> (elem);
-        }
-      
-      template<typename ELM>
-      static  typename enable_if< use_conversion<ELM&,TAR>,
-      TAR     >::type
-      access (ELM& elem)
-        {
-          return elem;
+          std::cerr << "convert-"<<lib::test::showRefKind<SRC>()<<" && ->"<<lib::test::showRefKind<SRC&&>()<<std::endl;
+          return std::forward<SRC> (elem);
         }
     };
   
-
+  
 } // namespace util
 #endif
diff --git a/tests/library/meta/access-casted-test.cpp b/tests/library/meta/access-casted-test.cpp
index 00cefb9cb..d1b4be725 100644
--- a/tests/library/meta/access-casted-test.cpp
+++ b/tests/library/meta/access-casted-test.cpp
@@ -26,10 +26,14 @@
 #include "lib/test/test-helper.hpp"
 #include "lib/access-casted.hpp"
 
+#include <iostream>
+#include <utility>
+#include <string>
 
+using std::move;
 using std::string;
-using std::cout;
 using std::ostream;
+using std::cout;
 
 
 namespace util {
@@ -90,56 +94,61 @@ namespace test {
           E* pE = &f;
           D* pDE = pE;
           
-          cout <<  "is_base_of<B,D> = "   << is_base_of<B ,D >::value << "\n";
-          cout <<  "is_base_of<B*,D*> = " << is_base_of<B*,D*>::value << "\n";
-          cout <<  "is_base_of<B&,D&> = " << is_base_of<B&,D&>::value << "\n";
+          cout <<  "can_downcast<B,D>     = " << can_downcast<B,D>::value << "\n";
+          cout <<  "can_downcast<B*,D*>   = " << can_downcast<B*,D*>::value << "\n";
+          cout <<  "can_downcast<B&,D&>   = " << can_downcast<B&,D&>::value << "\n";
+          cout <<  "can_downcast<B&,D*>   = " << can_downcast<B&,D*>::value << "\n";
+          cout <<  "can_downcast<B*,D&>   = " << can_downcast<B*,D&>::value << "\n";
+          cout <<  "can_downcast<B*&,D*&> = " << can_downcast<B*&,D*&>::value << "\n";
+          cout <<  "can_downcast<D*&,D*&> = " << can_downcast<D*&,D*&>::value << "\n";
           
-          cout <<  "can_cast<B,D> = " << can_cast<B,D>::value << "\n";
-          cout <<  "can_cast<B*,D*> = " << can_cast<B*,D*>::value << "\n";
-          cout <<  "can_cast<B&,D&> = " << can_cast<B&,D&>::value << "\n";
-          cout <<  "can_cast<B&,D*> = " << can_cast<B&,D*>::value << "\n";
-          cout <<  "can_cast<B*,D&> = " << can_cast<B*,D&>::value << "\n";
-          cout <<  "can_cast<B*&,D*&> = " << can_cast<B*&,D*&>::value << "\n";
-          cout <<  "can_cast<D*&,D*&> = " << can_cast<D*&,D*&>::value << "\n";
-          
-          cout <<  "can_cast<D*,E*> = " << can_cast<D*,E*>::value << "\n";
-          cout <<  "can_cast<E*,F*> = " << can_cast<E*,F*>::value << "\n";
+          cout <<  "can_downcast<D*,E*>   = " << can_downcast<D*,E*>::value << "\n";
+          cout <<  "can_downcast<E*,F*>   = " << can_downcast<E*,F*>::value << "\n";
           
           cout <<  "has_RTTI<D*> = " << has_RTTI<D*>::value << "\n";
           cout <<  "has_RTTI<E*> = " << has_RTTI<E*>::value << "\n";
           cout <<  "has_RTTI<F*> = " << has_RTTI<F*>::value << "\n";
           
+          cout <<  "is_convertible<D,D&>  = " << std::is_convertible<D,D&>::value << "\n";
+          cout <<  "is_convertible<D&,D>  = " << std::is_convertible<D&,D>::value << "\n";
           
-          cout <<  "use_dynamic_downcast<B*,D*> = " << use_dynamic_downcast<B*,D*>::value << "\n";
-          cout <<  "use_static_downcast<B*,D*> = " << use_static_downcast<B*,D*>::value << "\n";
-          cout <<  "use_conversion<D*,B*> = "      << use_conversion<D*,B*>::value << "\n";
           
-          cout <<  "use_static_downcast<D*&,D*&> = " << use_static_downcast<D*&,D*&>::value << "\n";
-          cout <<  "use_static_downcast<D*,E*> = " << use_static_downcast<D*,E*>::value << "\n";
-          cout <<  "use_dynamic_downcast<D*&,E*> = " << use_dynamic_downcast<D*&,E*>::value << "\n";
+          cout <<  "can_use_dynamic_downcast<D,D&>  = " << can_use_dynamic_downcast<D,D&>::value << "\n";
+          cout <<  "can_use_conversion<D,D&>        = " << can_use_conversion<D,D&>::value << "\n";
+          cout <<  "can_use_dynamic_downcast<B*,D*> = " << can_use_dynamic_downcast<B*,D*>::value << "\n";
+          cout <<  "can_use_conversion<D*,B*>       = " << can_use_conversion<D*,B*>::value << "\n";
+          
+          cout <<  "can_use_dynamic_downcast<D*&,D*&> = " << can_use_dynamic_downcast<D*&,D*&>::value << "\n";
+          cout <<  "can_use_conversion<D*&,D*&>       = " << can_use_conversion<D*&,D*&>::value << "\n";
+          cout <<  "can_use_conversion<D*,E*>         = " << can_use_conversion<D*,E*>::value << "\n";
+          cout <<  "can_use_dynamic_downcast<D*&,E*>  = " << can_use_dynamic_downcast<D*&,E*>::value << "\n";
           
           
           cout <<  "Access(D  as D&)    --->" << AccessCasted<D&>::access(d)  << "\n";
           cout <<  "Access(D& as D&)    --->" << AccessCasted<D&>::access(rD) << "\n";
-          cout <<  "Access(B& as D&)    --->" << AccessCasted<D&>::access(rB) << "\n";
-          cout <<  "Access(D* as D*)    --->" << AccessCasted<D*>::access(pD) << "\n";
-          cout <<  "Access(B* as D*)    --->" << AccessCasted<D*>::access(pB) << "\n";
-          cout <<  "Access(D*& as D*&)  --->" << AccessCasted<D*&>::access(rpD) << "\n";
-          cout <<  "Access(B*& as D*&)  --->" << AccessCasted<D*&>::access(rpB) << "\n";
-          
-          cout <<  "Access(D  as B&)    --->" << AccessCasted<B&>::access(d)  << "\n";
-          cout <<  "Access(D& as B&)    --->" << AccessCasted<B&>::access(rD) << "\n";
-          cout <<  "Access(B& as B&)    --->" << AccessCasted<D&>::access(rB) << "\n";
-          cout <<  "Access(D* as B*)    --->" << AccessCasted<B*>::access(pD) << "\n";
-          cout <<  "Access(B* as B*)    --->" << AccessCasted<B*>::access(pB) << "\n";
-          cout <<  "Access(D*& as B*&)  --->" << AccessCasted<B*&>::access(rpD) << "\n";
-          cout <<  "Access(B*& as B*&)  --->" << AccessCasted<B*&>::access(rpB) << "\n";
-          
-          cout <<  "Access(D  as E&)    --->" << AccessCasted<E&>::access(d) << "\n";
-          cout <<  "Access(E& as F&)    --->" << AccessCasted<F&>::access(rE) << "\n";
-          cout <<  "Access(D(E)* as E*) --->" << AccessCasted<E*>::access(pDE) << "\n";
-          cout <<  "Access(D(E)* as F*) --->" << AccessCasted<F*>::access(pDE) << "\n";
-          cout <<  "Access(E* as F*)    --->" << AccessCasted<F*>::access(pE) << "\n";
+          cout <<  "Access(D  as D)     --->" << AccessCasted<D>::access(d) << "\n";
+          cout <<  "Access(D& as D)     --->" << AccessCasted<D>::access(rD) << "\n";
+          D dd1(d);
+          cout <<  "Access(D&& as D)    --->" << AccessCasted<D>::access(move(dd1)) << "\n";
+//        cout <<  "Access(B& as D&)    --->" << AccessCasted<D&>::access(rB) << "\n";
+//        cout <<  "Access(D* as D*)    --->" << AccessCasted<D*>::access(pD) << "\n";
+//        cout <<  "Access(B* as D*)    --->" << AccessCasted<D*>::access(pB) << "\n";
+//        cout <<  "Access(D*& as D*&)  --->" << AccessCasted<D*&>::access(rpD) << "\n";
+//        cout <<  "Access(B*& as D*&)  --->" << AccessCasted<D*&>::access(rpB) << "\n";
+//        
+//        cout <<  "Access(D  as B&)    --->" << AccessCasted<B&>::access(d)  << "\n";
+//        cout <<  "Access(D& as B&)    --->" << AccessCasted<B&>::access(rD) << "\n";
+//        cout <<  "Access(B& as B&)    --->" << AccessCasted<D&>::access(rB) << "\n";
+//        cout <<  "Access(D* as B*)    --->" << AccessCasted<B*>::access(pD) << "\n";
+//        cout <<  "Access(B* as B*)    --->" << AccessCasted<B*>::access(pB) << "\n";
+//        cout <<  "Access(D*& as B*&)  --->" << AccessCasted<B*&>::access(rpD) << "\n";
+//        cout <<  "Access(B*& as B*&)  --->" << AccessCasted<B*&>::access(rpB) << "\n";
+//        
+//        cout <<  "Access(D  as E&)    --->" << AccessCasted<E&>::access(d) << "\n";
+//        cout <<  "Access(E& as F&)    --->" << AccessCasted<F&>::access(rE) << "\n";
+//        cout <<  "Access(D(E)* as E*) --->" << AccessCasted<E*>::access(pDE) << "\n";
+//        cout <<  "Access(D(E)* as F*) --->" << AccessCasted<F*>::access(pDE) << "\n";
+//        cout <<  "Access(E* as F*)    --->" << AccessCasted<F*>::access(pE) << "\n";
         }
     };