Compare commits

...

74 Commits

Author SHA1 Message Date
Peter Dimov
00b30343b9 Asciidoctor 2 fixes 2020-06-16 21:01:38 +03:00
Peter Dimov
c91dbc8249 Update footer for Asciidoctor 2 2020-06-16 20:44:31 +03:00
Peter Dimov
00d85d8d37 Update revision history 2020-06-16 20:44:09 +03:00
Peter Dimov
5d3365717e Revert "Revert operator bool() to its pre-failed value() != 0 meaning"
This reverts commit 3164b387a5.
2020-06-16 20:24:23 +03:00
Peter Dimov
6942dc454b Fix unsupported use of BOOST_SYMBOL_VISIBLE on Sun C++ 2020-01-24 20:59:12 +02:00
Peter Dimov
7ba160e443 Rename id to id_ to avoid ObjC++ parsing issues. Fixes #52. 2020-01-18 22:15:44 +02:00
Peter Dimov
d9bfbfc4d4 Disable BUILD_TESTING on the install test 2020-01-18 15:26:21 +02:00
Peter Dimov
90cb8254df Install Core as well; add EXCLUDE_FROM_ALL to test libraries 2020-01-18 07:12:06 +02:00
Peter Dimov
4d1486dec9 Update CMakeLists.txt 2020-01-18 05:28:55 +02:00
Peter Dimov
97665bf539 Remove duplicate clang-3.6 2020-01-02 04:17:38 +02:00
Peter Dimov
6d82346e0b Fix .travis.yml mistakes 2020-01-02 02:57:24 +02:00
Peter Dimov
673dd13eaa Switch UBSAN from g++-8 to g++-9 2020-01-01 23:47:39 +02:00
Peter Dimov
ca525cd7b2 Update Travis to Xenial 2020-01-01 23:32:04 +02:00
Peter Dimov
9fb5bbd448 Remove 32 bit configuration from clang-win on Appveyor to avoid mspdbcore.dll error 2019-12-09 01:47:54 +02:00
Peter Dimov
31152834ac Add VS2019 to Appveyor; separate clang-win into its own job 2019-11-24 00:04:25 +02:00
Peter Dimov
455946faac Merge pull request #49 from Thomas-Barbier-1A/cpp7_redundant_redeclar_constexpr
Fix c++17 warning redundant redeclaration of 'constexpr' static data
2019-10-02 02:55:45 -07:00
Thomas Barbier
08370c9158 Fix c++17 warning redundant redeclaration of 'constexpr' static data
member [-Werror=deprecated]
2019-10-01 18:49:31 +02:00
Peter Dimov
c556aba559 Remove redundant Travis job 2019-06-18 12:50:59 +03:00
Peter Dimov
ecc4ddd87c Add gcc9, clang8 to Travis 2019-06-18 12:46:04 +03:00
Peter Dimov
f67827eee3 Add dist: trusty to .travis.yml 2019-06-18 01:08:17 +03:00
Peter Dimov
c08b8a94ea Fix sign extension (warning 4826.) Closes #48. 2019-05-24 18:55:27 +03:00
Peter Dimov
835e5de228 Add clang-win to Appveyor 2019-05-14 04:16:53 +03:00
Peter Dimov
dc2ad73e30 Merge pull request #47 from KABoissonneault/feature/issue_46
Added boost::winapi::ERROR_CONNECTION_ABORTED_ to handled error codes…
2019-05-13 18:14:54 -07:00
Kévin Alexandre Boissonneault
32a6c13533 Added boost::winapi::ERROR_CONNECTION_ABORTED_ to handled error codes in Win32's system_category, making it equivalent to errc::connection_aborted 2019-05-13 18:08:24 -04:00
Peter Dimov
bfbc5ec42f Remove BOOST_SYSTEM_REQUIRE_CONST_INIT; variables are constexpr, so no longer needed. Closes #45. 2019-05-12 04:15:35 +03:00
Peter Dimov
9deadda4b4 Merge branch 'feature/system-generic-visible' into feature/std-ec-mismatch 2019-04-25 20:54:01 +03:00
Peter Dimov
3b6315e4a1 Add BOOST_SYMBOL_VISIBLE to system_category(), generic_category() 2019-04-25 16:55:13 +03:00
Peter Dimov
1d845408dd Fix thread safety issue in std interop 2019-04-25 01:01:48 +03:00
Peter Dimov
e08e4253d0 Avoid allocation on interop for system/generic categories; fix DLL interoperability on msvc-14.x by poking into std::system_category::_Addr 2019-04-25 00:31:25 +03:00
Peter Dimov
afc51937be Mark to_std_category as BOOST_SYMBOL_VISIBLE 2019-04-24 23:18:19 +03:00
Peter Dimov
907c867cd1 Rename test/std_ec_mismatch to std_single_instance; test also static and shared libraries 2019-04-24 21:15:39 +03:00
Peter Dimov
9f225112f1 Add std_ec_mismatch_test 2019-04-24 18:19:21 +03:00
Peter Dimov
48b8a6c41c Switch Appveyor to 2015 image 2019-04-14 18:06:05 +03:00
Peter Dimov
9b8cb7f1f6 Fix wrong null character stripping for FormatMessage (Nikita Kniazev) 2019-03-24 01:59:23 +02:00
Peter Dimov
90b2356015 system_error_test: Increase tested messages range (Nikita Kniazev) 2019-03-24 00:24:05 +02:00
Peter Dimov
1c36a72b79 Merge pull request #40 from Kojoley/system_error_test-mingw-non-en
system_error_test: Enable locale query on MinGW-w64
2019-03-17 11:28:45 +02:00
Nikita Kniazev
7947d0ed0d system_error_test: Reenable locale query on MinGW and Cygwin 2019-03-17 01:53:37 +03:00
Peter Dimov
72d3e96c73 Disable English-dependent test; fixes #39. 2019-03-16 19:51:21 +02:00
Peter Dimov
ca882f286c Skip system_category_test_utf8; comparing against FormatMessageA isn't going to work. Fixes #38. 2019-03-16 19:44:43 +02:00
Peter Dimov
df78f08bd2 Merge pull request #37 from Kojoley/patch-1
system_category_test: Increase buffer size
2019-03-16 19:02:47 +02:00
Nikita Kniazev
f878f41fe7 system_category_test: Increase buffer size
The message for 5810 error does not fit into buffer on non-English locales.
2019-03-16 01:55:18 +03:00
Peter Dimov
0134441a6e Add warnings_test.cpp; disable -Wnon-virtual-dtor on g++ < 4.6 2019-03-04 19:23:32 +02:00
Peter Dimov
c705bab504 #pragma GCC diagnostic push/pop requires gcc 4.6 2019-03-04 17:38:52 +02:00
Peter Dimov
af1dc84160 Disable -Wnon-virtual-dtor 2019-03-04 16:35:35 +02:00
Peter Dimov
2d37749d00 Enable -Wnon-virtual-dtor in warnings_test 2019-03-04 15:40:03 +02:00
Peter Dimov
3164b387a5 Revert operator bool() to its pre-failed value() != 0 meaning 2019-02-27 21:10:57 +02:00
Peter Dimov
9753cf7668 Update test/Jamfile 2019-02-27 06:23:16 +02:00
Peter Dimov
ef7c34fc30 Remove use of _alloca 2019-02-26 17:22:58 +02:00
Peter Dimov
f726c068c3 Add UTF-8 tests 2019-02-26 16:42:47 +02:00
Peter Dimov
2929d2dea2 Fix .travis.yml 2019-01-06 04:38:22 +02:00
Peter Dimov
2c01c5d5c8 Add test/cmake_subdir_test 2019-01-05 19:55:38 +02:00
Peter Dimov
5ab9a5117d Update CMakeLists.txt 2019-01-04 19:38:01 +02:00
Mike Dev
ee916382df [CMake] Generate cmake target that other libraries can use
... to express their dependency on this library and retrieve any
configuration information such as the include directory, binary
to link to (if any), transitive dependencies, necessary compiler
options or the required c++ standards level.
2018-12-23 22:47:51 +01:00
Peter Dimov
fc1f2f4845 Remove essentials from yml files 2018-12-22 05:14:53 +02:00
Peter Dimov
65daf972d3 Update .yml files 2018-12-18 21:56:44 +02:00
Peter Dimov
3a4fff686e Fix warnings on clang-win 2018-10-27 05:30:27 +03:00
Peter Dimov
054c0caf60 Add newline at end 2018-10-04 21:13:56 +03:00
Peter Dimov
b31fb4804d Document system_error changes; add example for message(ev, buffer, len) 2018-10-03 03:40:10 +03:00
Peter Dimov
7f303cc4b6 Remove old .html files; update redirect 2018-10-03 01:19:28 +03:00
Peter Dimov
504fb05c2f Make system_error(ec) explicit, return by value from system_error::code() 2018-10-03 01:15:43 +03:00
Peter Dimov
d13fa54450 Remove throws() from synopsis; document system_error 2018-10-03 00:24:10 +03:00
Peter Dimov
fb44b43f0a Merge branch 'develop' into feature/asciidoc 2018-10-02 23:02:24 +03:00
Peter Dimov
e87cd333a8 Work around 'unused variable' MSVC warning 2018-10-02 18:39:41 +03:00
Peter Dimov
3d01409fe6 Avoid long long warnings 2018-10-02 17:51:09 +03:00
Peter Dimov
25a34e1647 Merge branch 'develop' into feature/warnings-all 2018-10-02 17:15:40 +03:00
Peter Dimov
78a1813c13 Merge branch 'develop' into feature/use-utf8 2018-10-02 04:36:25 +03:00
Peter Dimov
342400c7ec Add a quick test with -Wall -Werror 2018-10-02 04:34:33 +03:00
Peter Dimov
1b4c7f366d Minor grammar fixes 2018-10-02 04:03:39 +03:00
Peter Dimov
af2edc5bea Add .gitignore 2018-10-02 02:59:42 +03:00
Peter Dimov
1e6dc86a68 Change code to match documentation 2018-10-02 02:59:03 +03:00
Peter Dimov
efff0260f7 Add changes, reference; fix trailing whitespace 2018-10-02 02:58:21 +03:00
Peter Dimov
62ca8e6d8c Add asciidoc documentation 2018-10-01 19:20:52 +03:00
Peter Dimov
584f9731ad Refactor BOOST_SYSTEM_USE_UTF8 code 2018-10-01 17:40:16 +03:00
Peter Dimov
b300fdeef4 Use CP_UTF8 when BOOST_SYSTEM_USE_UTF8 is defined 2018-09-21 20:45:44 +03:00
35 changed files with 1918 additions and 1293 deletions

View File

@@ -1,4 +1,4 @@
# Copyright 2016, 2017, 2018 Peter Dimov
# Copyright 2016-2019 Peter Dimov
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
@@ -6,7 +6,7 @@ language: cpp
sudo: false
python: "2.7"
dist: xenial
branches:
only:
@@ -109,7 +109,7 @@ matrix:
- os: linux
compiler: g++-8
env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17,2a
addons:
apt:
packages:
@@ -118,12 +118,22 @@ matrix:
- ubuntu-toolchain-r-test
- os: linux
compiler: g++-8
env: UBSAN=1 TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
compiler: g++-9
env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17,2a
addons:
apt:
packages:
- g++-8
- g++-9
sources:
- ubuntu-toolchain-r-test
- os: linux
compiler: g++-9
env: UBSAN=1 TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
addons:
apt:
packages:
- g++-9
sources:
- ubuntu-toolchain-r-test
@@ -132,6 +142,7 @@ matrix:
env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
- os: linux
dist: trusty
compiler: /usr/bin/clang++
env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
addons:
@@ -140,6 +151,7 @@ matrix:
- clang-3.3
- os: linux
dist: trusty
compiler: /usr/bin/clang++
env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
addons:
@@ -148,16 +160,15 @@ matrix:
- clang-3.4
- os: linux
dist: trusty
compiler: clang++-3.5
env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-3.5
- libstdc++-4.9-dev
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.5
- os: linux
compiler: clang++-3.6
@@ -168,19 +179,6 @@ matrix:
- clang-3.6
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.6
- os: linux
compiler: clang++-3.6
env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-3.6
- libstdc++-4.9-dev
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.6
- os: linux
compiler: clang++-3.7
@@ -191,19 +189,6 @@ matrix:
- clang-3.7
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.7
- os: linux
compiler: clang++-3.7
env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-3.7
- libstdc++-4.9-dev
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.7
- os: linux
compiler: clang++-3.8
@@ -214,19 +199,6 @@ matrix:
- clang-3.8
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.8
- os: linux
compiler: clang++-3.8
env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-3.8
- libstdc++-4.9-dev
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.8
- os: linux
compiler: clang++-3.9
@@ -237,19 +209,6 @@ matrix:
- clang-3.9
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.9
- os: linux
compiler: clang++-3.9
env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-3.9
- libstdc++-4.9-dev
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.9
- os: linux
compiler: clang++-4.0
@@ -260,19 +219,6 @@ matrix:
- clang-4.0
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-trusty-4.0
- os: linux
compiler: clang++-4.0
env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-4.0
- libstdc++-4.9-dev
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-trusty-4.0
- os: linux
compiler: clang++-5.0
@@ -283,19 +229,6 @@ matrix:
- clang-5.0
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-trusty-5.0
- os: linux
compiler: clang++-5.0
env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
addons:
apt:
packages:
- clang-5.0
- libstdc++-4.9-dev
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-trusty-5.0
- os: linux
compiler: clang++-6.0
@@ -306,33 +239,54 @@ matrix:
- clang-6.0
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-trusty-6.0
- os: linux
compiler: clang++-6.0
env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
compiler: clang++-7
env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17,2a
addons:
apt:
packages:
- clang-6.0
- libstdc++-4.9-dev
- clang-7
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-trusty-6.0
- llvm-toolchain-xenial-7
- os: linux
compiler: clang++-6.0
env: UBSAN=1 TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
compiler: clang++-8
env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17,2a
addons:
apt:
packages:
- clang-6.0
- libstdc++-5-dev
- clang-8
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-trusty-6.0
- llvm-toolchain-xenial-8
- os: linux
compiler: clang++-9
env: TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11,14,17,2a
addons:
apt:
packages:
- clang-9
sources:
- ubuntu-toolchain-r-test
- sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
- os: linux
compiler: clang++-8
env: UBSAN=1 TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
addons:
apt:
packages:
- clang-8
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-xenial-8
- os: linux
dist: trusty
compiler: clang++-libc++
env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
addons:
@@ -341,6 +295,7 @@ matrix:
- libc++-dev
- os: linux
dist: trusty
compiler: clang++-libc++
env: UBSAN=1 TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
addons:
@@ -352,13 +307,56 @@ matrix:
compiler: clang++
env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
- os: osx
compiler: clang++
env: UBSAN=1 TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
- os: linux
env: CMAKE=1
script:
- mkdir __build__ && cd __build__
- cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=system -DBUILD_TESTING=ON ..
- ctest --output-on-failure -R boost_system
- os: linux
env: CMAKE=1 BUILD_SHARED_LIBS=ON
script:
- mkdir __build__ && cd __build__
- cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBUILD_SHARED_LIBS=ON -DBOOST_INCLUDE_LIBRARIES=system -DBUILD_TESTING=ON ..
- ctest --output-on-failure -R boost_system
- os: linux
env: CMAKE_SUBDIR_TEST=1
install:
- BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
- git clone -b $BOOST_BRANCH https://github.com/boostorg/assert.git ../assert
- git clone -b $BOOST_BRANCH https://github.com/boostorg/config.git ../config
- git clone -b $BOOST_BRANCH https://github.com/boostorg/core.git ../core
- git clone -b $BOOST_BRANCH https://github.com/boostorg/predef.git ../predef
- git clone -b $BOOST_BRANCH https://github.com/boostorg/winapi.git ../winapi
script:
- cd test/cmake_subdir_test && mkdir __build__ && cd __build__
- cmake ..
- cmake --build .
- cmake --build . --target check
- os: linux
env: CMAKE_INSTALL=1
script:
- pip install --user cmake
- mkdir __build__ && cd __build__
- cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES="system;core" -DBUILD_TESTING=OFF -DCMAKE_INSTALL_PREFIX=~/.local ..
- cmake --build . --target install
- cd ../libs/system/test/cmake_install_test && mkdir __build__ && cd __build__
- cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
- cmake --build .
- cmake --build . --target check
install:
- BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
- cd ..
- git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
- cd boost-root
- git submodule update --init tools/build
- git submodule update --init libs/config
- git submodule update --init tools/boostdep
- cp -r $TRAVIS_BUILD_DIR/* libs/system
- python tools/boostdep/depinst/depinst.py system

24
CMakeLists.txt Normal file
View File

@@ -0,0 +1,24 @@
# Copyright 2018-2020 Peter Dimov
# Distributed under the Boost Software License, Version 1.0.
# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
cmake_minimum_required(VERSION 3.5...3.16)
project(boost_system VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
add_library(boost_system INTERFACE)
add_library(Boost::system ALIAS boost_system)
target_include_directories(boost_system INTERFACE include)
target_link_libraries(boost_system
INTERFACE
Boost::config
Boost::winapi
)
if(BUILD_TESTING)
add_subdirectory(test)
endif()

View File

@@ -1,4 +1,4 @@
# Copyright 2016-2018 Peter Dimov
# Copyright 2016-2019 Peter Dimov
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
@@ -14,28 +14,36 @@ branches:
environment:
matrix:
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-14.0
TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
TOOLSET: msvc-12.0,msvc-14.0
ADDRMD: 32,64
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TOOLSET: msvc-14.1
CXXSTD: 14,17
ADDRMD: 32,64
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
TOOLSET: clang-win
CXXSTD: 14,17
ADDRMD: 64
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
TOOLSET: msvc-14.2
CXXSTD: 14,17
ADDRMD: 32,64
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
ADDPATH: C:\cygwin\bin;
TOOLSET: gcc
CXXSTD: 03,11,14,1z
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
ADDPATH: C:\cygwin64\bin;
TOOLSET: gcc
CXXSTD: 03,11,14,1z
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
ADDPATH: C:\mingw\bin;
TOOLSET: gcc
CXXSTD: 03,11,14,1z
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
TOOLSET: gcc
CXXSTD: 03,11,14,1z
@@ -46,10 +54,8 @@ install:
- cd ..
- git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
- cd boost-root
- git submodule update --init tools/build
- git submodule update --init libs/config
- git submodule update --init tools/boostdep
- xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\system
- xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\system\
- python tools/boostdep/depinst/depinst.py system
- cmd /c bootstrap
- b2 -d0 headers

View File

@@ -22,4 +22,4 @@ lib boost_system
<link>static:<define>BOOST_SYSTEM_STATIC_LINK=1
;
boost-install boost_system ;
boost-install boost_system ;

2
doc/.gitignore vendored Normal file
View File

@@ -0,0 +1,2 @@
/html/
/pdf/

23
doc/Jamfile Normal file
View File

@@ -0,0 +1,23 @@
# Copyright 2017, 2018 Peter Dimov
#
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
import asciidoctor ;
html system.html : system.adoc ;
install html_ : system.html : <location>html ;
pdf system.pdf : system.adoc ;
explicit system.pdf ;
install pdf_ : system.pdf : <location>pdf ;
explicit pdf_ ;
###############################################################################
alias boostdoc ;
explicit boostdoc ;
alias boostrelease : html_ ;
explicit boostrelease ;

View File

@@ -1,163 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Language" content="en-us">
<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<title>Boost System Library</title>
<link rel="stylesheet" type="text/css" href="../../../doc/src/minimal.css">
</head>
<body>
<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111">
<tr>
<td width="277">
<a href="../../../index.html">
<img src="../../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86" border="0"></a></td>
<td width="337" align="middle">
<font size="7">System Library</font>
</td>
</tr>
</table>
<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="100%">
<tr>
<td><a href="../../../index.htm">Boost Home</a>&nbsp;&nbsp;&nbsp; <a href="index.html">
Library Home</a>&nbsp;&nbsp; Tutorial&nbsp;&nbsp; <a href="reference.html">
Reference</a></td>
</tr>
</table>
<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" align="right">
<tr>
<td width="100%" bgcolor="#D7EEFF" align="center">
<i><b>Contents</b></i></td>
</tr>
<tr>
<td width="100%" bgcolor="#E8F5FF">
<a href="#Introduction">Introduction</a><br>
<a href="#Release_History">Release History</a><br>
<a href="#Design_Rationale">Design Rationale</a><br>
<a href="#History">History</a><br>
<a href="#Acknowledgements">Acknowledgements</a>
</td>
</tr>
<tr>
<td width="100%" bgcolor="#D7EEFF" align="center">
<b><i>Headers</i></b></td>
</tr>
<tr>
<td width="100%" bgcolor="#E8F5FF">
<a href="reference.html#Header-error_code">&lt;boost/system/error_code.hpp&gt;</a><br>
<a href="reference.html#Header-system_error">
&lt;boost/system/system_error.hpp&gt;</a><br>
<a href="../../../boost/system/cygwin_error.hpp">
&lt;boost/system/cygwin_error.hpp&gt;</a><br>
<a href="../../../boost/system/linux_error.hpp">
&lt;boost/system/linux_error.hpp&gt;</a><br>
<a href="../../../boost/system/windows_error.hpp">
&lt;boost/system/windows_error.hpp&gt;</a></td>
</tr>
</table>
<h2><a name="Introduction">Introduction</a></h2>
<p>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 <a href="reference.html#Class-error_code">
error_code</a> objects that encapsulate system-specific error code values, yet
also provide access to more abstract and portable error conditions via
<a href="reference.html#Class-error_condition">error_condition</a> objects.
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 <a href="reference.html#Class-error_category">
error_category</a>.</p>
<p>An exception class,&nbsp; <a href="reference.html#Class-system_error">
system_error</a>, 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.</p>
<p>While exceptions are the preferred C++ default error code reporting
mechanism, users of libraries dependent on low-level API's&nbsp;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 very inefficient. The Boost System library
supports both error reporting by exception and by error code.</p>
<p>In addition to portable errors codes and conditions supported by the <code>
error_code.hpp</code> 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.</p>
<table border="1" cellpadding="10" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
<tr>
<td>The Boost System Library is part of the C++11 Standard Library.
A number of changes, particularly to names, were made by the C++ committee
during standardization. The Boost implementation is tracking those changes.
See <a href="reference.html#Deprecated-names">Deprecated names</a> for
synonyms provided to prevent breakage of existing user code. See
<a href="reference.html#Breaking-changes">Breaking changes</a> for changes
that unavoidably break existing user code. All breaking changes are noisy
and will cause compile-time errors.</td>
</tr>
</table>
<h2><a name="Release_History">Release History</a></h2>
<p><code>system-2014-06-02</code>: First modular Boost release. Minor
maintenance changes.</p>
<h2><a name="Design_Rationale">Design Rationale</a></h2>
<p>Class <code>error_code</code>&nbsp; and <code>error_condition</code> are designed as a value types so
they can be copied
without slicing and do not requiring heap allocation, but still have polymorphic
behavior based on the error category. This is achieved by abstract base class
<code>error_category</code> supplying the polymorphic behavior, and <code>
error_code</code> and <code>error_condition</code> containing a pointer to an object of a type derived from <code>
error_category</code>.</p>
<p>Many of the detailed design decisions were driven by the requirements that
users to be able to add additional error categories, and that it be no more
difficult to write portable code than system-specific code.</p>
<p>The <code>operator&lt;&lt;</code> overload for <code>error_code</code> eliminates a
misleading conversion to bool in code like <code>cout &lt;&lt; ec</code>, where <code>
ec</code> is of type <code>error_code</code>. It is also useful in its own
right.</p>
<h2><a name="History">History</a></h2>
<p><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1975.html">
N1975</a>, Filesystem Library Proposal for TR2, accepted for Library Technical
Report 2 (TR2) at the Berlin meeting, included additional components to
supplement the Standard Library's Diagnostics clause. Since then, these error
reporting components have received wider public scrutiny and enhancements have
been made to the design. The enhanced version has been used by N2054, Networking
Library Proposal for TR2, demonstrating that these error reporting components
are useful beyond the original Filesystem Library.</p>
<p>The original proposal viewed error categories as a binary choice between
<code>errno</code> (i.e. POSIX-style) and the native operating system's error
codes. The proposed components now allow as many additional error categories as
are needed by either implementations or by users. The need to support additional
error categories, for example, occurs in some networking library implementations
because they are built on top of the POSIX <code>getaddrinfo</code> API that
uses error codes not based on <code>errno</code>.</p>
<h2><a name="Acknowledgements">Acknowledgements</a></h2>
<p>Christopher Kohlhoff and Peter Dimov made important contributions to the
design. Comments and suggestions were also received from Pavel Vozenilek,
Gennaro Prota, Dave Abrahams, Jeff Garland, Iain Hanson, Oliver Kowalke, and
Oleg Abrosimov. Christopher Kohlhoff suggested several improvements to the N2066
paper. Johan Nilsson's comments led to several of the refinements in N2066 .</p>
<hr>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->June 02, 2014<!--webbot bot="Timestamp" endspan i-checksum="13984" --> </font>
</p>
<p><EFBFBD> Copyright Beman Dawes, 1999</p>
<p>Distributed under the Boost Software License, Version 1.0.
(See file <a href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a>
or&nbsp; <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>) </p>
</body>
</html>

View File

@@ -1,834 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Language" content="en-us">
<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<title>System Library Reference</title>
<link rel="stylesheet" type="text/css" href="../../../doc/src/minimal.css">
</head>
<body>
<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="637">
<tr>
<td width="277">
<a href="../../../index.htm">
<img src="../../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86" border="0"></a></td>
<td width="337" align="middle">
<font size="7">System Library</font>
</td>
</tr>
</table>
<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="100%">
<tr>
<td><a href="../../../index.htm">Boost Home</a>&nbsp;&nbsp;&nbsp; <a href="index.html">
Library Home</a>&nbsp;&nbsp; Tutorial&nbsp;&nbsp; <a href="reference.html">
Reference</a></td>
</tr>
</table>
<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" align="right">
<tr>
<td width="100%" bgcolor="#D7EEFF" align="center">
<i><b>Contents</b></i></td>
</tr>
<tr>
<td width="100%" bgcolor="#E8F5FF">
<a href="#Introduction">Introduction</a><br>
<a href="#C++11">C++11</a><br>
<a href="#Macros">Macros</a><br>
<a href="#Deprecated-names">Deprecated names</a><br>
<a href="#Breaking-changes">Breaking changes</a><br>
<a href="#Header-error_code">Header &lt;boost/system/error_code.hpp&gt;</a><br>
<a href="#Class-error_category">Class <code>error_category</code></a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_category-synopsis">Class <code>error_category</code> synopsis</a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_category-virtual-members">Class <code>error_category</code> virtual members</a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_category-non-virtual-members">Class <code>error_category</code> non-virtual members</a><br>
&nbsp;&nbsp; <a href="#Class-error_category-non-member-functions">Class <code>error_category</code>
non-member functions</a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_category-predefined-objects">Class <code>error_category</code> predefined objects</a><br>
<a href="#Class-error_code">Class <code>error_code</code></a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_code-synopsis">Class <code>error_code</code> synopsis</a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_code-constructors">Class <code>error_code</code> constructors</a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_code-modifiers">Class <code>error_code</code> modifiers</a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_code-observers">Class <code>error_code</code> observers</a><br>
<a href="#Class-error_condition">Class <code>error_condition</code></a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_condition-synopsis">Class <code>error_condition</code> synopsis</a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_condition-constructors">Class <code>error_condition</code> constructors</a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_condition-modifiers">Class <code>error_condition</code> modifiers</a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-error_condition-observers">Class <code>error_condition</code> observers</a><br>
<a href="#Function-boost-throws">Function <code>boost::throws()</code></a><br>
<a href="#Non-member-functions">Non-member functions</a><br>
<a href="#Header-system_error">Header &lt;boost/system/system_error.hpp&gt;</a><br>
&nbsp;&nbsp;&nbsp;<a href="#Class-system_error">Class <code>system_error</code></a><br>
</td>
</tr>
</table>
<h2><a name="Introduction">Introduction</a></h2>
<p>This reference documentation describes components that&nbsp;programs may use to report error conditions originating from the operating
system or other low-level application program interfaces.</p>
<p>Boost.System library components never change the value of <code>
errno</code>.</p>
<h2><a name="C++11">C++11</a></h2>
<p>The library is documented to use several C++11 features, including <code>
noexcept</code> and explicit conversion operators. The actual implementation
uses C++11 features only when they are available, and otherwise falls back on
C++03 features.</p>
<h2><a name="Macros">Macros</a></h2>
<p>Users may define the following macros if desired. Sensible defaults are
provided, so users may ignore these macros if they prefer.</p>
<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" height="368">
<tr>
<td height="16"><b><i>Macro Name</i></b></td>
<td height="16"><b><i>Default</i></b></td>
<td height="16"><b><i>Effect if defined</i></b></td>
</tr>
<tr>
<td valign="top" height="64"><code>BOOST_ERROR_CODE_HEADER_ONLY</code></td>
<td valign="top" height="64">Not defined.</td>
<td valign="top" height="64">The implementation is header-only, and the
Boost.System library is not built. Overrides other link and library macros.</td>
</tr>
<tr>
<td valign="top" height="64"><code>BOOST_SYSTEM_DYN_LINK</code></td>
<td valign="top" height="64">Defined if <code>BOOST_ALL_DYN_LINK</code> is defined,
otherwise not defined.</td>
<td valign="top" height="64">Boost.System library is dynamically linked. If not defined,
static linking is assumed.</td>
</tr>
<tr>
<td valign="top" height="47"><code>BOOST_SYSTEM_NO_LIB</code></td>
<td valign="top" height="47">Defined if <code>BOOST_ALL_NO_LIB</code> is defined,
otherwise not defined.</td>
<td valign="top" height="47">Boost.System library does not use the Boost auto-link
facility.</td>
</tr>
<tr>
<td valign="top" height="32"><code>BOOST_SYSTEM_ENABLE_DEPRECATED</code></td>
<td valign="top" height="32">Not defined.</td>
<td valign="top" height="32">Deprecated features are provided for compatibility.</td>
</tr>
</table>
<h2><a name="Deprecated-names">Deprecated names</a></h2>
<p>In the process of adding Boost.System to the C++11 standard library, the
C++ committee changed some names. To ease transition, Boost.System deprecates
the old names, but will provide them when the macro
<code>BOOST_SYSTEM_ENABLE_DEPRECATED</code> is defined.</p>
<table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
<tr>
<td><b><i>Old usage, now deprecated</i></b></td>
<td><b><i>Replacement</i></b></td>
</tr>
<tr>
<td><code>get_generic_category()</code></td>
<td><code>generic_category()</code></td>
</tr>
<tr>
<td><code>get_system_category()</code></td>
<td><code>system_category()</code></td>
</tr>
<tr>
<td><code>namespace posix</code></td>
<td><code>namespace errc</code></td>
</tr>
<tr>
<td><code>namespace posix_error</code></td>
<td><code>namespace errc</code></td>
</tr>
<tr>
<td><code>enum posix_errno</code></td>
<td><code>enum errc_t</code></td>
</tr>
<tr>
<td><code>get_posix_category()</code></td>
<td><code>generic_category()</code></td>
</tr>
<tr>
<td><code>posix_category</code></td>
<td><code>generic_category()</code></td>
</tr>
<tr>
<td><code>errno_ecat</code></td>
<td><code>generic_category()</code></td>
</tr>
<tr>
<td><code>native_ecat</code></td>
<td><code>system_category()</code></td>
</tr>
</table>
<h2><a name="Breaking-changes">Breaking changes</a></h2>
<p>Two static consts are replaced by functions. These are breaking changes best
fixed by globally adding () to these names to turn them into function calls.</p>
<table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
<tr>
<td><b><i>Old usage, now broken</i></b></td>
<td><b><i>Replacement</i></b></td>
</tr>
<tr>
<td><code>generic_category</code></td>
<td><code>generic_category()</code></td>
</tr>
<tr>
<td><code>system_category</code></td>
<td><code>system_category()</code></td>
</tr>
</table>
<p>User-defined BOOST_POSIX_API and BOOST_WINDOWS_API macros are no longer supported.</p>
<h2><a name="Header-error_code">Header &lt;boost/system/error_code.hpp&gt;</a></h2>
<h3>&lt;boost/system/error_code.hpp&gt; synopsis</h3>
<blockquote>
<pre>namespace boost
{
namespace system
{
class <a href="#Class-error_category">error_category</a>;
const error_category &amp; <a href="#system_category">system_category</a>() noexcept;
const error_category &amp; <a href="#generic_category">generic_category</a>() noexcept;
class <a href="#Class-error_code">error_code</a>;
class <a href="#Class-error_condition">error_condition</a>;
// "Concept" helpers
template< class T="" >
struct is_error_code_enum { static const bool value = false; };
template< class T="" >
struct is_error_condition_enum { static const bool value = false; };
// generic error_conditions
namespace errc
{
enum errc_t
{
success = 0,
address_family_not_supported, //EAFNOSUPPORT
address_in_use, //EADDRINUSE
address_not_available, //EADDRNOTAVAIL
already_connected, //EISCONN
argument_list_too_long, //E2BIG
argument_out_of_domain, //EDOM
bad_address, //EFAULT
bad_file_descriptor, //EBADF
bad_message, //EBADMSG
broken_pipe, //EPIPE
connection_aborted, //ECONNABORTED
connection_already_in_progress, //EALREADY
connection_refused, //ECONNREFUSED
connection_reset, //ECONNRESET
cross_device_link, //EXDEV
destination_address_required, //EDESTADDRREQ
device_or_resource_busy, //EBUSY
directory_not_empty, //ENOTEMPTY
executable_format_error, //ENOEXEC
file_exists, //EEXIST
file_too_large, //EFBIG
filename_too_long, //ENAMETOOLONG
function_not_supported, //ENOSYS
host_unreachable, //EHOSTUNREACH
identifier_removed, //EIDRM
illegal_byte_sequence, //EILSEQ
inappropriate_io_control_operation,//ENOTTY
interrupted, //EINTR
invalid_argument, //EINVAL
invalid_seek, //ESPIPE
io_error, //EIO
is_a_directory, //EISDIR
message_size, //EMSGSIZE
network_down, //ENETDOWN
network_reset, //ENETRESET
network_unreachable, //ENETUNREACH
no_buffer_space, //ENOBUFS
no_child_process, //ECHILD
no_link, //ENOLINK
no_lock_available, //ENOLCK
no_message_available, //ENODATA
no_message, //ENOMSG
no_protocol_option, //ENOPROTOOPT
no_space_on_device, //ENOSPC
no_stream_resources, //ENOSR
no_such_device_or_address, //ENXIO
no_such_device, //ENODEV
no_such_file_or_directory, //ENOENT
no_such_process, //ESRCH
not_a_directory, //ENOTDIR
not_a_socket, //ENOTSOCK
not_a_stream, //ENOSTR
not_connected, //ENOTCONN
not_enough_memory, //ENOMEM
not_supported, //ENOTSUP
operation_canceled, //ECANCELED
operation_in_progress, //EINPROGRESS
operation_not_permitted, //EPERM
operation_not_supported, //EOPNOTSUPP
operation_would_block, //EWOULDBLOCK
owner_dead, //EOWNERDEAD
permission_denied, //EACCES
protocol_error, //EPROTO
protocol_not_supported, //EPROTONOSUPPORT
read_only_file_system, //EROFS
resource_deadlock_would_occur, //EDEADLK
resource_unavailable_try_again, //EAGAIN
result_out_of_range, //ERANGE
state_not_recoverable, //ENOTRECOVERABLE
stream_timeout, //ETIME
text_file_busy, //ETXTBSY
timed_out, //ETIMEDOUT
too_many_files_open_in_system, //ENFILE
too_many_files_open, //EMFILE
too_many_links, //EMLINK
too_many_synbolic_link_levels, //ELOOP
value_too_large, //EOVERFLOW
wrong_protocol_type //EPROTOTYPE
};
} // namespace errc
template<> struct is_error_condition_enum<posix::posix_errno>&lt;errc::errc_t&gt;
{ static const bool value = true; };
// <a href="#Non-member-functions">non-member functions</a>
bool operator==( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;
bool operator==( const error_code &amp; code, const error_condition &amp; condition ) noexcept;
bool operator==( const error_condition &amp; condition, const error_code &amp; code ) noexcept;
bool operator==( const error_condition &amp; lhs, const error_condition &amp; rhs ) noexcept;
bool operator!=( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;
bool operator!=( const error_code &amp; code, const error_condition &amp; condition ) noexcept;
bool operator!=( const error_condition &amp; condition, const error_code &amp; code ) noexcept;
bool operator!=( const error_condition &amp; lhs, const error_condition &amp; rhs ) noexcept;
bool operator&lt;( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;
bool operator&lt;( const error_condition &amp; lhs, const error_condition &amp; rhs ) noexcept;
error_code make_error_code( errc::errc_t e ) noexcept;
error_condition make_error_condition( errc::errc_t e ) noexcept;
template &lt;class charT, class traits&gt;
std::basic_ostream&lt;charT,traits&gt;&amp;
operator&lt;&lt;( basic_ostream&lt;charT,traits&gt;&amp; os, const error_code &amp; ec );
size_t hash_value( const error_code &amp; ec );
} // namespace system
system::error_code &amp; throws();
} // namespace boost</pre>
</blockquote>
<p>The value of each<code> errc_t</code> constant shall be the same as the
value of the <code>&lt;cerrno&gt;</code> macro shown in the above synopsis.</p>
<p>Users may specialize <code>is_error_code_enum</code> and <code>
is_error_condition_enum</code> templates to indicate that a type is eligible for
class <code>error_code</code> and <code>error_condition</code> automatic
conversions respectively.</p>
<pre>const error_category &amp; <a name="system_category">system_category</a>();</pre>
<blockquote>
<p><i>Returns:</i> A reference to a <code>error_category</code> object
identifying errors originating from the operating system.</p>
</blockquote>
<pre>const error_category &amp; <a name="generic_category">generic_category</a>();</pre>
<blockquote>
<p><i>Returns:</i> A reference to a <code>error_category</code> object
identifying portable error conditions.</p>
</blockquote>
<h2><a name="Class-error_category">Class <code>error_category</code></a></h2>
<p>The class <code>error_category</code> defines the base class for types used
to identify the source and encoding of a particular category of error code.</p>
<p><i>[Note:</i> Classes may be derived from <code>error_category</code>
to support additional categories of errors. <i>--end note]</i></p>
<p>The class <code>error_category</code> serves as a base class for types used
to identify the source and encoding of a particular category of error code.
Classes may be derived from <code>error_category</code> to support categories of
errors in addition to those defined in the Boost System library. Such classes
shall behave as specified in this subclause. [<i> Note:</i> <code>error_category</code>
objects are passed by reference, and two such objects are equal if they have the
same address. This means that applications using custom <code>error_category</code>
types should create a single object of each such type. <i><EFBFBD>end note</i> ]</p>
<h3><a name="Class-error_category-synopsis">Class <code>error_category</code> synopsis</a></h3>
<blockquote>
<pre>namespace boost
{
namespace system
{
class error_category : public noncopyable
{
public:
virtual ~error_category();
virtual const char * name() const noexcept = 0;
virtual string message( int ev ) const = 0;
virtual error_condition default_error_condition( int ev ) const noexcept;
virtual bool equivalent( int code, const error_condition &amp; condition )
const noexcept;
virtual bool equivalent( const error_code &amp; code, int condition ) const noexcept;
bool operator==( const error_category &amp; rhs ) const noexcept;
bool operator!=( const error_category &amp; rhs ) const noexcept;
bool operator&lt; ( const error_category &amp; rhs ) const noexcept;
};
}
}</pre>
</blockquote>
<h3><a name="Class-error_category-virtual-members">Class <code>error_category</code> virtual members</a></h3>
<p>Classes derived from <code>error_category</code> shall behave as specified in
this subclause.</p>
<pre>virtual const char * name() const noexcept =0;</pre>
<blockquote>
<p><i>Returns: </i>a string naming the error category.</p>
</blockquote>
<pre>virtual string message( int ev ) const noexcept =0;</pre>
<blockquote>
<p><i>Returns:</i> A string that describes the error denoted by
<code>ev</code>.</p>
</blockquote>
<pre>virtual error_condition default_error_condition( int ev ) const noexcept;</pre>
<blockquote>
<p><i>Returns:</i>&nbsp; <code>error_condition( ev, *this )</code>.</p>
<blockquote>
<p dir="ltr">&nbsp;[<i>--Note:</i> Derived classes will typically convert <code>ev</code>
to some portable <code>error_category</code>, such as <code>generic_category()</code>,
and return it as an <code>error_condition</code> for that category. <i>--end
note</i>]</p>
</blockquote>
</blockquote>
<pre>virtual bool equivalent( int code, const error_condition &amp; condition ) const noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>default_error_condition( code ) == condition</code>.</p>
</blockquote>
<pre>virtual bool equivalent( const error_code &amp; code, int condition ) const noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>*this == code.category() &amp;&amp; code.value() == condition</code>.</p>
</blockquote>
<h3><a name="Class-error_category-non-virtual-members">Class <code>error_category</code> non-virtual members</a></h3>
<pre>bool operator==( const error_category &amp; rhs ) const noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>this == &amp;rhs</code>.</p>
</blockquote>
<pre>bool operator!=( const error_category &amp; rhs ) const noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>this != &amp;rhs</code>.</p>
</blockquote>
<pre>bool operator&lt;( const error_category &amp; rhs ) const noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>std::less&lt;const error_category*&gt;()( this, &amp;rhs&nbsp;
noexcept)</code>.</p>
<blockquote>
<p><i>[Note:</i> <code>std::less</code> provides a total ordering for
pointers. <i>--end note]</i></p>
</blockquote>
</blockquote>
<h2><a name="Class-error_code">Class <code>
error_code</code></a></h2>
<p>The class <code>error_code</code> describes an object used to hold error code
values, such as those originating from the operating<br>
system or other low-level application program interfaces. <i>[ Note: </i>Class
<code>error_code</code> is an adjunct to error reporting by<br>
exception. <i><EFBFBD>end note ]</i></p>
<h3><a name="Class-error_code-synopsis">Class <code>
error_code</code> synopsis</a></h3>
<blockquote>
<pre>namespace boost
{
namespace system
{
class error_code {
public:
// constructors:
error_code() noexcept;
error_code( val, const error_category &amp; cat ) noexcept;
template &lt;class <code>ErrorCodeEnum</code>&gt;
error_code(<code> ErrorCodeEnum</code> e ) noexcept;
// modifiers:
void assign( int val, const error_category &amp; cat ) noexcept;
template&lt;typename <code>ErrorCodeEnum</code>&gt;
error_code &amp; operator=( <code>ErrorCodeEnum</code> val ) noexcept;
void clear() noexcept;
// observers:
int value() const noexcept;
cont error_category &amp; category() const noexcept;
error_condition default_error_condition() const noexcept;
string message() const;
operator unspecified-bool-type() const;
private:
int val_; // <i>exposition only</i>
const error_category * cat_; // <i>exposition only</i>
};
}
}</pre>
</blockquote>
<h3><a name="Class-error_code-constructors">Class <code>
error_code</code> constructors</a></h3>
<pre>error_code() noexcept;</pre>
<blockquote>
<p><i>Effects: </i>Constructs an object of type <code>error_code</code>.</p>
<p><i>Postconditions:</i> <code>val_ == 0 &amp;&amp; cat_ == &amp;system_category()</code>.</p>
</blockquote>
<pre>error_code( int val, const error_category &amp; cat ) noexcept;</pre>
<blockquote>
<p><i>Effects: </i>Constructs an object of type <code>error_code</code>.</p>
<p><i>Postconditions:</i> <code>val_ == val &amp;&amp; cat_ == &amp;cat</code>.</p>
</blockquote>
<pre>template &lt;class <code>ErrorCodeEnum</code>&gt;
error_code(<code> ErrorCodeEnum</code> val ) noexcept;</pre>
<blockquote>
<p><i>Effects: </i>Constructs an object of type <code>error_code</code>.</p>
<p><i>Postconditions:</i> <code>*this == make_error_code( val )</code>.</p>
<p><i>Remarks:</i> This constructor shall not participate in overload
resolution unless <code>is_error_code_enum&lt;ErrorCodeEnum&gt;::value</code> is
<code>true</code>.</p>
</blockquote>
<h3><a name="Class-error_code-modifiers">Class <code>
error_code</code> modifiers</a></h3>
<pre>void assign( int val, const error_category &amp; cat ) noexcept;</pre>
<blockquote>
<p><i>Postconditions:</i> <code>val_ == val &amp;&amp; cat_ == &amp;cat</code>.</p>
</blockquote>
<pre>template&lt;typename <code>ErrorCodeEnum</code>&gt;
error_code &amp; operator=( <code>ErrorCodeEnum</code> val ) noexcept;</pre>
<blockquote>
<p><i>Postconditions:</i> <code>*this == make_error_code( val )</code>.</p>
<p><i>Remarks:</i> This operator shall not participate in overload resolution
unless <code>is_error_code_enum&lt;ErrorCodeEnum&gt;::value</code> is <code>true</code>.</p>
</blockquote>
<pre><code>void clear() noexcept;</code></pre>
<blockquote>
<p><i>postcondition:</i> <code>value() == 0 &amp;&amp; category() ==
system_category()</code></p>
</blockquote>
<h3><a name="Class-error_code-observers">Class <code>
error_code</code> observers</a></h3>
<pre><code>int value() const noexcept;</code></pre>
<blockquote>
<p><i>Returns:</i> <code>val_</code>.</p>
</blockquote>
<pre><code>const error_category &amp; category() const noexcept;</code></pre>
<blockquote>
<p><i>Returns:</i> <code>*cat_</code>.</p>
</blockquote>
<pre>error_condition default_error_condition() const noexcept;</pre>
<blockquote>
<p><i>Returns:</i>&nbsp; <code>category().default_error_condition( value())</code>.</p>
</blockquote>
<pre><code>string message() const;</code></pre>
<blockquote>
<p><i>Returns:</i>&nbsp; <code>category().message( value())</code>.</p>
<p><i>Throws:</i> Nothing.</p>
</blockquote>
<pre>operator unspecified-bool-type() const;</pre>
<blockquote>
<p><i>Returns:</i> if <code>value() != 0</code>, returns a value that will evaluate
<code>true</code> in a boolean context; otherwise, returns a value that will
evaluate <code>false</code> in a boolean context. The value type returned shall
not be convertible to <code>int</code>.</p>
<p><i>Throws:</i> nothing.</p>
<p><i>[Note: </i>This conversion can be used in contexts where a <code>bool</code>
is expected ( e.g., an <code>if</code> condition ); however, implicit conversions
( e.g., to <code>int</code>) that can occur with <code>bool</code> are not
allowed, eliminating some sources of user error. One possible implementation
choice for this type is pointer-to-member. <i>--end note ]</i></p>
</blockquote>
<h2><a name="Class-error_condition">Class <code>error_condition</code></a></h2>
<p>The class <code>error_condition</code> describes an object used to hold
values identifying error conditions. <i>[ Note: </i><code>error_condition</code>
values are portable abstractions, while <code>error_code</code> values are
implementation specific. <i>--end note ]</i></p>
<h3><a name="Class-error_condition-synopsis">Class <code>error_condition</code> synopsis</a></h3>
<blockquote>
<pre>namespace boost
{
namespace system
{
class error_condition
{
public:
// constructors:
error_condition() noexcept;
error_condition( int val, const error_category &amp; cat ) noexcept;
template &lt;class ErrorConditionEnum&gt;
error_condition( errorConditionEnum val ) noexcept;
// modifiers:
void assign( int val, const error_category &amp; cat ) noexcept;
template&lt;typename ErrorConditionEnum&gt;
error_condition &amp; operator=( ErrorConditionEnum val ) noexcept;
void clear() noexcept;
// observers:
int value() const noexcept;
const error_category &amp; category() const noexcept;
string message() const;
operator unspecified-bool-type () const noexcept;
private:
int val_; // <i>exposition only</i>
const error_category * cat_; // <i>exposition only</i>
};
}
}</pre>
</blockquote>
<h3><a name="Class-error_condition-constructors">Class <code>error_condition</code>
constructors</a></h3>
<pre>error_condition() noexcept; </pre>
<blockquote>
<p><i>Effects:</i> Constructs an object of type <code>error_condition</code>.</p>
<p><i>Postconditions:</i> <code>val_ == 0 and cat_ == &amp;generic_category()</code>.</p>
</blockquote>
<pre>error_condition( int val, const error_category &amp; cat ) noexcept;</pre>
<blockquote>
<p><i>Effects: </i>Constructs an object of type error_condition.</p>
<p><i>Postconditions:</i> <code>val_ == val and cat_ == &amp;cat</code>.</p>
</blockquote>
<pre>template &lt;class ErrorConditionEnum&gt;
error_condition( ErrorConditionEnum e ) noexcept;</pre>
<blockquote>
<p><i>Effects:</i> Constructs an object of type <code>error_condition</code>.</p>
<p><i>Postconditions:</i> <code>*this == make_error_condition(e)</code>.</p>
<p><i>Remarks:</i> This constructor shall not participate in overload
resolution unless <code>is_error_condition_enum&lt;ErrorConditionEnum&gt;::value</code>
is <code>true</code>.</p>
</blockquote>
<h3><a name="Class-error_condition-modifiers">Class <code>error_condition</code>
modifiers</a></h3>
<pre>void assign( int val, const error_category &amp; cat ) noexcept; </pre>
<blockquote>
<p><i>Postconditions:</i> <code>val_ == val and cat_ == &amp;cat</code>. </p>
</blockquote>
<pre>template&lt;typename ErrorConditionEnum&gt;
error_condition &amp; operator=( ErrorConditionEnum e ) noexcept;</pre>
<blockquote>
<p><i>Postconditions:</i> <code>*this == make_error_condition( e )</code>.</p>
<p><i>Returns:</i> <code>*this</code>.</p>
<p><i>Remarks:</i> This operator shall not participate in overload resolution
unless <code>is_error_condition_enum&lt;ErrorConditionEnum&gt;::value</code> is
<code>true</code>.</p>
</blockquote>
<pre>void clear() noexcept;</pre>
<blockquote>
<p><i>Postcondition:</i> <code>value() == 0 &amp;&amp; category() == generic_category()</code></p>
</blockquote>
<h3><a name="Class-error_condition-observers">Class <code>error_condition</code>
observers</a></h3>
<pre>int value() const noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>val_</code>.</p>
</blockquote>
<pre>const error_category &amp; category() const noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>*cat_</code>.</p>
</blockquote>
<pre>string message() const;</pre>
<blockquote>
<p><i>Returns:</i> <code>category().message( value() )</code>.</p>
</blockquote>
<pre>operator unspecified-bool-type () const;</pre>
<blockquote>
<p><i>Returns: </i>If <code>value() != 0</code>, returns a value that will
evaluate <code>true</code> in a boolean context; otherwise, returns a value
that will evaluate <code>false</code>. The return type shall not be
convertible to <code>int</code>. </p>
<p><i>Throws:</i> Nothing.</p>
<p><i>&nbsp;[ Note:</i> This conversion can be used in contexts where a <code>bool</code>
is expected ( e.g., an if condition ); however, implicit conversions ( e.g., to
<code>int</code>) that can occur with <code>bool</code> are not allowed,
eliminating some sources of user error. One possible implementation choice for
this type is pointer to member. <i>--end note</i> <i>]</i></p>
</blockquote>
<h2><a name="Non-member-functions">Non-member functions</a></h2>
<pre>bool operator==( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>lhs.category() == rhs.category() &amp;&amp; lhs.value() ==
rhs.value()</code>.</p>
</blockquote>
<pre>bool operator==( const error_code &amp; code, const error_condition &amp; condition ) noexcept;
bool operator==( const error_condition &amp; condition, const error_code &amp; code ) noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>code.category().equivalent( code.value(), condition )<br>
|| condition.category().equivalent( code, condition.value() )</code>.</p>
</blockquote>
<pre>bool operator==( const error_condition &amp; lhs, const error_condition &amp; rhs ) noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>lhs.category() == rhs.category() &amp;&amp; lhs.value() ==
rhs.value()</code>.</p>
</blockquote>
<pre>bool operator!=( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>!(lhs == rhs )</code>.</p>
</blockquote>
<pre>bool operator!=( const error_code &amp; code, const error_condition &amp; condition ) noexcept;
bool operator!=( const error_condition &amp; condition, const error_code &amp; code ) noexcept;</pre>
<blockquote>
<p><i>Returns:</i><code> !( code ==&nbsp; condition )</code>.</p>
</blockquote>
<pre>bool operator!=( const error_condition &amp; lhs, const error_condition &amp; rhs ) noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>!(lhs == rhs )</code>.</p>
</blockquote>
<pre>bool operator&lt;( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>lhs.category() &lt; rhs.category()<br>
&nbsp; || (lhs.category() == rhs.category() &amp;&amp; lhs.value() &lt; rhs.value())</code>.</p>
</blockquote>
<pre>bool operator&lt;( const error_condition &amp; lhs, const error_condition &amp; rhs ) noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>lhs.category() &lt; rhs.category()<br>
&nbsp; || (lhs.category() == rhs.category() &amp;&amp; lhs.value() &lt; rhs.value())</code>.</p>
</blockquote>
<pre>error_code make_error_code( errc::errc_t e ) noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>error_code( e, generic_category())</code>.</p>
</blockquote>
<pre>error_condition make_error_condition( errc::errc_t e ) noexcept;</pre>
<blockquote>
<p><i>Returns:</i> <code>error_condition( static_cast&lt;int&gt;( e ), generic_category())</code>.</p>
</blockquote>
<pre>template &lt;class charT, class traits&gt;
std::basic_ostream&lt;charT,traits&gt;&amp;
operator&lt;&lt;( basic_ostream&lt;charT,traits&gt;&amp; os, const error_code &amp; ec );</pre>
<blockquote>
<p><i>Effects:</i> <code>os &lt;&lt; ec.category().name() &lt;&lt; ':' &lt;&lt; ec.value()</code>.</p>
<p><i>Returns:</i> <code>os</code>.</p>
</blockquote>
<pre>size_t <a name="hash_value">hash_value</a>( const error_code &amp; ec );</pre>
<blockquote>
<p><i>Returns: </i>&nbsp;A hash value representing <code>ec</code>.</p>
</blockquote>
<h2><a name="Function-boost-throws">Function <code>boost::throws()</code></a></h2>
<pre>system::error_code&amp; throws();</pre>
<blockquote>
<p><i>Returns:</i> A <code>system::error_code</code> reference
for use in some user-defined function signature as a &quot;throw on error&quot; tag.</p>
<p><i>Remark:</i> The only valid use for the returned reference is to test its
address for equality or inequality to the address of the reference returned by
another call to throws(). The returned reference itself has been poisoned so
that an attempt to dereference it will fail.</p>
<p>[<i>Example: </i>Example of a function that uses the <code>throws()</code> idiom:</p>
<blockquote>
<pre>int divide(int dividend, int divisor,
boost::system::error_code&amp; ec = boost::throws())
{
if (divisor == 0) // is there an error?
{
if (&amp;ec == &amp;boost::throws()) // throw on error
throw &quot;oops!&quot;; // whatever exception you prefer
ec = error_code(EDOM, generic_category()); // report error via error_code
return 0;
}
if (&amp;ec != &amp;boost::throws()) // error reporting via error_code
ec.clear();
return dividend / divisor;
}</pre>
</blockquote>
<p>&mdash; <i>end Example</i>]</p>
</blockquote>
<h2><a name="Header-system_error">Header &lt;boost/system/system_error.hpp&gt;</a></h2>
<h3><a name="Class-system_error">Class <code>
system_error</code></a></h3>
<p>The class <code>system_error</code> describes an exception object used to
report errors that have an associated <code><a href="#Class-error_code">error_code</a></code>. Such errors typically originate from operating system or other low-level
application program interfaces.</p>
<blockquote>
<pre>namespace boost
{
namespace system
{
class system_error : public std::runtime_error
{
public:
system_error( error_code ec );
system_error( error_code ec, const char * what_arg );
system_error( error_code ec, const std::string &amp; what_arg );
system_error( int ev, const error_category &amp; ecat,
const char * what_arg );
system_error( int ev, const error_category &amp; ecat,
const std::string &amp; what_arg );
system_error( int ev, const error_category &amp; ecat);
const error_code &amp; code() const throw();
const char * what() const throw();
};
}
}</pre>
</blockquote>
<pre>system_error( error_code ec );</pre>
<blockquote>
<p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
<p><i>Postcondition:</i> <code>code() == ec <br>
&nbsp; &amp;&amp; std::strcmp( this-&gt;runtime_error::what(), &quot;&quot; ) == 0</code></p>
</blockquote>
<pre>system_error( error_code ec, const char * what_arg );</pre>
<blockquote>
<p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
<p><i>Postcondition:</i> <code>code() == ec <br>
&nbsp; &amp;&amp; std::strcmp( this-&gt;runtime_error::what(), what_arg ) == 0</code></p>
</blockquote>
<pre>system_error( error_code ec, const std::string &amp; what_arg );</pre>
<blockquote>
<p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
<p><i>Postcondition:</i> <code>code() == ec <br>
&nbsp; &amp;&amp; std::strcmp( this-&gt;runtime_error::what(), what_arg.c_str() ) == 0</code></p>
</blockquote>
<pre>system_error( int ev, const error_category &amp; ecat,
const char * what_arg );</pre>
<blockquote>
<p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
<p><i>Postcondition:</i> <code>code() == error_code( ev, ecat )<br>
&nbsp; &amp;&amp; std::strcmp( this-&gt;runtime_error::what(), what_arg ) == 0</code></p>
</blockquote>
<pre>system_error( int ev, const error_category &amp; ecat,
const std::string &amp; what_arg );</pre>
<blockquote>
<p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
<p><i>Postcondition:</i> <code>code() == error_code( ev, ecat )<br>
&nbsp; &amp;&amp; std::strcmp( this-&gt;runtime_error::what(), what_arg.c_str() ) == 0</code></p>
</blockquote>
<pre>system_error( int ev, const error_category &amp; ecat );</pre>
<blockquote>
<p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
<p><i>Postcondition:</i> <code>code() == error_code( ev, ecat )<br>
&nbsp; &amp;&amp; std::strcmp( this-&gt;runtime_error::what(), &quot;&quot; ) == 0</code></p>
</blockquote>
<pre>const error_code &amp; code() const;</pre>
<blockquote>
<p><i>Returns:</i> <code>ec</code> or <code>error_code( ev, ecat )</code>, from
the constructor, as appropriate.</p>
</blockquote>
<pre>const char * what() const;</pre>
<blockquote>
<p><i>Returns: </i>A string incorporating <code>
this-&gt;runtime_error::what()</code> and <code>
code.message()</code>.</p>
</blockquote>
<hr>
<p>Revised
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->September 07, 2017<!--webbot bot="Timestamp" endspan i-checksum="38006" --> </font>
</p>
<p><EFBFBD> Copyright Beman Dawes, 2006, 2007, 2008, 2013</p>
<p>Distributed under the Boost Software License, Version 1.0. See
<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
</body>
</html>

View File

@@ -0,0 +1,6 @@
<style>
*:not(pre)>code { background: none; color: #600000; }
:not(pre):not([class^=L])>code { background: none; color: #600000; }
</style>

27
doc/system.adoc Normal file
View File

@@ -0,0 +1,27 @@
////
Copyright 2018 Peter Dimov
Distributed under the Boost Software License, Version 1.0.
See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt
////
# Boost.System: Extensible Error Reporting
Beman Dawes, Christopher Kohlhoff, Peter Dimov
:toc: left
:toclevels: 3
:idprefix:
:docinfo: private-footer
:leveloffset: +1
include::system/introduction.adoc[]
include::system/changes.adoc[]
include::system/rationale.adoc[]
include::system/reference.adoc[]
include::system/history.adoc[]
include::system/acknowledgements.adoc[]
include::system/copyright.adoc[]
:leveloffset: -1

View File

@@ -0,0 +1,19 @@
////
Copyright 2003-2017 Beman Dawes
Distributed under the Boost Software License, Version 1.0.
See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt
////
[#acknowledgments]
# Acknowledgments
:idprefix: ack_
Christopher Kohlhoff and Peter Dimov made important contributions to the
design. Comments and suggestions were also received from Pavel Vozenilek,
Gennaro Prota, Dave Abrahams, Jeff Garland, Iain Hanson, Oliver Kowalke, and
Oleg Abrosimov. Christopher Kohlhoff suggested several improvements to the
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2066.html[N2066]
paper. Johan Nilsson's comments led to several of the refinements in N2066.

66
doc/system/changes.adoc Normal file
View File

@@ -0,0 +1,66 @@
////
Copyright 2018 Peter Dimov
Distributed under the Boost Software License, Version 1.0.
See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt
////
[#changes]
# Revision History
:idprefix:
## Changes in Boost 1.74
* `operator bool()` now returns `failed()` instead of `value() != 0`.
## Changes in Boost 1.69
* Boost.System is now header-only. A stub library is still built for
compatibility, but linking to it is no longer necessary.
* Even more functions have been marked `constexpr`.
* The destructor of `error_category` is now protected and no longer
virtual. This is a _potentially breaking change_ but its impact
is expected to be limited.
* `error_category` now has a constructor that accepts a 64 bit identifier,
enabling distinct category objects to compare equal.
* The constructors of `error_category` are now protected.
* A non-allocating, nonthrowing overload of `message` has been added.
* A virtual function `failed` has been added, allowing categories for
which success is not synonymous with 0.
* The deprecated `boost::system::throws` object has been removed.
* `boost::throws()` is now deprecated and its use is discouraged.
* The constructor of `system_error` taking a single `error_code` argument
is now explicit.
* `system_error::code()` now returns by value.
## Changes in Boost 1.68
On a {cpp}14 compiler, many Boost.System functions and member functions
are now `constexpr`, and `error_code` and `error_condition` are literal
classes.
In addition to enabling use in constant expressions (and `constexpr`
functions), this significantly improves the quality of the generated code.
As a result of this change, however, now using Boost.System from {cpp}14
or {cpp}17 code requires that the library be also built with {cpp}14 or
above. This is the default on GCC 6 and newer, but not on GCC 5 or Clang.
One can build Boost for {cpp}14 by passing the `cxxstd=14` option to `b2`.
(Previous versions allowed code built against any {cpp} standard to link
with Boost.System built against any {cpp} standard. In 1.68, code using
any {cpp} standard can link with Boost.System built with {cpp}14 or above,
but if Boost.System is built with {cpp}11 or below, only code also built
with {cpp}11 and below can link to it successfully.)
## Changes in Boost 1.65
On a {cpp}11 compiler, Boost.System now provides implicit conversions
from `boost::system::error_category`, `error_code`, and `error_condition`
to their standard equivalents from `<system_error>`.
This allows libraries to expose a {cpp}11 interface and report errors
via `std::error_code` even when using Boost.System, directly or through a
dependency such as Boost.ASIO.

19
doc/system/copyright.adoc Normal file
View File

@@ -0,0 +1,19 @@
////
Copyright 2018 Peter Dimov
Distributed under the Boost Software License, Version 1.0.
See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt
////
[#copyright]
# Copyright and License
:idprefix:
This documentation is
* Copyright 2003-2017 Beman Dawes
* Copyright 2018 Peter Dimov
and is distributed under the http://www.boost.org/LICENSE_1_0.txt[Boost Software License, Version 1.0].

30
doc/system/history.adoc Normal file
View File

@@ -0,0 +1,30 @@
////
Copyright 2003-2017 Beman Dawes
Distributed under the Boost Software License, Version 1.0.
See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt
////
[#history]
# History
:idprefix: history_
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1975.html[N1975],
Filesystem Library Proposal for TR2, accepted for Library Technical
Report 2 (TR2) at the Berlin meeting, included additional components to
supplement the Standard Library's Diagnostics clause. Since then, these error
reporting components have received wider public scrutiny and enhancements have
been made to the design. The enhanced version has been used by
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2054.pdf[N2054],
Networking Library Proposal for TR2, demonstrating that these error reporting
components are useful beyond the original Filesystem Library.
The original proposal viewed error categories as a binary choice between
`errno` (i.e. POSIX-style) and the native operating system's error
codes. The proposed components now allow as many additional error categories as
are needed by either implementations or by users. The need to support additional
error categories, for example, occurs in some networking library implementations
because they are built on top of the POSIX `getaddrinfo` API that
uses error codes not based on `errno`.

View File

@@ -0,0 +1,50 @@
////
Copyright 2003-2017 Beman Dawes
Copyright 2018 Peter Dimov
Distributed under the Boost Software License, Version 1.0.
See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt
////
[#introduction]
# 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.
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`.
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.
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.
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.
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.

27
doc/system/rationale.adoc Normal file
View File

@@ -0,0 +1,27 @@
////
Copyright 2003-2017 Beman Dawes
Distributed under the Boost Software License, Version 1.0.
See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt
////
[#rationale]
# Design Rationale
:idprefix: rationale_
`error_code` and `error_condition` are designed as value types so
they can be copied without slicing and do not require heap allocation, but
still have polymorphic behavior based on the error category. This is achieved
by abstract base class `error_category` supplying the polymorphic behavior,
and `error_code` and `error_condition` containing a pointer to an object of a
type derived from `error_category`.
Many of the detailed design decisions were driven by the requirements that
users to be able to add additional error categories, and that it be no more
difficult to write portable code than system-specific code.
The `operator<<` overload for `error_code` eliminates a misleading conversion to
`bool` in code like `cout << ec`, where `ec` is of type `error_code`. It is also
useful in its own right.

970
doc/system/reference.adoc Normal file
View File

@@ -0,0 +1,970 @@
////
Copyright 2003-2017 Beman Dawes
Copyright 2018 Peter Dimov
Distributed under the Boost Software License, Version 1.0.
See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt
////
[#reference]
# Reference
:idprefix: ref_
## Use of {cpp}11 and {cpp}14 Features
The library is documented to use several {cpp}11 and {cpp}14 features,
including `noexcept`, explicit conversion operators and `constexpr`. The
actual implementation uses {cpp}11 and {cpp}14 features only when they are
available, and otherwise falls back on {cpp}03 features.
## Macros
When `BOOST_SYSTEM_ENABLE_DEPRECATED` is defined, the library provides
deprecated features for compatibility. These features are bound to eventually
disappear.
When `BOOST_SYSTEM_USE_UTF8` is defined, on Windows the library returns
UTF-8 messages using code page `CP_UTF8` instead of the default `CP_ACP`.
This macro has no effect on POSIX.
## Deprecated Names
In the process of adding Boost.System to the {cpp}11 standard library, the
{cpp} committee changed some names. To ease transition, Boost.System deprecates
the old names, but will provide them when the macro `BOOST_SYSTEM_ENABLE_DEPRECATED` is defined.
|===
|Old usage, now deprecated|Replacement
|`get_generic_category()`|`generic_category()`
|`get_system_category()`|`system_category()`
|`namespace posix`|`namespace errc`
|`namespace posix_error`|`namespace errc`
|`get_posix_category()`|`generic_category()`
|`posix_category`|`generic_category()`
|`errno_ecat`|`generic_category()`
|`native_ecat`|`system_category()`
|===
## <boost/system/error_code.hpp>
### Synopsis
```
namespace boost {
namespace system {
class error_category;
constexpr const error_category & system_category() noexcept;
constexpr const error_category & generic_category() noexcept;
class error_code;
class error_condition;
// "Concept" helpers
template<class T>
struct is_error_code_enum { static const bool value = false; };
template<class T>
struct is_error_condition_enum { static const bool value = false; };
// generic error conditions
namespace errc {
enum errc_t
{
success = 0,
address_family_not_supported, //EAFNOSUPPORT
address_in_use, //EADDRINUSE
address_not_available, //EADDRNOTAVAIL
already_connected, //EISCONN
argument_list_too_long, //E2BIG
argument_out_of_domain, //EDOM
bad_address, //EFAULT
bad_file_descriptor, //EBADF
bad_message, //EBADMSG
broken_pipe, //EPIPE
connection_aborted, //ECONNABORTED
connection_already_in_progress, //EALREADY
connection_refused, //ECONNREFUSED
connection_reset, //ECONNRESET
cross_device_link, //EXDEV
destination_address_required, //EDESTADDRREQ
device_or_resource_busy, //EBUSY
directory_not_empty, //ENOTEMPTY
executable_format_error, //ENOEXEC
file_exists, //EEXIST
file_too_large, //EFBIG
filename_too_long, //ENAMETOOLONG
function_not_supported, //ENOSYS
host_unreachable, //EHOSTUNREACH
identifier_removed, //EIDRM
illegal_byte_sequence, //EILSEQ
inappropriate_io_control_operation, //ENOTTY
interrupted, //EINTR
invalid_argument, //EINVAL
invalid_seek, //ESPIPE
io_error, //EIO
is_a_directory, //EISDIR
message_size, //EMSGSIZE
network_down, //ENETDOWN
network_reset, //ENETRESET
network_unreachable, //ENETUNREACH
no_buffer_space, //ENOBUFS
no_child_process, //ECHILD
no_link, //ENOLINK
no_lock_available, //ENOLCK
no_message_available, //ENODATA
no_message, //ENOMSG
no_protocol_option, //ENOPROTOOPT
no_space_on_device, //ENOSPC
no_stream_resources, //ENOSR
no_such_device_or_address, //ENXIO
no_such_device, //ENODEV
no_such_file_or_directory, //ENOENT
no_such_process, //ESRCH
not_a_directory, //ENOTDIR
not_a_socket, //ENOTSOCK
not_a_stream, //ENOSTR
not_connected, //ENOTCONN
not_enough_memory, //ENOMEM
not_supported, //ENOTSUP
operation_canceled, //ECANCELED
operation_in_progress, //EINPROGRESS
operation_not_permitted, //EPERM
operation_not_supported, //EOPNOTSUPP
operation_would_block, //EWOULDBLOCK
owner_dead, //EOWNERDEAD
permission_denied, //EACCES
protocol_error, //EPROTO
protocol_not_supported, //EPROTONOSUPPORT
read_only_file_system, //EROFS
resource_deadlock_would_occur, //EDEADLK
resource_unavailable_try_again, //EAGAIN
result_out_of_range, //ERANGE
state_not_recoverable, //ENOTRECOVERABLE
stream_timeout, //ETIME
text_file_busy, //ETXTBSY
timed_out, //ETIMEDOUT
too_many_files_open_in_system, //ENFILE
too_many_files_open, //EMFILE
too_many_links, //EMLINK
too_many_synbolic_link_levels, //ELOOP
value_too_large, //EOVERFLOW
wrong_protocol_type //EPROTOTYPE
};
} // namespace errc
template<> struct is_error_condition_enum<errc::errc_t>
{ static const bool value = true; };
// non-member functions
constexpr bool operator==( const error_code & lhs,
const error_code & rhs ) noexcept;
bool operator==( const error_code & code,
const error_condition & condition ) noexcept;
bool operator==( const error_condition & condition,
const error_code & code ) noexcept;
constexpr bool operator==( const error_condition & lhs,
const error_condition & rhs ) noexcept;
constexpr bool operator!=( const error_code & lhs,
const error_code & rhs ) noexcept;
bool operator!=( const error_code & code,
const error_condition & condition ) noexcept;
bool operator!=( const error_condition & condition,
const error_code & code ) noexcept;
constexpr bool operator!=( const error_condition & lhs,
const error_condition & rhs ) noexcept;
constexpr bool operator<( const error_code & lhs,
const error_code & rhs ) noexcept;
constexpr bool operator<( const error_condition & lhs,
const error_condition & rhs ) noexcept;
constexpr error_code make_error_code( errc::errc_t e ) noexcept;
constexpr error_condition make_error_condition( errc::errc_t e ) noexcept;
template <class charT, class traits>
std::basic_ostream<charT, traits>&
operator<<( basic_ostream<charT, traits>& os, const error_code & ec );
std::size_t hash_value( const error_code & ec );
} // namespace system
} // namespace boost
```
The value of each `errc_t` constant is the same as the value of the `<cerrno>`
macro shown in the above synopsis.
Users may specialize `is_error_code_enum` and `is_error_condition_enum`
templates to indicate that a type is eligible for class `error_code` and
`error_condition` automatic conversions respectively.
### Class error_category
The class `error_category` defines the base class for types used
to identify the source and encoding of a particular category of error code.
Classes may be derived from `error_category` to support categories of
errors in addition to those defined in Boost.System.
```
namespace boost {
namespace system {
class error_category
{
public: // noncopyable
error_category( error_category const & ) = delete;
error_category& operator=( error_category const & ) = delete;
protected:
~error_category() = default;
constexpr error_category() noexcept;
explicit constexpr error_category( unsigned long long id ) noexcept;
public:
virtual const char * name() const noexcept = 0;
virtual error_condition default_error_condition( int ev ) const noexcept;
virtual bool equivalent( int code, const error_condition & condition )
const noexcept;
virtual bool equivalent( const error_code & code, int condition )
const noexcept;
virtual std::string message( int ev ) const = 0;
virtual char const * message( int ev, char * buffer, std::size_t len )
const noexcept;
virtual bool failed( int ev ) const noexcept;
constexpr bool operator==( const error_category & rhs ) const noexcept;
constexpr bool operator!=( const error_category & rhs ) const noexcept;
constexpr bool operator< ( const error_category & rhs ) const noexcept;
operator std::error_category const & () const;
private:
unsigned long long id_; // exposition only
};
}
}
```
#### Constructors
```
constexpr error_category() noexcept;
```
[none]
* {blank}
+
Effects: :: Initializes `id_` to 0.
Remarks: :: Since equivalence for categories that do not have an identifier is
based on comparing object addresses, a user-defined derived category of type
`C` that uses this constructor should ensure that only one object of type `C`
exists in the program.
```
explicit constexpr error_category( unsigned long long id ) noexcept;
```
[none]
* {blank}
+
Effects: :: Initializes `id_` to `id`.
Remarks: :: User-defined derived categories that use this constructor are considered
equivalent when their identifiers match. Therefore, those categories may have more
than one instance existing in a program, but to minimize the possibility of
collision, their identifiers must be randomly chosen (at the time the category
is implemented, not at runtime). One way of generating a 64 bit random identifier
is https://www.random.org/cgi-bin/randbyte?nbytes=8&format=h.
#### Virtuals
```
virtual const char * name() const noexcept = 0;
```
[none]
* {blank}
+
Returns: :: In derived classes, a character literal naming the error category.
```
virtual error_condition default_error_condition( int ev ) const noexcept;
```
[none]
* {blank}
+
Returns: ::
- In derived classes, an error condition corresponding to `ev`.
The returned error condition will typically come from the generic category.
- In the default implementation, `error_condition( ev, *this )`.
```
virtual bool equivalent( int code, const error_condition & condition )
const noexcept;
```
[none]
* {blank}
+
Returns: ::
- In derived classes, `true` when `error_code( code, *this )` is equivalent to `condition`.
- In the default implementation, `default_error_condition( code ) == condition`.
```
virtual bool equivalent( const error_code & code, int condition )
const noexcept;
```
[none]
* {blank}
+
Returns: ::
- In derived classes, `true` when `code` is equivalent to `error_condition( condition, *this )`.
- In the default implementation, `*this == code.category() && code.value() == condition`.
```
virtual std::string message( int ev ) const = 0;
```
[none]
* {blank}
+
Returns: :: In derived classes, a string that describes the error denoted by `ev`.
```
virtual char const * message( int ev, char * buffer, std::size_t len )
const noexcept;
```
[none]
* {blank}
+
Effects: ::
** Derived classes should either
*** return a pointer to a character literal describing the error denoted by `ev`, or
*** copy a string describing the error into `buffer`, truncating it to `len-1`
characters and storing a null terminator, and return `buffer`. If `len` is 0,
nothing is copied, but the function still returns `buffer`. Note that
when `len` is 0, `buffer` may be `nullptr`.
** The default implementation calls `message(ev)` and copies the result into
`buffer`, truncating it to `len-1` characters and storing a null terminator.
If `len` is 0, copies nothing. Returns `buffer`. If `message(ev)` throws an
exception, the string `"Message text unavailable"` is used.
Example: ::
+
```
const char* my_category::message(int ev, char* buffer, size_t len) const noexcept
{
switch(ev)
{
case 0: return "no error";
case 1: return "voltage out of range";
case 2: return "impedance mismatch";
case 31:
case 32:
case 33:
std::snprintf(buffer, len, "component %d failure", ev-30);
return buffer;
default:
std::snprintf(buffer, len, "unknown error %d", ev);
return buffer;
}
}
```
```
virtual bool failed( int ev ) const noexcept;
```
[none]
* {blank}
+
Returns: ::
- In derived classes, `true` when `ev` represents a failure.
- In the default implementation, `ev != 0`.
Remarks: ::
All calls to this function with the same `ev` must return the same value.
#### Nonvirtuals
```
constexpr bool operator==( const error_category & rhs ) const noexcept;
```
[none]
* {blank}
+
Returns: :: `rhs.id_ == 0? this == &rhs: id_ == rhs.id_`.
Remarks: :: Two category objects are considered equivalent when they have matching
nonzero identifiers, or are the same object.
```
constexpr bool operator!=( const error_category & rhs ) const noexcept;
```
[none]
* {blank}
+
Returns: :: `!( *this == rhs )`.
```
constexpr bool operator< ( const error_category & rhs ) const noexcept;
```
[none]
* {blank}
+
Returns: ::
** If `id_ < rhs.id_`, `true`;
** Otherwise, if `id_ > rhs.id_`, `false`;
** Otherwise, if `rhs.id_ != 0`, `false`;
** Otherwise, `std::less<error_category const *>()( this, &rhs )`.
```
operator std::error_category const & () const;
```
[none]
* {blank}
+
Returns: :: A reference to an `std::error_category` object corresponding
to `*this`.
### Predefined Categories
```
constexpr const error_category & system_category() noexcept;
```
[none]
* {blank}
+
Returns: :: A reference to an `error_category` object identifying errors
originating from the operating system.
```
constexpr const error_category & generic_category() noexcept;
```
[none]
* {blank}
+
Returns: :: A reference to an `error_category` object identifying portable
error conditions.
### Class error_code
The class `error_code` describes an object used to hold error code
values, such as those originating from the operating system or other
low-level application program interfaces. It's an adjunct to error reporting
by exception.
```
namespace boost {
namespace system {
class error_code {
public:
// constructors:
constexpr error_code() noexcept;
constexpr error_code( int val, const error_category & cat ) noexcept;
template <class ErrorCodeEnum>
constexpr error_code( ErrorCodeEnum e ) noexcept;
// modifiers:
constexpr void assign( int val, const error_category & cat ) noexcept;
template<typename ErrorCodeEnum>
constexpr error_code & operator=( ErrorCodeEnum e ) noexcept;
constexpr void clear() noexcept;
// observers:
constexpr int value() const noexcept;
constexpr const error_category & category() const noexcept;
error_condition default_error_condition() const noexcept;
std::string message() const;
char const * message( char * buffer, std::size_t len ) const noexcept;
constexpr bool failed() const noexcept;
constexpr explicit operator bool() const noexcept;
operator std::error_code() const;
private: // exposition only
int val_;
const error_category * cat_;
};
}
}
```
#### Constructors
```
constexpr error_code() noexcept;
```
[none]
* {blank}
+
Ensures: :: `val_ == 0`; `*cat_ == system_category()`.
```
constexpr error_code( int val, const error_category & cat ) noexcept;
```
[none]
* {blank}
+
Ensures: :: `val_ == val`; `cat_ == &cat`.
```
template <class ErrorCodeEnum>
constexpr error_code( ErrorCodeEnum e ) noexcept;
```
[none]
* {blank}
+
Ensures: :: `*this == make_error_code( e )`.
Remarks: :: This constructor is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.
#### Modifiers
```
constexpr void assign( int val, const error_category & cat ) noexcept;
```
[none]
* {blank}
+
Ensures: :: `val_ == val`; `cat_ == &cat`.
```
template<typename ErrorCodeEnum>
constexpr error_code & operator=( ErrorCodeEnum e ) noexcept;
```
[none]
* {blank}
+
Ensures: :: `*this == make_error_code( e )`.
Remarks: :: This operator is only enabled when `is_error_code_enum<ErrorCodeEnum>::value` is `true`.
```
constexpr void clear() noexcept;
```
[none]
* {blank}
+
Ensures: ::
`val_ == 0`; `*cat_ == system_category()`.
#### Observers
```
constexpr int value() const noexcept;
```
[none]
* {blank}
+
Returns: :: `val_`.
```
constexpr const error_category & category() const noexcept;
```
[none]
* {blank}
+
Returns: :: `*cat_`.
```
error_condition default_error_condition() const noexcept;
```
[none]
* {blank}
+
Returns: :: `cat_\->default_error_condition( val_ )`.
```
std::string message() const;
```
[none]
* {blank}
+
Returns: :: `cat_\->message( val_ )`.
```
char const * message( char * buffer, std::size_t len ) const noexcept;
```
[none]
* {blank}
+
Returns: :: `cat_\->message( val_, buffer, len )`.
```
constexpr bool failed() const noexcept;
```
[none]
* {blank}
+
Returns: :: `cat_\->failed( val_ )`.
```
constexpr explicit operator bool() const noexcept;
```
[none]
* {blank}
+
Returns: :: `failed()`.
```
operator std::error_code() const;
```
[none]
* {blank}
+
Returns: ::
`std::error_code( val_, *cat_ )`.
### Class error_condition
```
namespace boost {
namespace system {
class error_condition {
public:
// constructors:
constexpr error_condition() noexcept;
constexpr error_condition( int val, const error_category & cat ) noexcept;
template <class ErrorConditionEnum>
constexpr error_condition( ErrorConditionEnum e ) noexcept;
// modifiers:
constexpr void assign( int val, const error_category & cat ) noexcept;
template<typename ErrorConditionEnum>
constexpr error_condition & operator=( ErrorConditionEnum e ) noexcept;
constexpr void clear() noexcept;
// observers:
constexpr int value() const noexcept;
constexpr const error_category & category() const noexcept;
std::string message() const;
char const * message( char * buffer, std::size_t len ) const noexcept;
constexpr bool failed() const noexcept;
constexpr explicit operator bool() const noexcept;
operator std::error_condition() const;
private: // exposition only
int val_;
const error_category * cat_;
};
}
}
```
#### Constructors
```
constexpr error_condition() noexcept;
```
[none]
* {blank}
+
Ensures: :: `val_ == 0`; `*cat_ == generic_category()`.
```
constexpr error_condition( int val, const error_category & cat ) noexcept;
```
[none]
* {blank}
+
Ensures: :: `val_ == val`; `cat_ == &cat`.
```
template <class ErrorConditionEnum>
constexpr error_condition( ErrorConditionEnum e ) noexcept;
```
[none]
* {blank}
+
Ensures: :: `*this == make_error_condition( e )`.
Remarks: ::
This constructor is only enabled when `is_error_condition_enum<ErrorConditionEnum>::value` is `true`.
#### Modifiers
```
constexpr void assign( int val, const error_category & cat ) noexcept;
```
[none]
* {blank}
+
Ensures: :: `val_ == val`; `cat_ == &cat`.
```
template <class ErrorConditionEnum>
constexpr error_condition & operator=( ErrorConditionEnum e ) noexcept;
```
[none]
* {blank}
+
Ensures: :: `*this == make_error_condition( e )`.
Remarks: :: This operator is only enabled when `is_error_condition_enum<ErrorConditionEnum>::value` is `true`.
```
constexpr void clear() noexcept;
```
[none]
* {blank}
+
Ensures: ::
`val_ == 0`; `*cat_ == generic_category()`.
#### Observers
```
constexpr int value() const noexcept;
```
[none]
* {blank}
+
Returns: :: `val_`.
```
constexpr const error_category & category() const noexcept;
```
[none]
* {blank}
+
Returns: :: `*cat_`.
```
std::string message() const;
```
[none]
* {blank}
+
Returns: :: `cat_\->message( val_ )`.
```
char const * message( char * buffer, std::size_t len ) const noexcept;
```
[none]
* {blank}
+
Returns: :: `cat_\->message( val_, buffer, len )`.
```
constexpr bool failed() const noexcept;
```
[none]
* {blank}
+
Returns: :: `cat_\->failed( val_ )`.
```
constexpr explicit operator bool() const noexcept;
```
[none]
* {blank}
+
Returns: :: `failed()`.
```
operator std::error_condition() const;
```
[none]
* {blank}
+
Returns: ::
`std::error_condition( val_, *cat_ )`.
### Nonmember functions
```
constexpr bool operator==( const error_code & lhs,
const error_code & rhs ) noexcept;
constexpr bool operator==( const error_condition & lhs,
const error_condition & rhs ) noexcept;
```
[none]
* {blank}
+
Returns: :: `lhs.value() == rhs.value() && lhs.category() == rhs.category()`.
```
bool operator==( const error_code & code,
const error_condition & condition ) noexcept;
bool operator==( const error_condition & condition,
const error_code & code ) noexcept;
```
[none]
* {blank}
+
Returns: :: `code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() )`.
```
constexpr bool operator!=( const error_code & lhs,
const error_code & rhs ) noexcept;
constexpr bool operator!=( const error_condition & lhs,
const error_condition & rhs ) noexcept;
bool operator!=( const error_code & code,
const error_condition & condition ) noexcept;
bool operator!=( const error_condition & condition,
const error_code & code ) noexcept;
```
[none]
* {blank}
+
Returns: :: `!( lhs == rhs )`.
```
constexpr bool operator<( const error_code & lhs,
const error_code & rhs ) noexcept;
constexpr bool operator<( const error_condition & lhs,
const error_condition & rhs ) noexcept;
```
[none]
* {blank}
+
Returns: :: `lhs.category() < rhs.category() || ( lhs.category() == rhs.category() && lhs.value() < rhs.value() )`.
```
constexpr error_code make_error_code( errc::errc_t e ) noexcept;
```
[none]
* {blank}
+
Returns: :: `error_code( e, generic_category() )`.
```
constexpr error_condition make_error_condition( errc::errc_t e ) noexcept;
```
[none]
* {blank}
+
Returns: :: `error_condition( e, generic_category() )`.
```
template <class charT, class traits>
std::basic_ostream<charT, traits>&
operator<<( basic_ostream<charT, traits>& os, const error_code & ec );
```
[none]
* {blank}
+
Effects: :: `os << ec.category().name() << ':' << ec.value()`.
Returns: :: `os`.
```
std::size_t hash_value( const error_code & ec );
```
[none]
* {blank}
+
Returns: ::
A hash value representing `ec`.
## <boost/system/system_error.hpp>
### Class system_error
The class `system_error` describes an exception object used to
report errors that have an associated `error_code`. Such errors
typically originate from operating system or other low-level
application program interfaces.
```
namespace boost
{
namespace system
{
class system_error: public std::runtime_error
{
public:
explicit system_error( error_code ec );
system_error( error_code ec, const char * what_arg );
system_error( error_code ec, const std::string & what_arg );
system_error( int ev, const error_category & ecat );
system_error( int ev, const error_category & ecat,
const char * what_arg );
system_error( int ev, const error_category & ecat,
const std::string & what_arg );
error_code code() const noexcept;
const char * what() const noexcept;
};
}
}
```
#### Constructors
```
explicit system_error( error_code ec );
system_error( error_code ec, const char * what_arg );
system_error( error_code ec, const std::string & what_arg );
```
[none]
* {blank}
+
Ensures: :: `code() == ec`.
```
system_error( int ev, const error_category & ecat,
const char * what_arg );
system_error( int ev, const error_category & ecat,
const std::string & what_arg );
system_error( int ev, const error_category & ecat );
```
[none]
* {blank}
+
Ensures: ::
`code() == error_code( ev, ecat )`.
#### Observers
```
error_code code() const noexcept;
```
[none]
* {blank}
+
Returns: :: `ec` or `error_code( ev, ecat )`, from the constructor, as appropriate.
```
const char * what() const noexcept;
```
[none]
* {blank}
+
Returns: :: A null-terminated character string incorporating the arguments supplied
in the constructor, typically of the form `what_arg + ": " + code.message()`.

View File

@@ -22,6 +22,11 @@
# undef BOOST_SYSTEM_HAS_SYSTEM_ERROR
#endif
#if defined(BOOST_NO_CXX11_HDR_MUTEX)
// Required for thread-safe map manipulation
# undef BOOST_SYSTEM_HAS_SYSTEM_ERROR
#endif
// BOOST_SYSTEM_NOEXCEPT
// Retained for backward compatibility
@@ -43,15 +48,4 @@
# define BOOST_SYSTEM_CONSTEXPR
#endif
// BOOST_SYSTEM_REQUIRE_CONST_INIT
#define BOOST_SYSTEM_REQUIRE_CONST_INIT
#if defined(__has_cpp_attribute)
#if __has_cpp_attribute(clang::require_constant_initialization)
# undef BOOST_SYSTEM_REQUIRE_CONST_INIT
# define BOOST_SYSTEM_REQUIRE_CONST_INIT [[clang::require_constant_initialization]]
#endif
#endif
#endif // BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED

View File

@@ -50,6 +50,11 @@ inline std::string generic_error_category_message( int ev )
# if defined( BOOST_MSVC )
# pragma warning( push )
# pragma warning( disable: 4996 )
# elif defined(__clang__) && defined(__has_warning)
# pragma clang diagnostic push
# if __has_warning("-Wdeprecated-declarations")
# pragma clang diagnostic ignored "-Wdeprecated-declarations"
# endif
# endif
inline std::string generic_error_category_message( int ev )
@@ -83,6 +88,8 @@ inline char const * generic_error_category_message( int ev, char * buffer, std::
# if defined( BOOST_MSVC )
# pragma warning( pop )
# elif defined(__clang__) && defined(__has_warning)
# pragma clang diagnostic pop
# endif
#endif

View File

@@ -10,6 +10,7 @@
#include <system_error>
#include <map>
#include <memory>
#include <mutex>
//
@@ -30,8 +31,20 @@ private:
public:
explicit std_category( boost::system::error_category const * pc ): pc_( pc )
explicit std_category( boost::system::error_category const * pc, unsigned id ): pc_( pc )
{
if( id != 0 )
{
#if defined(_MSC_VER) && defined(_CPPLIB_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
// Poking into the protected _Addr member of std::error_category
// is not a particularly good programming practice, but what can
// you do
_Addr = id;
#endif
}
}
virtual const char * name() const BOOST_NOEXCEPT
@@ -53,24 +66,52 @@ public:
virtual bool equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT;
};
#if !defined(__SUNPRO_CC) // trailing __global is not supported
inline std::error_category const & to_std_category( boost::system::error_category const & cat ) BOOST_SYMBOL_VISIBLE;
#endif
struct cat_ptr_less
{
bool operator()( boost::system::error_category const * p1, boost::system::error_category const * p2 ) const BOOST_NOEXCEPT
{
return *p1 < *p2;
}
};
inline std::error_category const & to_std_category( boost::system::error_category const & cat )
{
typedef std::map< boost::system::error_category const *, std::unique_ptr<std_category> > map_type;
static map_type map_;
map_type::iterator i = map_.find( &cat );
if( i == map_.end() )
if( cat == boost::system::system_category() )
{
std::unique_ptr<std_category> p( new std_category( &cat ) );
std::pair<map_type::iterator, bool> r = map_.insert( map_type::value_type( &cat, std::move( p ) ) );
i = r.first;
static const std_category system_instance( &cat, 0x1F4D7 );
return system_instance;
}
else if( cat == boost::system::generic_category() )
{
static const std_category generic_instance( &cat, 0x1F4D3 );
return generic_instance;
}
else
{
typedef std::map< boost::system::error_category const *, std::unique_ptr<std_category>, cat_ptr_less > map_type;
return *i->second;
static map_type map_;
static std::mutex map_mx_;
std::lock_guard<std::mutex> guard( map_mx_ );
map_type::iterator i = map_.find( &cat );
if( i == map_.end() )
{
std::unique_ptr<std_category> p( new std_category( &cat, 0 ) );
std::pair<map_type::iterator, bool> r = map_.insert( map_type::value_type( &cat, std::move( p ) ) );
i = r.first;
}
return *i->second;
}
}
inline bool std_category::equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT

View File

@@ -55,6 +55,19 @@ inline char const * unknown_message_win32( int ev, char * buffer, std::size_t le
#endif
inline boost::winapi::UINT_ message_cp_win32()
{
#if defined(BOOST_SYSTEM_USE_UTF8)
return boost::winapi::CP_UTF8_;
#else
return boost::winapi::CP_ACP_;
#endif
}
inline char const * system_category_message_win32( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
{
if( len == 0 )
@@ -68,42 +81,60 @@ inline char const * system_category_message_win32( int ev, char * buffer, std::s
return buffer;
}
#if defined(__GNUC__)
# define BOOST_SYSTEM_ALLOCA __builtin_alloca
#else
# define BOOST_SYSTEM_ALLOCA _alloca
boost::winapi::UINT_ const code_page = message_cp_win32();
int r = 0;
#if !defined(BOOST_NO_ANSI_APIS)
if( code_page == boost::winapi::CP_ACP_ )
{
using namespace boost::winapi;
DWORD_ retval = boost::winapi::FormatMessageA(
FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
NULL,
ev,
MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
buffer,
static_cast<DWORD_>( len ),
NULL
);
r = static_cast<int>( retval );
}
else
#endif
wchar_t * wbuffer = static_cast<wchar_t*>( BOOST_SYSTEM_ALLOCA( len * sizeof( wchar_t ) ) );
#undef BOOST_SYSTEM_ALLOCA
using namespace boost::winapi;
DWORD_ retval = boost::winapi::FormatMessageW(
FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
NULL,
ev,
MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
wbuffer,
static_cast<DWORD_>( len ),
NULL
);
if( retval == 0 )
{
return unknown_message_win32( ev, buffer, len );
}
using namespace boost::winapi;
int r = boost::winapi::WideCharToMultiByte( CP_ACP_, 0, wbuffer, -1, buffer, static_cast<int>( len ), NULL, NULL );
wchar_t * lpMsgBuf = 0;
DWORD_ retval = boost::winapi::FormatMessageW(
FORMAT_MESSAGE_ALLOCATE_BUFFER_ | FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
NULL,
ev,
MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
(LPWSTR_) &lpMsgBuf,
0,
NULL
);
if( retval != 0 )
{
r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, buffer, static_cast<int>( len ), NULL, NULL );
boost::winapi::LocalFree( lpMsgBuf );
if ( r != 0 ) --r; // exclude null terminator
}
}
if( r == 0 )
{
return unknown_message_win32( ev, buffer, len );
}
--r; // exclude null terminator
while( r > 0 && ( buffer[ r-1 ] == '\n' || buffer[ r-1 ] == '\r' ) )
{
buffer[ --r ] = 0;
@@ -155,8 +186,11 @@ inline std::string system_category_message_win32( int ev )
}
local_free lf_ = { lpMsgBuf };
(void)lf_;
int r = boost::winapi::WideCharToMultiByte( CP_ACP_, 0, lpMsgBuf, -1, 0, 0, NULL, NULL );
UINT_ const code_page = message_cp_win32();
int r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, 0, 0, NULL, NULL );
if( r == 0 )
{
@@ -165,7 +199,7 @@ inline std::string system_category_message_win32( int ev )
std::string buffer( r, char() );
r = boost::winapi::WideCharToMultiByte( CP_ACP_, 0, lpMsgBuf, -1, &buffer[0], r, NULL, NULL );
r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, &buffer[0], r, NULL, NULL );
if( r == 0 )
{
@@ -230,6 +264,7 @@ inline error_condition system_category_default_error_condition_win32( int ev ) B
case ERROR_CANTOPEN_: return make_error_condition( io_error );
case ERROR_CANTREAD_: return make_error_condition( io_error );
case ERROR_CANTWRITE_: return make_error_condition( io_error );
case ERROR_CONNECTION_ABORTED_: return make_error_condition( connection_aborted );
case ERROR_CURRENT_DIRECTORY_: return make_error_condition( permission_denied );
case ERROR_DEV_NOT_EXIST_: return make_error_condition( no_such_device );
case ERROR_DEVICE_IN_USE_: return make_error_condition( device_or_resource_busy );

View File

@@ -155,6 +155,10 @@ template<> struct is_error_condition_enum<errc::errc_t>
};
// class error_category
#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
#endif
#ifdef BOOST_MSVC
#pragma warning( push )
@@ -205,16 +209,16 @@ protected:
#endif
BOOST_SYSTEM_CONSTEXPR error_category() BOOST_NOEXCEPT: id_( 0 )
{
}
explicit BOOST_SYSTEM_CONSTEXPR error_category( boost::ulong_long_type id ) BOOST_NOEXCEPT: id_( id )
{
}
public:
BOOST_SYSTEM_CONSTEXPR error_category() BOOST_NOEXCEPT: id_( 0 )
{
}
virtual const char * name() const BOOST_NOEXCEPT = 0;
virtual error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT;
@@ -278,7 +282,8 @@ public:
// clang++ 3.8 and below: initialization of const object
// requires a user-provided default constructor
BOOST_SYSTEM_CONSTEXPR generic_error_category() BOOST_NOEXCEPT: error_category( 0xB2AB117A257EDF0Dull )
BOOST_SYSTEM_CONSTEXPR generic_error_category() BOOST_NOEXCEPT:
error_category( ( boost::ulong_long_type( 0xB2AB117A ) << 32 ) + 0x257EDF0D )
{
}
@@ -295,7 +300,8 @@ class BOOST_SYMBOL_VISIBLE system_error_category: public error_category
{
public:
BOOST_SYSTEM_CONSTEXPR system_error_category() BOOST_NOEXCEPT: error_category( 0x8FAFD21E25C5E09Bull )
BOOST_SYSTEM_CONSTEXPR system_error_category() BOOST_NOEXCEPT:
error_category( ( boost::ulong_long_type( 0x8FAFD21E ) << 32 ) + 0x25C5E09B )
{
}
@@ -312,6 +318,10 @@ public:
} // namespace detail
#if ( defined( BOOST_GCC ) && BOOST_GCC >= 40600 ) || defined( BOOST_CLANG )
#pragma GCC diagnostic pop
#endif
// generic_category(), system_category()
#if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
@@ -319,14 +329,17 @@ public:
namespace detail
{
template<class T> struct cat_holder
template<class T> struct BOOST_SYMBOL_VISIBLE cat_holder
{
BOOST_SYSTEM_REQUIRE_CONST_INIT static constexpr system_error_category system_category_instance{};
BOOST_SYSTEM_REQUIRE_CONST_INIT static constexpr generic_error_category generic_category_instance{};
static constexpr system_error_category system_category_instance{};
static constexpr generic_error_category generic_category_instance{};
};
template<class T> BOOST_SYSTEM_REQUIRE_CONST_INIT constexpr system_error_category cat_holder<T>::system_category_instance;
template<class T> BOOST_SYSTEM_REQUIRE_CONST_INIT constexpr generic_error_category cat_holder<T>::generic_category_instance;
// Before C++17 it was mandatory to redeclare all static constexpr
#if defined(BOOST_NO_CXX17_INLINE_VARIABLES)
template<class T> constexpr system_error_category cat_holder<T>::system_category_instance;
template<class T> constexpr generic_error_category cat_holder<T>::generic_category_instance;
#endif
} // namespace detail
@@ -342,6 +355,11 @@ constexpr error_category const & generic_category() BOOST_NOEXCEPT
#else // #if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
#if !defined(__SUNPRO_CC) // trailing __global is not supported
inline error_category const & system_category() BOOST_NOEXCEPT BOOST_SYMBOL_VISIBLE;
inline error_category const & generic_category() BOOST_NOEXCEPT BOOST_SYMBOL_VISIBLE;
#endif
inline error_category const & system_category() BOOST_NOEXCEPT
{
static const detail::system_error_category system_category_instance;
@@ -651,7 +669,7 @@ public:
return failed_? unspecified_bool_true: 0;
}
BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT // true if no error
BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT // true if no error
{
return !failed_;
}
@@ -746,7 +764,7 @@ inline bool operator!=( const error_code & lhs, const error_condition & rhs ) BO
inline bool operator==( const error_condition & condition, const error_code & code ) BOOST_NOEXCEPT
{
return condition.category().equivalent( code, condition.value() ) || code.category().equivalent( code.value(), condition );
return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
}
inline bool operator!=( const error_condition & lhs, const error_code & rhs ) BOOST_NOEXCEPT
@@ -766,19 +784,19 @@ inline std::size_t hash_value( error_code const & ec )
{
error_category const & cat = ec.category();
boost::ulong_long_type id = cat.id_;
boost::ulong_long_type id_ = cat.id_;
if( id == 0 )
if( id_ == 0 )
{
id = reinterpret_cast<boost::ulong_long_type>( &cat );
id_ = reinterpret_cast<boost::uintptr_t>( &cat );
}
boost::ulong_long_type hv = 0xCBF29CE484222325ull;
boost::ulong_long_type const prime = 0x00000100000001B3ull;
boost::ulong_long_type hv = ( boost::ulong_long_type( 0xCBF29CE4 ) << 32 ) + 0x84222325;
boost::ulong_long_type const prime = ( boost::ulong_long_type( 0x00000100 ) << 32 ) + 0x000001B3;
// id
hv ^= id;
hv ^= id_;
hv *= prime;
// value
@@ -847,6 +865,11 @@ inline char const * error_category::message( int ev, char * buffer, std::size_t
# if defined( BOOST_MSVC )
# pragma warning( push )
# pragma warning( disable: 4996 )
# elif defined(__clang__) && defined(__has_warning)
# pragma clang diagnostic push
# if __has_warning("-Wdeprecated-declarations")
# pragma clang diagnostic ignored "-Wdeprecated-declarations"
# endif
# endif
std::strncpy( buffer, m.c_str(), len - 1 );
@@ -854,6 +877,8 @@ inline char const * error_category::message( int ev, char * buffer, std::size_t
# if defined( BOOST_MSVC )
# pragma warning( pop )
# elif defined(__clang__) && defined(__has_warning)
# pragma clang diagnostic pop
# endif
return buffer;

View File

@@ -24,7 +24,7 @@ namespace boost
// library can be caught. See svn.boost.org/trac/boost/ticket/3697
{
public:
system_error( error_code ec )
explicit system_error( error_code ec )
: std::runtime_error(""), m_error_code(ec) {}
system_error( error_code ec, const std::string & what_arg )
@@ -46,8 +46,8 @@ namespace boost
virtual ~system_error() BOOST_NOEXCEPT_OR_NOTHROW {}
const error_code & code() const BOOST_NOEXCEPT_OR_NOTHROW { return m_error_code; }
const char * what() const BOOST_NOEXCEPT_OR_NOTHROW;
error_code code() const BOOST_NOEXCEPT { return m_error_code; }
const char * what() const BOOST_NOEXCEPT_OR_NOTHROW;
private:
error_code m_error_code;

View File

@@ -1,14 +1,15 @@
<html>
<head>
<meta http-equiv="refresh" content="0; URL=doc/index.html">
<meta http-equiv="refresh" content="0; URL=doc/html/system.html">
</head>
<body>
Automatic redirection failed, please go to
<a href="doc/index.html">doc/index.html</a>.
<hr>
<p><EFBFBD> Copyright Beman Dawes, 2003</p>
<p> Distribution under the Boost Software License, Version 1.0.
(See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
www.boost.org/LICENSE_1_0.txt</a>)</p>
<a href="doc/html/system.html">doc/html/system.html</a>.
</body>
</html>
</html>
<!--
<09> Copyright Beman Dawes, 2001
Distributed under the Boost Software License, Version 1.0.
See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt
-->

71
test/CMakeLists.txt Normal file
View File

@@ -0,0 +1,71 @@
# Copyright 2018-2020 Peter Dimov
# Distributed under the Boost Software License, Version 1.0.
# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
include(BoostTest OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
if(NOT HAVE_BOOST_TEST)
return()
endif()
macro(system_run s1)
string(MAKE_C_IDENTIFIER ${s1} n1)
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)
endmacro()
macro(lib name macro)
add_library(${name} EXCLUDE_FROM_ALL ${ARGN})
target_compile_definitions(${name} PRIVATE $<$<BOOL:BUILD_SHARED_LIBS>:${macro}=1>)
target_link_libraries(${name} PRIVATE Boost::system Boost::config)
endmacro()
set(BOOST_TEST_LINK_LIBRARIES Boost::system Boost::core Boost::static_assert)
boost_test(SOURCES quick.cpp)
system_run(error_code_test.cpp)
system_run(error_code_user_test.cpp)
system_run(system_error_test.cpp)
lib(boost_system_throw_test THROW_DYN_LINK throw_test.cpp)
boost_test(SOURCES dynamic_link_test.cpp LINK_LIBRARIES boost_system_throw_test)
system_run(initialization_test.cpp)
system_run(header_only_test.cpp)
boost_test(SOURCES config_test.cpp)
system_run(std_interop_test.cpp)
system_run(std_mismatch_test.cpp)
lib(boost_system_single_instance_lib1 SINGLE_INSTANCE_DYN_LINK single_instance_1.cpp)
lib(boost_system_single_instance_lib2 SINGLE_INSTANCE_DYN_LINK single_instance_2.cpp)
system_run(single_instance_test.cpp single_instance_1.cpp single_instance_2.cpp)
boost_test(SOURCES single_instance_test.cpp NAME single_instance_test_lib LINK_LIBRARIES boost_system_single_instance_lib1 boost_system_single_instance_lib2)
system_run(before_main_test.cpp)
system_run(constexpr_test.cpp)
system_run(win32_hresult_test.cpp)
system_run(error_category_test.cpp)
system_run(generic_category_test.cpp)
system_run(system_category_test.cpp)
system_run(after_main_test.cpp)
system_run(failed_test.cpp)
system_run(failed_constexpr_test.cpp)
boost_test(SOURCES warnings_test.cpp COMPILE_OPTIONS -Wall -Werror)
lib(boost_system_std_single_instance_lib1 STD_SINGLE_INSTANCE_DYN_LINK std_single_instance_1.cpp)
lib(boost_system_std_single_instance_lib2 STD_SINGLE_INSTANCE_DYN_LINK std_single_instance_2.cpp)
system_run(std_single_instance_test.cpp std_single_instance_1.cpp std_single_instance_2.cpp)
boost_test(SOURCES std_single_instance_test.cpp NAME std_single_instance_test_lib LINK_LIBRARIES boost_system_std_single_instance_lib1 boost_system_std_single_instance_lib2)

View File

@@ -1,7 +1,7 @@
# Boost System Library test Jamfile
# Copyright Beman Dawes 2003, 2006
# Copyright 2017, 2018 Peter Dimov
# Copyright 2017-2019 Peter Dimov
# Distributed under the Boost Software License, Version 1.0.
# See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt
@@ -9,118 +9,46 @@
# See library home page at http://www.boost.org/libs/system
import testing ;
import os ;
project
: requirements
<library>/boost/system//boost_system
;
lib throw_test : throw_test.cpp : <link>shared:<define>THROW_DYN_LINK=1 ;
lib single_instance_lib1 : single_instance_1.cpp : <link>shared:<define>SINGLE_INSTANCE_DYN_LINK ;
lib single_instance_lib2 : single_instance_2.cpp : <link>shared:<define>SINGLE_INSTANCE_DYN_LINK ;
rule cxx03 ( properties * )
{
local result ;
if <toolset>gcc in $(properties)
{
result = <cxxflags>-std=c++98 ; # 4.4 has no 03
}
else if <toolset>clang in $(properties)
{
result = <cxxflags>-std=c++03 ;
}
else
{
result = <build>no ;
}
return $(result) ;
}
rule cxx11 ( properties * )
{
local result ;
if <toolset>gcc in $(properties)
{
result = <cxxflags>-std=c++0x ; # 4.6 has no 11
}
else if <toolset>clang in $(properties)
{
result = <cxxflags>-std=c++11 ;
}
else
{
result = <build>no ;
}
return $(result) ;
}
rule system-run- ( sources + )
{
local result ;
result += [ run $(sources) : : : <link>static : $(sources[1]:B)_static ] ;
result += [ run $(sources) : : : <link>shared : $(sources[1]:B)_shared ] ;
result += [ run $(sources) : : : -<library>/boost/system//boost_system <define>BOOST_ERROR_CODE_HEADER_ONLY : $(sources[1]:B)_header ] ;
return $(result) ;
}
if [ os.environ UBSAN ]
rule system-run ( sources + )
{
rule system-run ( sources + )
{
# The 03/11 tests are ODR violations, no point running them under -fsanitize=undefined
return [ system-run- $(sources) ] ;
}
}
else
{
rule system-run ( sources + )
{
local result = [ system-run- $(sources) ] ;
local result ;
# Test a source file built with -std=c++03 linked with a System library built without -std=c++03
result += [ run $(sources) : : : <link>static <conditional>@cxx03 : $(sources[1]:B)_static_03 ] ;
result += [ run $(sources) : : : <link>shared <conditional>@cxx03 : $(sources[1]:B)_shared_03 ] ;
result += [ run $(sources) ] ;
result += [ run $(sources) : : : <library>/boost/system//boost_system <link>static : $(sources[1]:B)_static ] ;
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 ] ;
# Test a source file built with -std=c++11 linked with a System library built without -std=c++11
result += [ run $(sources) : : : <link>static <conditional>@cxx11 : $(sources[1]:B)_static_11 ] ;
result += [ run $(sources) : : : <link>shared <conditional>@cxx11 : $(sources[1]:B)_shared_11 ] ;
return $(result) ;
}
return $(result) ;
}
system-run error_code_test.cpp ;
system-run error_code_user_test.cpp ;
system-run system_error_test.cpp ;
run dynamic_link_test.cpp throw_test : : : <link>shared : throw_test_shared ;
lib throw_test : throw_test.cpp : <link>shared:<define>THROW_DYN_LINK=1 ;
run dynamic_link_test.cpp throw_test : : : <link>shared : throw_test_shared ;
system-run initialization_test.cpp ;
run header_only_test.cpp : : : -<library>/boost/system//boost_system ;
run header_only_test.cpp : : : -<library>/boost/system//boost_system <define>BOOST_NO_ANSI_APIS : header_only_test_no_ansi ;
system-run header_only_test.cpp ;
run config_test.cpp : : : <test-info>always_show_run_output ;
system-run- std_interop_test.cpp ;
system-run std_interop_test.cpp ;
system-run std_mismatch_test.cpp ;
lib single_instance_lib1 : single_instance_1.cpp : <link>shared:<define>SINGLE_INSTANCE_DYN_LINK ;
lib single_instance_lib2 : single_instance_2.cpp : <link>shared:<define>SINGLE_INSTANCE_DYN_LINK ;
system-run single_instance_test.cpp single_instance_1.cpp single_instance_2.cpp ;
run single_instance_test.cpp single_instance_lib1 single_instance_lib2 : : : <link>static : single_instance_lib_static ;
run single_instance_test.cpp single_instance_lib1 single_instance_lib2 : : : <link>shared : single_instance_lib_shared ;
system-run before_main_test.cpp ;
run-fail throws_assign_fail.cpp ;
system-run- constexpr_test.cpp ;
system-run constexpr_test.cpp ;
system-run win32_hresult_test.cpp ;
system-run error_category_test.cpp ;
@@ -128,7 +56,16 @@ system-run generic_category_test.cpp ;
system-run system_category_test.cpp ;
system-run after_main_test.cpp ;
system-run failed_test.cpp ;
system-run- failed_constexpr_test.cpp ;
system-run failed_constexpr_test.cpp ;
# Quick (CI) test
run quick.cpp ;
run warnings_test.cpp : : : <warnings>all <warnings-as-errors>on <toolset>gcc:<cxxflags>-Wnon-virtual-dtor <toolset>clang:<cxxflags>-Wnon-virtual-dtor ;
lib std_single_instance_lib1 : std_single_instance_1.cpp : <link>shared:<define>STD_SINGLE_INSTANCE_DYN_LINK ;
lib std_single_instance_lib2 : std_single_instance_2.cpp : <link>shared:<define>STD_SINGLE_INSTANCE_DYN_LINK ;
system-run std_single_instance_test.cpp std_single_instance_1.cpp std_single_instance_2.cpp ;
run std_single_instance_test.cpp std_single_instance_lib1 std_single_instance_lib2 : : : <link>static : std_single_instance_lib_static ;
run std_single_instance_test.cpp std_single_instance_lib1 std_single_instance_lib2 : : : <link>shared <define>STD_SINGLE_INSTANCE_SHARED : std_single_instance_lib_shared ;

View File

@@ -0,0 +1,18 @@
# Copyright 2018, 2019 Peter Dimov
# Distributed under the Boost Software License, Version 1.0.
# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
cmake_minimum_required(VERSION 3.5...3.16)
project(cmake_install_test LANGUAGES CXX)
find_package(boost_system REQUIRED)
find_package(boost_core REQUIRED)
add_executable(quick ../quick.cpp)
target_link_libraries(quick Boost::system Boost::core)
enable_testing()
add_test(quick quick)
add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

View File

@@ -0,0 +1,22 @@
# Copyright 2018, 2019 Peter Dimov
# Distributed under the Boost Software License, Version 1.0.
# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
cmake_minimum_required(VERSION 3.5...3.16)
project(cmake_subdir_test LANGUAGES CXX)
add_subdirectory(../.. boostorg/system)
add_subdirectory(../../../assert boostorg/assert)
add_subdirectory(../../../config boostorg/config)
add_subdirectory(../../../core boostorg/core)
add_subdirectory(../../../predef boostorg/predef)
add_subdirectory(../../../winapi boostorg/winapi)
add_executable(quick ../quick.cpp)
target_link_libraries(quick Boost::system Boost::core)
enable_testing()
add_test(quick quick)
add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

View File

@@ -197,7 +197,8 @@ int main( int, char ** )
#if defined(BOOST_WINDOWS_API)
// Borland appends newline, so just check text
BOOST_TEST( ec.message().substr(0,13) == "Unknown error" );
BOOST_TEST( ec_0_system.message().substr(0,36) == "The operation completed successfully" );
// Fails when the language isn't US English
// BOOST_TEST( ec_0_system.message().substr(0,36) == "The operation completed successfully" );
#elif defined(linux) || defined(__linux) || defined(__linux__)
// Linux appends value to message as unsigned, so it varies with # of bits
BOOST_TEST( ec.message().substr(0,13) == "Unknown error" );

View File

@@ -0,0 +1,40 @@
// Copyright 2019 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
#include <boost/config.hpp>
#if defined(STD_SINGLE_INSTANCE_DYN_LINK)
# define EXPORT BOOST_SYMBOL_EXPORT
#else
# define EXPORT
#endif
#include <boost/system/error_code.hpp>
#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
#include <system_error>
namespace lib1
{
EXPORT std::error_code get_system_code()
{
return boost::system::error_code( 0, boost::system::system_category() );
}
EXPORT std::error_code get_generic_code()
{
return boost::system::error_code( 0, boost::system::generic_category() );
}
} // namespace lib1
#else
EXPORT void lib1_f()
{
}
#endif

View File

@@ -0,0 +1,40 @@
// Copyright 2019 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
#include <boost/config.hpp>
#if defined(STD_SINGLE_INSTANCE_DYN_LINK)
# define EXPORT BOOST_SYMBOL_EXPORT
#else
# define EXPORT
#endif
#include <boost/system/error_code.hpp>
#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
#include <system_error>
namespace lib2
{
EXPORT std::error_code get_system_code()
{
return boost::system::error_code( 0, boost::system::system_category() );
}
EXPORT std::error_code get_generic_code()
{
return boost::system::error_code( 0, boost::system::generic_category() );
}
} // namespace lib2
#else
EXPORT void lib2_f()
{
}
#endif

View File

@@ -0,0 +1,76 @@
// Copyright 2019 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
#include <boost/system/error_code.hpp>
#include <boost/config/pragma_message.hpp>
#include <boost/config/helper_macros.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(STD_SINGLE_INSTANCE_SHARED) && defined(__CYGWIN__)
BOOST_PRAGMA_MESSAGE( "Skipping Windows/DLL test, __CYGWIN__" )
int main() {}
#elif defined(STD_SINGLE_INSTANCE_SHARED) && defined(_WIN32) && !defined(_MSC_VER)
BOOST_PRAGMA_MESSAGE( "Skipping Windows/DLL test, no _MSC_VER" )
int main() {}
#elif defined(STD_SINGLE_INSTANCE_SHARED) && defined(_WIN32) && !defined(_CPPLIB_VER)
BOOST_PRAGMA_MESSAGE( "Skipping Windows/DLL test, no _CPPLIB_VER" )
int main() {}
#elif defined(STD_SINGLE_INSTANCE_SHARED) && defined(_WIN32) && (_MSC_VER < 1900 || _MSC_VER >= 2000)
BOOST_PRAGMA_MESSAGE( "Skipping Windows/DLL test, _MSC_VER is " BOOST_STRINGIZE(_MSC_VER) )
int main() {}
#else
#include <boost/core/lightweight_test.hpp>
#include <system_error>
using namespace boost::system;
namespace lib1
{
std::error_code get_system_code();
std::error_code get_generic_code();
} // namespace lib1
namespace lib2
{
std::error_code get_system_code();
std::error_code get_generic_code();
} // namespace lib2
int main()
{
{
std::error_code e1 = lib1::get_system_code();
std::error_code e2 = lib2::get_system_code();
BOOST_TEST_EQ( e1, e2 );
}
{
std::error_code e1 = lib1::get_generic_code();
std::error_code e2 = lib2::get_generic_code();
BOOST_TEST_EQ( e1, e2 );
}
return boost::report_errors();
}
#endif

View File

@@ -18,6 +18,16 @@
//
#if defined(BOOST_WINDOWS_API) && defined(BOOST_SYSTEM_USE_UTF8)
#include <boost/config/pragma_message.hpp>
BOOST_PRAGMA_MESSAGE( "Skipping test due to BOOST_WINDOWS_API && BOOST_SYSTEM_USE_UTF8" )
int main() {}
#else
#if defined(BOOST_WINDOWS_API)
#include <windows.h>
@@ -90,7 +100,7 @@ static void test_message( sys::error_category const & cat, int ev )
{
BOOST_TEST_EQ( cat.message( ev ), sys_strerror( ev ) );
char buffer[ 2048 ]; // yes, really
char buffer[ 4096 ]; // yes, really
BOOST_TEST_CSTR_EQ( cat.message( ev, buffer, sizeof( buffer ) ), sys_strerror( ev ).c_str() );
}
@@ -100,17 +110,12 @@ int main()
// message
for( int i = -2; i < 1024; ++i )
{
test_message( cat, i );
}
test_message( cat, 5810 );
for( int i = 10000; i < 11032; ++i )
for( int i = -2; i < 16000; ++i )
{
test_message( cat, i );
}
return boost::report_errors();
}
#endif // #if defined(BOOST_WINDOWS_API) && defined(BOOST_SYSTEM_USE_UTF8)

View File

@@ -37,7 +37,7 @@ namespace
BOOST_TEST( ex.code().category() == system_category() );
# ifdef BOOST_WINDOWS_API
LANGID language_id;
# if !defined(__MINGW32__) && !defined(__CYGWIN__) && !BOOST_PLAT_WINDOWS_RUNTIME
# if !BOOST_PLAT_WINDOWS_RUNTIME
language_id = ::GetUserDefaultUILanguage();
# else
language_id = 0x0409; // Assume US English

42
test/warnings_test.cpp Normal file
View File

@@ -0,0 +1,42 @@
// Copyright 2017, 2019 Peter Dimov.
//
// Distributed under the Boost Software License, Version 1.0.
//
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
// See library home page at http://www.boost.org/libs/system
#include <boost/config.hpp>
#if defined( BOOST_GCC ) && BOOST_GCC < 40600
#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
#endif
#include <boost/system/error_code.hpp>
#include <boost/core/lightweight_test.hpp>
#include <cerrno>
int main()
{
boost::system::error_category const & bt = boost::system::generic_category();
int ev = ENOENT;
boost::system::error_code bc( ev, bt );
BOOST_TEST_EQ( bc.value(), ev );
BOOST_TEST_EQ( &bc.category(), &bt );
boost::system::error_condition bn = bt.default_error_condition( ev );
BOOST_TEST_EQ( bn.value(), ev );
BOOST_TEST_EQ( &bn.category(), &bt );
BOOST_TEST( bt.equivalent( ev, bn ) );
BOOST_TEST( bc == bn );
return boost::report_errors();
}