Add converting constructor to result (refs #82)

doc/system/changes.adoc

@@ -14,6 +14,8 @@ https://www.boost.org/LICENSE_1_0.txt
   to `error_code`, the original is now restored, if possible.
 * Reworked the conversion from `error_category` to `std::error_category`
   to avoid the one-time allocation that shows up on leak checkers.
+* Added a constructor that allows replacing the source location of an
+  `error_code`, and a corresponding `assign`.
 
 ## Changes in Boost 1.79
 

doc/system/reference.adoc

@@ -610,9 +610,8 @@ public:
     template<class ErrorCodeEnum>
       constexpr error_code( ErrorCodeEnum e ) noexcept;
 
-    template<class ErrorCodeEnum>
-      error_code( ErrorCodeEnum e, boost::source_location const * loc )
-        noexcept;
+    error_code( error_code const& ec,
+      boost::source_location const * loc ) noexcept;
 
     error_code( std::error_code const& ec ) noexcept;
 
@@ -626,9 +625,8 @@ public:
     template<class ErrorCodeEnum>
       constexpr error_code & operator=( ErrorCodeEnum e ) noexcept;
 
-    template<class ErrorCodeEnum>
-      void assign( ErrorCodeEnum e,
-        boost::source_location const * loc ) noexcept;
+    void assign( error_code const& ec,
+      boost::source_location const * loc ) noexcept;
 
     constexpr void clear() noexcept;
 
@@ -757,17 +755,17 @@ Ensures: :: `*this == make_error_code( e )`.
 Remarks: :: This constructor is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.
 
 ```
-template<class ErrorCodeEnum>
-  error_code( ErrorCodeEnum e, boost::source_location const * loc ) noexcept;
+error_code( error_code const& ec,
+  boost::source_location const * loc ) noexcept;
 ```
 [none]
 * {blank}
 +
-Requires: :: `loc` points to a valid `boost::source_location` object with static storage duration.
-Ensures: :: `*this == make_error_code( e )`.
-Remarks: :: This constructor is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.
-  When `make_error_code( e )` is not a default-constructed `error_code` and doesn't wrap a
-  `std::error_code`, `has_location()` is `true` and `&location()` is `loc`.
+Requires: :: `loc` points to a valid `boost::source_location` object with static storage duration, or is `nullptr`.
+Ensures: :: `*this == ec`.
+Remarks: :: When `ec` is a default-constructed `error_code` or wraps a `std::error_code`,
+  or when `loc` is `nullptr`, `*this` stores no location (`has_location()` is `false`).
+  Otherwise, `*this` stores `loc` (`has_location()` is `true` and `&location()` is `loc`.)
 
 ```
 error_code( std::error_code const & ec ) noexcept;
@@ -808,16 +806,13 @@ Ensures: :: `*this == make_error_code( e )`.
 Remarks: :: This operator is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.
 
 ```
-template<class ErrorCodeEnum>
-  void assign( ErrorCodeEnum e,
-    boost::source_location const * loc ) noexcept;
+void assign( error_code const& ec,
+  boost::source_location const * loc ) noexcept;
 ```
 [none]
 * {blank}
 +
-Requires: :: `loc` points to a valid `boost::source_location` object with static storage duration.
-Effects: :: `*this = error_code( e, loc )`.
-Remarks: :: This function is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.
+Effects: :: `*this = error_code( ec, loc )`.
 
 ```
 constexpr void clear() noexcept;

include/boost/system/result.hpp

@@ -174,6 +174,43 @@ public:
     {
     }
 
+    // converting
+    template<class T2, class E2, class En = typename std::enable_if<
+        std::is_convertible<T2, T>::value &&
+        std::is_convertible<E2, E>::value
+        >::type>
+    BOOST_CXX14_CONSTEXPR result( result<T2, E2> const& r2 )
+        noexcept(
+            std::is_nothrow_constructible<T, T2 const&>::value &&
+            std::is_nothrow_constructible<E, E2>::value &&
+            std::is_nothrow_default_constructible<E2>::value &&
+            std::is_nothrow_copy_constructible<E2>::value )
+        : v_( in_place_error, r2.error() )
+    {
+        if( r2 )
+        {
+            v_.template emplace<0>( *r2 );
+        }
+    }
+
+    template<class T2, class E2, class En = typename std::enable_if<
+        std::is_convertible<T2, T>::value &&
+        std::is_convertible<E2, E>::value
+        >::type>
+    BOOST_CXX14_CONSTEXPR result( result<T2, E2>&& r2 )
+        noexcept(
+            std::is_nothrow_constructible<T, T2&&>::value &&
+            std::is_nothrow_constructible<E, E2>::value &&
+            std::is_nothrow_default_constructible<E2>::value &&
+            std::is_nothrow_copy_constructible<E2>::value )
+        : v_( in_place_error, r2.error() )
+    {
+        if( r2 )
+        {
+            v_.template emplace<0>( std::move( *r2 ) );
+        }
+    }
+
     // queries
 
     constexpr bool has_value() const noexcept

test/CMakeLists.txt

@@ -142,3 +142,4 @@ boost_test(TYPE run SOURCES result_eq.cpp)
 boost_test(TYPE run SOURCES result_range_for.cpp)
 boost_test(TYPE run SOURCES result_value_construct2.cpp)
 boost_test(TYPE run SOURCES result_error_construct2.cpp)
+boost_test(TYPE run SOURCES result_convert_construct.cpp)

test/Jamfile.v2

@@ -169,3 +169,4 @@ run result_range_for.cpp : : : $(CPP11) ;
 run result_value_construct2.cpp : : : $(CPP11) ;
 run result_error_construct2.cpp : : : $(CPP11) ;
 run result_errc_construct.cpp : : : $(CPP11) ;
+run result_convert_construct.cpp : : : $(CPP11) ;

test/result_convert_construct.cpp

@@ -0,0 +1,202 @@
+// Copyright 2017, 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+using namespace boost::system;
+
+struct X
+{
+    static int instances;
+
+    int v_;
+
+    X(): v_() { ++instances; }
+
+    X( int v ): v_( v ) { ++instances; }
+
+    X( X const& r ): v_( r.v_ ) { ++instances; }
+
+    X& operator=( X const& ) = delete;
+
+    ~X() { --instances; }
+};
+
+bool operator==( X const & x1, X const & x2 )
+{
+    return x1.v_ == x2.v_;
+}
+
+std::ostream& operator<<( std::ostream& os, X const & x )
+{
+    os << "X:" << x.v_;
+    return os;
+}
+
+int X::instances = 0;
+
+int main()
+{
+    {
+        result<int> r( 5 );
+        result<long> r2 = r;
+
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 5 );
+    }
+
+    {
+        result<int> const r( 6 );
+        result<long> r2 = r;
+
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 6 );
+    }
+
+    {
+        result<long> r2 = result<int>( 7 );
+
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 7 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<int> r( 5 );
+        result<X> r2 = r;
+
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 5 );
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<int> const r( 6 );
+        result<X> r2 = r;
+
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 6 );
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r2 = result<int>( 7 );
+
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, 7 );
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> r( ec );
+        result<long> r2 = r;
+
+        BOOST_TEST( !r2 );
+        BOOST_TEST_EQ( r2.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<int> r( ec );
+        result<long> r2 = r;
+
+        BOOST_TEST( !r2 );
+        BOOST_TEST_EQ( r2.error(), ec );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<long> r2 = result<int>( ec );
+
+        BOOST_TEST( !r2 );
+        BOOST_TEST_EQ( r2.error(), ec );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<char const*, int> r( "test" );
+        result<std::string, X> r2 = r;
+
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, std::string( "test" ) );
+        BOOST_TEST_EQ( X::instances, 0 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<char const*, int> const r( "test" );
+        result<std::string, X> r2 = r;
+
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, std::string( "test" ) );
+        BOOST_TEST_EQ( X::instances, 0 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<std::string, X> r2 = result<char const*, int>( "test" );
+
+        BOOST_TEST( r2 ) && BOOST_TEST_EQ( *r2, std::string( "test" ) );
+        BOOST_TEST_EQ( X::instances, 0 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<char const*, int> r( 5 );
+        result<std::string, X> r2 = r;
+
+        BOOST_TEST( !r2 );
+        BOOST_TEST_EQ( r2.error(), X(5) );
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<char const*, int> const r( 6 );
+        result<std::string, X> r2 = r;
+
+        BOOST_TEST( !r2 );
+        BOOST_TEST_EQ( r2.error(), X(6) );
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    {
+        result<std::string, X> r2 = result<char const*, int>( 7 );
+
+        BOOST_TEST( !r2 );
+        BOOST_TEST_EQ( r2.error(), X(7) );
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<long>, result<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_convertible<result<int>, result<long>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int>, result<void*>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<void*>, result<int>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int>, result<void>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<void>, result<int>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<void>, result<int>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<int>, result<void>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int, void*>, result<int, int>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_convertible<result<int, int>, result<int, void*>>));
+    }
+
+    return boost::report_errors();
+}