Merge branch 'fix_error_code_wostream' of https://github.com/MarcelRaad/system into feature/pr-76

This fixes a regression from commit
a9b64a888a.
Calling `operator<<` with `std::string` only works for `std::ostream`.
Use `c_str()` to restore the previous behavior of using `const char*`,
which works for any `basic_ostream` specialization.

.github/workflows/ci.yml

@@ -144,6 +144,10 @@ jobs:
       fail-fast: false
       matrix:
         include:
+          - toolset: msvc-14.0
+            cxxstd: "14"
+            addrmd: 32,64
+            os: windows-2019
           - toolset: msvc-14.1
             cxxstd: "14,17,latest"
             addrmd: 32,64

doc/system.adoc

@@ -19,6 +19,7 @@ Beman Dawes, Christopher Kohlhoff, Peter Dimov
 :leveloffset: +1
 
 include::system/introduction.adoc[]
+include::system/usage.adoc[]
 include::system/changes.adoc[]
 include::system/rationale.adoc[]
 include::system/reference.adoc[]

doc/system/introduction.adoc

@@ -1,6 +1,6 @@
 ////
 Copyright 2003-2017 Beman Dawes
-Copyright 2018 Peter Dimov
+Copyright 2018, 2021 Peter Dimov
 
 Distributed under the Boost Software License, Version 1.0.
 
@@ -12,39 +12,67 @@ http://www.boost.org/LICENSE_1_0.txt
 # Introduction
 :idprefix: intro_
 
-Error conditions originating from the operating system or other low-level
-application program interfaces (API's) are typically reported via an integer
-representing an error code. When these low-level API calls are wrapped in
-portable code, such as in a portable library, some users want to deal with the
-error codes in portable ways. Other users need to get at the system specific
-error codes, so they can deal with system specific needs. The Boost System
-library provides simple, light-weight `error_code` objects that encapsulate
-system-specific error code values, yet also provide access to more abstract
-and portable error conditions via `error_condition` objects.
+Errors originating from the operating system or other low-level application
+program interfaces (APIs) are typically reported via an integer representing
+an error code, either by returning the code directly from the function (e.g.
+`pthread_mutex_init`) or by using a side channel such as the `errno`
+pseudo-variable under POSIX or `GetLastError()` under Windows.
 
-Because `error_code` objects can represent errors from sources other than the
-operating system, including user-defined sources, each `error_code` and
-`error_condition` has an associated `error_category`.
+However, these integer error values can only be interpreted when their source
+is known. The value 5 under Windows means `ERROR_ACCESS_DENIED` when returned
+by `GetLastError()`, but `EIO` when retrieved from `errno`. And conversely,
+the same error condition "access denied" is represented by the value 5 when
+returned by `GetLastError()` and 13 (`EACCES`) when retrieved from `errno`.
 
-An exception class, `system_error`, is provided. Derived from
-`std::runtime_error`, it captures the underlying `error_code` for the problem
-causing the exception so that this important information is not lost.
+This means that in order for code to be able to handle errors from both
+sources (to retrieve a text message describing the error, or to check whether
+the error means "access denied"), it needs to know where the integer error
+value originated. For this to be possible, the integer error value needs to
+be accompanied by a piece of information identifying the source.
 
-While exceptions are the preferred {cpp} default error code reporting
-mechanism, users of libraries dependent on low-level API's often need overloads
-reporting error conditions via error code arguments and/or return values rather
-than via throwing exceptions. Otherwise, when errors are not exceptional
-occurrences and must be dealt with as they arise, programs become littered with
-try/catch blocks, unreadable, and inefficient. The Boost System library
-supports both error reporting by exception and by error code.
+Boost.System provides a framework in which this is possible. Errors are
+represented by a class `error_code` which contains both the error value and
+a pointer to their source (called "category"), represented as a class derived
+from `error_category`.
 
-In addition to portable errors codes and conditions supported by the
-`error_code.hpp` header, system-specific headers support the Cygwin, Linux,
-and Windows platforms. These headers are effectively no-ops if included for
-platforms other than their intended target.
+The category provides member functions such as `message`, which returns a text
+message for a specific error value, and `equivalent`, which can be used to test
+whether a specific error value correspond to an error condition such as "access
+denied". `error_code` uses these category-provided functions in the
+implementation of its `message` and `operator==` member functions.
 
-Boost.System is part of the {cpp}11 Standard Library.
-A number of changes, particularly to names, were made by the C++ committee
-during standardization. The Boost implementation has been tracking those changes.
-See <<#ref_deprecated_names,Deprecated Names>> for synonyms provided to prevent
-breakage of existing user code.
+Boost.System contains two predefined category classes, the generic category
+(a reference to which is returned by `generic_category()`) and the system
+category (`system_category()`). The generic category represents the error
+values of the portable subset of `errno` values defined by the POSIX standard,
+whereas the system category is OS dependent. Under POSIX, the system category
+represents the `errno` values returned by the OS APIs (a superset of those in
+the generic category), whereas under Windows, the system category represents
+the error values returned by `GetLastError()`.
+
+The framework is extensible. Users can define their own categories by
+deriving a class from `error_category` and implementing a function that
+returns a reference to an instance of it. This capability is useful both for
+describing library-defined error values, and for adapting existing C API
+libraries that return integer error values.
+
+For those who prefer error reporting via exceptions, Boost.System provides
+a standard exception class `system_error` that stores an `error_code`.
+
+Boost.System was standardized in {cpp}11 as `<system_error>`. For a while,
+the two were equivalent, but Boost.System has evolved since then and now
+contains a number of extensions over its standard sibling:
+
+* A non-allocating overload of `message`;
+* Support for nonzero error codes meaning success, via the `failed` member
+  functions;
+* Support for 64 bit category identifiers, as a solution to the problem
+  that sometimes it's not possible to ensure that only one instance of a
+  category exists in the program;
+* Support for attaching source locations (file/line/function) to error codes;
+* A class `result<T>` that can be used to return either a value or an error
+  code from a function;
+* Various other minor improvements.
+
+`boost::system::error_code` can be converted to, and constructed from,
+`std::error_code`.

doc/system/reference.adoc

@@ -175,7 +175,7 @@ namespace errc {
     too_many_files_open_in_system,  //ENFILE
     too_many_files_open,            //EMFILE
     too_many_links,                 //EMLINK
-    too_many_synbolic_link_levels,  //ELOOP
+    too_many_symbolic_link_levels,  //ELOOP
     value_too_large,                //EOVERFLOW
     wrong_protocol_type             //EPROTOTYPE
   };

include/boost/system/detail/error_code.hpp

@@ -604,7 +604,7 @@ public:
         inline friend std::basic_ostream<Ch, Tr>&
         operator<< (std::basic_ostream<Ch, Tr>& os, error_code const & ec)
     {
-        return os << ec.to_string();
+        return os << ec.to_string().c_str();
     }
 
     std::string what() const

include/boost/system/result.hpp

@@ -39,6 +39,15 @@ constexpr in_place_value_t in_place_value{};
 using in_place_error_t = variant2::in_place_index_t<1>;
 constexpr in_place_error_t in_place_error{};
 
+namespace detail
+{
+
+template<class T> using remove_cvref = typename std::remove_cv< typename std::remove_reference<T>::type >::type;
+
+template<class... T> using is_errc_t = std::is_same<mp11::mp_list<remove_cvref<T>...>, mp11::mp_list<errc::errc_t>>;
+
+} // namespace detail
+
 // result
 
 template<class T, class E = error_code> class result
@@ -65,6 +74,7 @@ public:
     // implicit, value
     template<class A = T, typename std::enable_if<
         std::is_convertible<A, T>::value &&
+        !(detail::is_errc_t<A>::value && std::is_arithmetic<T>::value) &&
         !std::is_constructible<E, A>::value, int>::type = 0>
     constexpr result( A&& a )
         noexcept( std::is_nothrow_constructible<T, A>::value )
@@ -85,6 +95,7 @@ public:
     // explicit, value
     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
         >::type>
     explicit constexpr result( A&&... a )

meta/libraries.json

@@ -4,9 +4,14 @@
     "authors": [
         "Beman Dawes"
     ],
-    "description": "Operating system support, including the diagnostics support that will be part of the C++0x standard library.",
+    "maintainers": [
+        "Peter Dimov <pdimov -at- gmail.com>"
+    ],
+    "description": "Extensible error reporting.",
     "category": [
-        "System"
+        "System",
+        "Error-handling",
+        "Programming"
     ],
     "cxxstd": "03"
 }

test/CMakeLists.txt

@@ -112,6 +112,8 @@ boost_test(TYPE run SOURCES system_error_test3.cpp)
 
 boost_test(TYPE run SOURCES std_interop_test11.cpp)
 
+boost_test(TYPE run SOURCES ec_wstream_test.cpp)
+
 # result
 
 set(BOOST_TEST_COMPILE_FEATURES cxx_std_11)

test/Jamfile.v2

@@ -134,6 +134,8 @@ run system_error_test3.cpp ;
 
 run std_interop_test11.cpp ;
 
+run ec_wstream_test.cpp ;
+
 # result
 
 import ../../config/checks/config : requires ;
@@ -154,3 +156,4 @@ run result_eq.cpp : : : $(CPP11) ;
 run result_range_for.cpp : : : $(CPP11) ;
 run result_value_construct2.cpp : : : $(CPP11) ;
 run result_error_construct2.cpp : : : $(CPP11) ;
+run result_errc_construct.cpp : : : $(CPP11) ;

test/ec_wstream_test.cpp

@@ -0,0 +1,21 @@
+// 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/core/lightweight_test.hpp>
+#include <sstream>
+
+namespace sys = boost::system;
+
+int main()
+{
+    {
+        std::wostringstream os;
+        os << sys::error_code();
+
+        BOOST_TEST( os.str() == L"system:0" );
+    }
+
+    return boost::report_errors();
+}

test/result_errc_construct.cpp

@@ -0,0 +1,23 @@
+// Copyright 2021 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_trait.hpp>
+#include <type_traits>
+
+using namespace boost::system;
+
+int main()
+{
+    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<int>>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int>, errc::errc_t>));
+
+    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<double>>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<double>, errc::errc_t>));
+
+    BOOST_TEST_TRAIT_FALSE((std::is_convertible<errc::errc_t, result<bool>>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, errc::errc_t>));
+
+    return boost::report_errors();
+}