Fix return value type deduction for nonstd::visit #28 (#29)

martinmoene · Nov 6, 2018 · 0efbca4 · 0efbca4
1 parent d33e5cd
commit 0efbca4
Show file tree

Hide file tree

Showing 3 changed files with 82 additions and 3 deletions.
diff --git a/include/nonstd/variant.hpp b/include/nonstd/variant.hpp
@@ -1924,7 +1924,7 @@ struct VisitorApplicator
 template< size_t NumVars, typename Visitor, typename ... V >
 struct VisitorImpl
 {
-    typedef decltype(std::declval<Visitor>()(get<0>(std::declval<V>())...)) result_type;
+    typedef decltype(std::declval<Visitor>()(get<0>(static_cast<const V&>(std::declval<V>()))...)) result_type;
     typedef VisitorApplicator<result_type> applicator_type;
 };
 #endif
@@ -2125,4 +2125,4 @@ struct hash< nonstd::variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T
 
 #endif // variant_USES_STD_VARIANT
 
-#endif // NONSTD_VARIANT_LITE_HPP
+#endif // NONSTD_VARIANT_LITE_HPP
diff --git a/template/variant.hpp b/template/variant.hpp
@@ -1598,7 +1598,7 @@ struct VisitorApplicator
 template< size_t NumVars, typename Visitor, typename ... V >
 struct VisitorImpl
 {
-    typedef decltype(std::declval<Visitor>()(get<0>(std::declval<V>())...)) result_type;
+    typedef decltype(std::declval<Visitor>()(get<0>(static_cast<const V&>(std::declval<V>()))...)) result_type;
     typedef VisitorApplicator<result_type> applicator_type;
 };
 #endif

diff --git a/test/variant.t.cpp b/test/variant.t.cpp
@@ -7,6 +7,8 @@
 
 #include "variant-main.t.hpp"
 
+#include <memory>
+
 namespace {
 
 // ensure comparison of pointers for lest:
@@ -1007,6 +1009,83 @@ CASE( "variant: Allows to check for content by type" )
 #endif
 }
 
+#if variant_CPP14_OR_GREATER
+struct RVRefTestVisitor
+{
+    std::string operator()(int val) const
+    {
+        std::ostringstream os;
+        os << val;
+        return os.str();
+    }
+    std::string operator()(const std::string& val) const
+    {
+        std::ostringstream os;
+        os << val;
+        return os.str();
+    }
+
+	template<typename ... Args>
+	std::string operator()(const variant<Args...>& var) const
+	{
+		return visit(RVRefTestVisitor(), var);
+	}
+
+	template<typename U>
+	std::string operator()(U&&) const
+	{
+	    static_assert(std::is_const<U>::value, "Wrong branch!");
+		return ">>> Broken branch! <<<";
+	}
+};
+
+struct Unwrapper
+{
+    RVRefTestVisitor* m_v;
+
+    Unwrapper(RVRefTestVisitor* v)
+        : m_v(v)
+    {}
+
+    template<typename T>
+    auto& Unwrap(T&& val) const
+    {
+        return std::forward<T>(val);
+    }
+
+    template<typename T>
+    const auto& Unwrap(std::shared_ptr<T> val) const
+    {
+        const auto& result = *val.get();
+        return result;
+    }
+
+    template<typename ... Args>
+    auto operator()(Args&& ... args) const
+    {
+        return (*m_v)(Unwrap(std::forward<Args>(args))...);
+    }
+
+};
+
+CASE( "variant: Allows to visit contents (args: 1)" )
+{
+	typedef std::shared_ptr<std::string> string_ptr_t;
+    typedef variant< int, std::string, string_ptr_t > var_t;
+    string_ptr_t inner = std::make_shared<std::string>("hello1");
+
+    var_t vstr1 = inner;
+    var_t vstr2 = std::string("hello2");
+    RVRefTestVisitor visitor;
+
+    std::string rs1 = visit(Unwrapper(&visitor), vstr1);
+    std::string rs2 = visit(Unwrapper(&visitor), vstr2);
+
+    EXPECT( rs1 == "hello1" );
+    EXPECT( rs2 == "hello2" );
+}
+#endif
+
 CASE( "variant: Allows to get element by type" )
 {
     variant<int, S> var( S( 7 ) );