Research: corner cases of "perfect forwarding"

research/try.cpp

@@ -25,230 +25,105 @@
 // 1/12  - is partial application of member functions possible?
 // 5/14  - c++11 transition: detect empty function object
 // 7/14  - c++11 transition: std hash function vs. boost hash
+// 9/14  - variadic templates and perfect forwarding
 
 
 /** @file try.cpp
- ** Investigation: how to supply a hash function for custom types.
+ ** Investigation: pitfalls of "perfect forwarding".
- ** This example defines two custom types, each of which provides a way
+ ** Find out about the corner cases where chained argument forwarding
- ** to calculate hash values. But in one case, we use the new \c std::hash
+ ** does not work as expected
- ** as a framework, in the other case we use the extension mechanism for
- ** \c boost::hash. The latter has the benefit of being simpler and less verbose
- ** to write, since a simple ADL function is sufficient as extension point
- ** 
- ** Now it would be desirable to bridge automatically between the two systems of
- ** defining hash functions. Unfortunately, the standard library since GCC 4.7
- ** contains a default implementation of std::hash to trigger a static assertion.
- ** Probably this was meant to educate people, but has the adverse side effect to
- ** prohibit any metaprogramming through SFINAE
- ** 
- ** This mistake was corrected somewhere in the 4.8.x series, but in the meantime
- ** we'll use the dirty trick proposed by "enobayram" to hijack and fix the problematic
- ** definition from the standard library.
- ** http://stackoverflow.com/questions/12753997/check-if-type-is-hashable
- ** 
- ** Moreover, in this exploration, we build an automatic bridge to invoke
- ** existing boost hash functions whenever a \c std::hash definition is required.
  **
  */
 
+#include "lib/test/test-helper.hpp"
+#include "lib/util.hpp"
+
 #include <cstddef>
-
+#include <utility>
-namespace lib {
-namespace meta {
-  
-  namespace {
-    struct NoUsableHashDefinition { size_t more_than_one[2]; };
-    typedef size_t HasUsableHashDefinition;
-    
-    NoUsableHashDefinition hash_value(...);
-    
-  }
-  
-  template<typename TY>
-  class provides_BoostHashFunction
-    {
-      TY const& unusedDummy = *(TY*)nullptr;
-      
-    public:
-      enum{ value = (sizeof(HasUsableHashDefinition) == sizeof(hash_value(unusedDummy))) };
-    };
-
-}}
-
-#include <boost/utility/enable_if.hpp>
-
-namespace std {
-  
-  template<typename Result, typename Arg>
-  struct __hash_base;
-  
-  
-  template<typename TY, typename TOGGLE = void>
-  struct _HashImplementationSelector
-    : public __hash_base<size_t, TY>
-    {
-      static_assert (sizeof(TY) < 0, "No hash implementation found. Either specialise std::hash or provide a boost-style hash_value via ADL.");
-      
-      typedef int NotHashable;
-    };
-  
-  template<typename TY>
-  struct _HashImplementationSelector<TY,   typename boost::enable_if< lib::meta::provides_BoostHashFunction<TY> >::type >
-    : public __hash_base<size_t, TY>
-    {
-      size_t
-      operator() (TY const& elm) const noexcept
-        {
-          return hash_value(elm);
-        }
-      
-    };
-  
-  /**
-   * Primary class template for std::hash.
-   * We provide no default implementation, but a marker type
-   * to allow detection of custom implementation through metaprogramming
-   */
-  template<typename TY>
-  struct hash
-    : public _HashImplementationSelector<TY>
-    { };
-  
-}
-
-
-
-#define hash hash_HIDDEN
-#define _Hash_impl _Hash_impl_HIDDEN
-#include <functional>
-#undef hash
-#undef _Hash_impl
-
-
-namespace std {
-  
-  struct _Hash_impl
-    : public std::_Hash_impl_HIDDEN
-    {
-      template<typename ... ARGS>
-      static auto
-      hash (ARGS&&... args) -> decltype(hash_HIDDEN (std::forward<ARGS>(args)...))
-        {
-          return hash_HIDDEN (std::forward<ARGS>(args)...);
-        }
-    };
-
-#define STD_HASH_IMPL(_TY_) \
-  template<> struct hash<_TY_> : public hash_HIDDEN<_TY_> { };
-
-  STD_HASH_IMPL (bool)
-  STD_HASH_IMPL (char)
-  STD_HASH_IMPL (signed char)
-  STD_HASH_IMPL (unsigned char)
-  STD_HASH_IMPL (wchar_t)
-  STD_HASH_IMPL (char16_t)
-  STD_HASH_IMPL (char32_t)
-  STD_HASH_IMPL (short)
-  STD_HASH_IMPL (int)
-  STD_HASH_IMPL (long)
-  STD_HASH_IMPL (long long)
-  STD_HASH_IMPL (unsigned short)
-  STD_HASH_IMPL (unsigned int)
-  STD_HASH_IMPL (unsigned long)
-  STD_HASH_IMPL (unsigned long long)
-  STD_HASH_IMPL (float)
-  STD_HASH_IMPL (double)
-  STD_HASH_IMPL (long double)
-  
-#undef STD_HASH_IMPL
-}
-
-
-
-
-
-#include <boost/functional/hash.hpp>
-
 #include <iostream>
+#include <functional>
 #include <string>
-#include <vector>
 
-using std::vector;
 using std::string;
 using std::cout;
 using std::endl;
 
-class S
+class Interface
+  {
+  public:
+    virtual ~Interface() { }
+    virtual string op()  const  =0;
+  };
+
+class Impl
+  : public Interface
   {
     string s_;
     
-    friend std::hash<S>;
+    string
+    op()  const override
+      {
+        return s_;
+      }
     
   public:
-    S(string ss ="")
+    Impl(string ss ="IMP")
       : s_(ss)
       { }
   };
 
-namespace std {
+template<typename X>
-  template<>
+void
-  struct hash<S>
+diagnostics (string id, const void* addr)
-    {
+{
-      size_t
+  cout << id << "\n"
-      operator() (S const& val)  const noexcept
+       << "invoked with.. " << lib::test::showType<X>()
-        {
+       << "\n Address ... " << addr
-          hash<string> string_hasher;
+       << "\n is lRef ... " << std::is_lvalue_reference<X>::value
-          return string_hasher(val.s_);
+       << "\n is rRef ... " << std::is_rvalue_reference<X>::value
-        }
+       << "\n"
-    };
+       ;
 }
 
-class V
-  {
-    vector<string> v_;
 
-  public:
+void
-    V(string ss ="")
+invoke (Interface const& ref)
-      {
+{
-        v_.push_back(ss);
+  using Ty = Interface const&;
-      }
+  diagnostics<Ty> ("Invoke", &ref);
+  cout << "instanceof Impl?" << bool(INSTANCEOF(Impl, &ref)) <<"\n";
+  cout <<  ref.op();
+}
 
-    friend size_t
+template<class FUN, typename A>
-    hash_value (V const& v)
+void
-    {
+indirect_1 (FUN fun, A&& a)
-      return boost::hash_value(v.v_);
+{
-    }
+  diagnostics<A> ("Indirect-1", &a);
-  };
+  fun (std::forward<A> (a));
+}
+
+template<class FUN, typename A>
+void
+indirect_2 (FUN fun, A&& a)
+{
+  diagnostics<A> ("Indirect-2", &a);
+  indirect_1 (fun, std::forward<A> (a));
+}
 
 
 int
 main (int, char**)
   {
-    string p("Путин"), pp(p);
+    Impl obj;
-    S s(p), ss(pp);
+    Interface const& ref = obj;
-    V v(p), vv(pp);
     
-    std::hash<string>   std_stringHasher;
+    cout << "before call. Address... "<<&ref<<"\n";
-    boost::hash<string> boo_stringHasher;
     
-    std::hash<S>   std_customHasher;
+    std::function<void(Interface const&)> fun(invoke);
-    boost::hash<V> boo_customHasher;
     
-    std::hash<V>   boo2std_crossHar;
+    indirect_2 (fun, ref);
-    
+    indirect_2 (fun, Impl("honk"));
-    cout << "raw hash(std) =      "   << std_stringHasher(p) <<"|"<< std_stringHasher(pp)
-         << "\n      (boost) =      " << boo_stringHasher(p) <<"|"<< boo_stringHasher(pp)
-         << "\n custom hash (std)   " << std_customHasher(s) <<"|"<< std_customHasher(ss)
-         << "\n custom hash (boost) " << boo_customHasher(v) <<"|"<< boo_customHasher(vv)
-         << "\n has_boost_hash<S>   " << lib::meta::provides_BoostHashFunction<S>::value
-         << "\n has_boost_hash<V>   " << lib::meta::provides_BoostHashFunction<V>::value
-         << "\n use boost from std: " << boo2std_crossHar(v) <<"|"<< boo2std_crossHar(vv)
-         ;
-    
-//  Note: does not compile,
-//          since there is not automatic bridge from std to boost hash
-//  
-//  boost::hash<S>()(s);
     
     cout <<  "\n.gulp.\n";