Add support for BOOST_SYSTEM_DISABLE_THREADS (refs #92)

.github/workflows/ci.yml

@@ -110,7 +110,7 @@ jobs:
             install: clang-14
           - toolset: clang
             cxxstd: "03,11,14,17,2a"
-            os: macos-10.15
+            os: macos-11
 
     runs-on: ${{matrix.os}}
 
@@ -220,7 +220,7 @@ jobs:
           - os: ubuntu-18.04
           - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-10.15
+          - os: macos-11
 
     runs-on: ${{matrix.os}}
 
@@ -267,7 +267,7 @@ jobs:
           - os: ubuntu-18.04
           - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-10.15
+          - os: macos-11
 
     runs-on: ${{matrix.os}}
 
@@ -324,7 +324,7 @@ jobs:
           - os: ubuntu-18.04
           - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-10.15
+          - os: macos-11
 
     runs-on: ${{matrix.os}}
 

README.md

@@ -0,0 +1,25 @@
+# Boost.System
+
+The Boost.System library, part of [Boost C++ Libraries](https://boost.org),
+implements an extensible framework for error reporting in the form of an
+`error_code` class and supporting facilities.
+
+It has been proposed for the C++11 standard, has been accepted, and
+is now available as part of the standard library in the `<system_error>`
+header. However, the Boost implementation has continued to evolve and
+gain enhancements and additional functionality, such as support for
+attaching [source locations](https://www.boost.org/doc/libs/release/libs/assert/doc/html/assert.html#source_location_support)
+to `error_code`, and a `result<T>` class that can carry either a value
+or an error code.
+
+See [the documentation of System](http://boost.org/libs/system) for more
+information.
+
+Since `<system_error>` is a relatively undocumented portion of the C++
+standard library, the documentation of Boost.System may be useful to you
+even if you use the standard components.
+
+## License
+
+Distributed under the
+[Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).

doc/system/changes.adoc

@@ -16,6 +16,7 @@ https://www.boost.org/LICENSE_1_0.txt
   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`.
+* Added a converting constructor to `result`.
 
 ## Changes in Boost 1.79
 

doc/system/reference.adoc

@@ -1608,6 +1608,12 @@ public:
     template<class... A>
       constexpr result( in_place_error_t, A&&... a );
 
+    template<class T2, class E2>
+      constexpr result( result<T2, E2> const& r2 );
+
+    template<class T2, class E2>
+      constexpr result( result<T2, E2>&& r2 );
+
     // queries
 
     constexpr bool has_value() const noexcept;
@@ -1716,6 +1722,30 @@ Ensures: ::
 Remarks: ::
   This constructor is only enabled when `std::is_constructible<E, A...>::value` is `true`.
 
+```
+template<class T2, class E2>
+  constexpr result( result<T2, E2> const& r2 );
+```
+[none]
+* {blank}
++
+Ensures: ::
+  If `r2.has_value()` is `true`, `*this` holds the value `T( *r2 )`, otherwise `*this` holds the value `E( r2.error() )`.
+Remarks: ::
+  This constructor is only enabled when `std::is_convertible<T2, T>::value && std::is_convertible<E2, E>::value` is `true`.
+
+```
+template<class T2, class E2>
+  constexpr result( result<T2, E2>&& r2 );
+```
+[none]
+* {blank}
++
+Ensures: ::
+  If `r2.has_value()` is `true`, `*this` holds the value `T( std::move( *r2 ) )`, otherwise `*this` holds the value `E( r2.error() )`.
+Remarks: ::
+  This constructor is only enabled when `std::is_convertible<T2, T>::value && std::is_convertible<E2, E>::value` is `true`.
+
 #### Queries
 
 ```

include/boost/system/detail/config.hpp

@@ -12,8 +12,14 @@
 #include <boost/config/workaround.hpp>
 
 // BOOST_SYSTEM_HAS_SYSTEM_ERROR
+//
+// The macro BOOST_SYSTEM_DISABLE_THREADS can be defined on configurations
+// that provide <system_error> and <atomic>, but not <mutex>, such as the
+// single-threaded libstdc++.
+//
+// https://github.com/boostorg/system/issues/92
 
-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_CXX11_HDR_ATOMIC) && !defined(BOOST_NO_CXX11_HDR_MUTEX)
+#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_CXX11_HDR_ATOMIC) && ( !defined(BOOST_NO_CXX11_HDR_MUTEX) || defined(BOOST_SYSTEM_DISABLE_THREADS) )
 # define BOOST_SYSTEM_HAS_SYSTEM_ERROR
 #endif
 

include/boost/system/detail/error_category_impl.hpp

@@ -98,14 +98,19 @@ inline char const * error_category::message( int ev, char * buffer, std::size_t
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
 #include <boost/system/detail/std_category_impl.hpp>
-#include <mutex>
 #include <new>
 
+#if !defined(BOOST_SYSTEM_DISABLE_THREADS)
+# include <mutex>
+#endif
+
 namespace boost
 {
 namespace system
 {
 
+#if !defined(BOOST_SYSTEM_DISABLE_THREADS)
+
 namespace detail
 {
 
@@ -118,6 +123,8 @@ template<class T> std::mutex stdcat_mx_holder<T>::mx_;
 
 } // namespace detail
 
+#endif
+
 inline void error_category::init_stdcat() const
 {
     static_assert( sizeof( stdcat_ ) >= sizeof( boost::system::detail::std_category ), "sizeof(stdcat_) is not enough for std_category" );
@@ -130,7 +137,9 @@ inline void error_category::init_stdcat() const
 
 #endif
 
+#if !defined(BOOST_SYSTEM_DISABLE_THREADS)
     std::lock_guard<std::mutex> lk( boost::system::detail::stdcat_mx_holder<>::mx_ );
+#endif
 
     if( sc_init_.load( std::memory_order_acquire ) == 0 )
     {

include/boost/system/detail/error_code.hpp

@@ -29,6 +29,7 @@
 #include <boost/assert/source_location.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
 #include <ostream>
 #include <new>
 #include <cstdio>
@@ -57,12 +58,14 @@ namespace system
 //  and error_code containing a pointer to an object of a type derived
 //  from error_category.
 
+bool operator==( const error_code & code, const error_condition & condition ) BOOST_NOEXCEPT;
 std::size_t hash_value( error_code const & ec );
 
 class error_code
 {
 private:
 
+    friend bool operator==( const error_code & code, const error_condition & condition ) BOOST_NOEXCEPT;
     friend std::size_t hash_value( error_code const & ec );
 
 private:
@@ -114,7 +117,10 @@ public:
 
     // constructors:
 
-    BOOST_SYSTEM_CONSTEXPR error_code() BOOST_NOEXCEPT:
+#if !BOOST_WORKAROUND(BOOST_GCC, < 40800)
+    BOOST_CONSTEXPR
+#endif
+    error_code() BOOST_NOEXCEPT:
         d1_(), lc_flags_( 0 )
     {
     }
@@ -434,48 +440,6 @@ public:
         return !( lhs == rhs );
     }
 
-    inline friend bool operator==( const error_code & code, const error_condition & condition ) BOOST_NOEXCEPT
-    {
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-        if( code.lc_flags_ == 1 )
-        {
-            return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
-        }
-        else
-
-#endif
-        {
-            return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
-        }
-    }
-
-    inline friend bool operator==( const error_condition & condition, const error_code & code ) BOOST_NOEXCEPT
-    {
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-        if( code.lc_flags_ == 1 )
-        {
-            return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
-        }
-        else
-
-#endif
-        {
-            return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
-        }
-    }
-
-    inline friend bool operator!=( const error_code & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
-    {
-        return !( lhs == rhs );
-    }
-
-    inline friend bool operator!=( const error_condition & lhs, const error_code & rhs ) BOOST_NOEXCEPT
-    {
-        return !( lhs == rhs );
-    }
-
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
     inline friend bool operator==( std::error_code const & lhs, error_code const & rhs ) BOOST_NOEXCEPT
@@ -678,6 +642,37 @@ public:
     }
 };
 
+inline bool operator==( const error_code & code, const error_condition & condition ) BOOST_NOEXCEPT
+{
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+    if( code.lc_flags_ == 1 )
+    {
+        return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
+    }
+    else
+
+#endif
+    {
+        return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
+    }
+}
+
+inline bool operator==( const error_condition & condition, const error_code & code ) BOOST_NOEXCEPT
+{
+    return code == condition;
+}
+
+inline bool operator!=( const error_code & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
+{
+    return !( lhs == rhs );
+}
+
+inline bool operator!=( const error_condition & lhs, const error_code & rhs ) BOOST_NOEXCEPT
+{
+    return !( lhs == rhs );
+}
+
 inline std::size_t hash_value( error_code const & ec )
 {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)

include/boost/system/detail/error_condition.hpp

@@ -261,6 +261,58 @@ public:
         return !( lhs == rhs );
     }
 
+    //
+
+    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( error_condition const & lhs, E rhs ) BOOST_NOEXCEPT
+    {
+        return lhs == make_error_condition( rhs );
+    }
+
+    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( E lhs, error_condition const & rhs ) BOOST_NOEXCEPT
+    {
+        return make_error_condition( lhs ) == rhs;
+    }
+
+    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( error_condition const & lhs, E rhs ) BOOST_NOEXCEPT
+    {
+        return !( lhs == rhs );
+    }
+
+    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
+    BOOST_SYSTEM_CONSTEXPR inline friend bool operator!=( E lhs, error_condition const & rhs ) BOOST_NOEXCEPT
+    {
+        return !( lhs == rhs );
+    }
+
+    //
+
+    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
+    inline friend bool operator==( error_condition const & lhs, E rhs ) BOOST_NOEXCEPT
+    {
+        return lhs == make_error_code( rhs );
+    }
+
+    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
+    inline friend bool operator==( E lhs, error_condition const & rhs ) BOOST_NOEXCEPT
+    {
+        return make_error_code( lhs ) == rhs;
+    }
+
+    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
+    inline friend bool operator!=( error_condition const & lhs, E rhs ) BOOST_NOEXCEPT
+    {
+        return !( lhs == rhs );
+    }
+
+    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
+    inline friend bool operator!=( E lhs, error_condition const & rhs ) BOOST_NOEXCEPT
+    {
+        return !( lhs == rhs );
+    }
+
 #endif
 
     std::string to_string() const

include/boost/system/result.hpp

@@ -135,7 +135,8 @@ public:
     template<class... A, class En = typename std::enable_if<
         std::is_constructible<T, A...>::value &&
         !(detail::is_errc_t<A...>::value && std::is_arithmetic<T>::value) &&
-        !std::is_constructible<E, A...>::value
+        !std::is_constructible<E, A...>::value &&
+        sizeof...(A) >= 1
         >::type>
     explicit constexpr result( A&&... a )
         noexcept( std::is_nothrow_constructible<T, A...>::value )
@@ -146,7 +147,8 @@ public:
     // explicit, error
     template<class... A, class En2 = void, class En = typename std::enable_if<
         !std::is_constructible<T, A...>::value &&
-        std::is_constructible<E, A...>::value
+        std::is_constructible<E, A...>::value &&
+        sizeof...(A) >= 1
         >::type>
     explicit constexpr result( A&&... a )
         noexcept( std::is_nothrow_constructible<E, A...>::value )
@@ -220,7 +222,7 @@ public:
 
     constexpr bool has_error() const noexcept
     {
-        return v_.index() != 0;
+        return v_.index() == 1;
     }
 
     constexpr explicit operator bool() const noexcept
@@ -509,7 +511,7 @@ public:
 
     constexpr bool has_error() const noexcept
     {
-        return v_.index() != 0;
+        return v_.index() == 1;
     }
 
     constexpr explicit operator bool() const noexcept

test/CMakeLists.txt

@@ -15,6 +15,7 @@ macro(system_run s1)
   boost_test(SOURCES ${s1} ${ARGN})
   boost_test(SOURCES ${s1} ${ARGN} COMPILE_DEFINITIONS BOOST_NO_ANSI_APIS NAME ${n1}_no_ansi)
   boost_test(SOURCES ${s1} ${ARGN} COMPILE_DEFINITIONS BOOST_SYSTEM_USE_UTF8 NAME ${n1}_utf8)
+  boost_test(SOURCES ${s1} ${ARGN} COMPILE_DEFINITIONS BOOST_SYSTEM_DISABLE_THREADS NAME ${n1}_nthr)
 
 endmacro()
 
@@ -124,6 +125,11 @@ boost_test(TYPE run SOURCES std_interop_test14.cpp)
 boost_test(TYPE run SOURCES ec_location_test3.cpp)
 boost_test(TYPE run SOURCES ec_location_test4.cpp)
 
+boost_test(TYPE compile SOURCES constexpr_test2.cpp)
+
+boost_test(TYPE run SOURCES error_code_test3.cpp)
+boost_test(TYPE run SOURCES std_interop_test15.cpp)
+
 # result
 
 set(BOOST_TEST_COMPILE_FEATURES cxx_std_11)

test/Jamfile.v2

@@ -33,6 +33,7 @@ rule system-run ( sources + )
     result += [ run $(sources) : : : <library>/boost/system//boost_system <link>shared : $(sources[1]:B)_shared ] ;
     result += [ run $(sources) : : : <define>BOOST_NO_ANSI_APIS : $(sources[1]:B)_no_ansi ] ;
     result += [ run $(sources) : : : <define>BOOST_SYSTEM_USE_UTF8 : $(sources[1]:B)_utf8 ] ;
+    result += [ run $(sources) : : : <define>BOOST_SYSTEM_DISABLE_THREADS : $(sources[1]:B)_nthr ] ;
 
     return $(result) ;
 }
@@ -152,6 +153,11 @@ run std_interop_test14.cpp ;
 run ec_location_test3.cpp ;
 run ec_location_test4.cpp ;
 
+compile constexpr_test2.cpp ;
+
+run error_code_test3.cpp ;
+run std_interop_test15.cpp ;
+
 # result
 
 import ../../config/checks/config : requires ;

test/constexpr_test2.cpp

@@ -0,0 +1,26 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_GCC) && BOOST_GCC >= 40700 && BOOST_GCC < 40800
+
+BOOST_PRAGMA_MESSAGE("Skipping test, BOOST_GCC is 407xx")
+
+#else
+
+struct X
+{
+    boost::system::error_code ec;
+};
+
+X const& f()
+{
+    BOOST_STATIC_CONSTEXPR X x;
+    return x;
+}
+
+#endif

test/error_code_test3.cpp

@@ -0,0 +1,69 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/system/error_condition.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+namespace sys = boost::system;
+
+enum my_errc
+{
+    enomem_c = ENOMEM
+};
+
+enum my_errn
+{
+    enomem_n = ENOMEM
+};
+
+namespace boost {
+namespace system {
+
+template<> struct is_error_code_enum<my_errc>
+{
+    static const bool value = true;
+};
+
+template<> struct is_error_condition_enum<my_errn>
+{
+    static const bool value = true;
+};
+
+} // namespace system
+} // namespace boost
+
+sys::error_code make_error_code( my_errc e )
+{
+    return sys::error_code( e, sys::generic_category() );
+}
+
+sys::error_condition make_error_condition( my_errn e )
+{
+    return sys::error_condition( e, sys::generic_category() );
+}
+
+int main()
+{
+    sys::error_code ec = make_error_code( sys::errc::not_enough_memory );
+    sys::error_condition en( sys::errc::not_enough_memory );
+
+    BOOST_TEST_EQ( ec, en );
+    BOOST_TEST_EQ( en, ec );
+
+    BOOST_TEST_EQ( ec, enomem_c );
+    BOOST_TEST_EQ( enomem_c, ec );
+
+    BOOST_TEST_EQ( ec, enomem_n );
+    BOOST_TEST_EQ( enomem_n, ec );
+
+    BOOST_TEST_EQ( en, enomem_c );
+    BOOST_TEST_EQ( enomem_c, en );
+
+    BOOST_TEST_EQ( en, enomem_n );
+    BOOST_TEST_EQ( enomem_n, en );
+
+    return boost::report_errors();
+}

test/result_default_construct.cpp

@@ -12,6 +12,11 @@ struct X
 {
 };
 
+struct Y
+{
+    Y( int );
+};
+
 int main()
 {
     {
@@ -37,5 +42,17 @@ int main()
         BOOST_TEST( !r.has_error() );
     }
 
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<result<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<result<int, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<result<X>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<result<X, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<result<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<result<void, int>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<Y>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<result<Y, int>>));
+    }
+
     return boost::report_errors();
 }

test/std_interop_test15.cpp

@@ -0,0 +1,94 @@
+// Copyright 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/system/error_condition.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+
+#if !defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+BOOST_PRAGMA_MESSAGE( "BOOST_SYSTEM_HAS_SYSTEM_ERROR not defined, test will be skipped" )
+int main() {}
+
+#elif defined(BOOST_SYSTEM_AVOID_STD_GENERIC_CATEGORY)
+
+BOOST_PRAGMA_MESSAGE( "Skipping test, BOOST_SYSTEM_AVOID_STD_GENERIC_CATEGORY is defined" )
+int main() {}
+
+#else
+
+#include <system_error>
+
+namespace sys = boost::system;
+
+enum my_errc
+{
+    enomem_c = ENOMEM
+};
+
+enum my_errn
+{
+    enomem_n = ENOMEM
+};
+
+namespace std {
+
+template<> struct is_error_code_enum<my_errc>
+{
+    static const bool value = true;
+};
+
+template<> struct is_error_condition_enum<my_errn>
+{
+    static const bool value = true;
+};
+
+} // namespace std
+
+std::error_code make_error_code( my_errc e )
+{
+    return std::error_code( e, std::generic_category() );
+}
+
+std::error_condition make_error_condition( my_errn e )
+{
+    return std::error_condition( e, std::generic_category() );
+}
+
+int main()
+{
+    sys::error_code ec = make_error_code( sys::errc::not_enough_memory );
+    sys::error_condition en( sys::errc::not_enough_memory );
+
+    BOOST_TEST_EQ( ec, en );
+    BOOST_TEST_EQ( en, ec );
+
+    BOOST_TEST_EQ( ec, enomem_c );
+    BOOST_TEST_EQ( enomem_c, ec );
+
+    BOOST_TEST_EQ( ec, enomem_n );
+    BOOST_TEST_EQ( enomem_n, ec );
+
+    BOOST_TEST_EQ( en, enomem_c );
+    BOOST_TEST_EQ( enomem_c, en );
+
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1800)
+
+    // msvc-12.0 has op== as a member of std::error_condition
+
+#else
+
+    BOOST_TEST_EQ( en, enomem_n );
+
+#endif
+
+    BOOST_TEST_EQ( enomem_n, en );
+
+    return boost::report_errors();
+}
+
+#endif