mirror of
https://github.com/boostorg/system.git
synced 2026-06-16 08:52:38 +02:00
Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Beman Dawes
|
8ba49731c8 |
-404
@@ -1,404 +0,0 @@
|
||||
# Copyright 2016 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)
|
||||
|
||||
language: cpp
|
||||
|
||||
sudo: false
|
||||
|
||||
python: "2.7"
|
||||
|
||||
os:
|
||||
- linux
|
||||
- osx
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- develop
|
||||
|
||||
env:
|
||||
matrix:
|
||||
- BOGUS_JOB=true
|
||||
|
||||
matrix:
|
||||
|
||||
exclude:
|
||||
- env: BOGUS_JOB=true
|
||||
|
||||
include:
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++03
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++03
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++03
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++03
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++03
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-5
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-5
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-5
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-5
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++03
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: g++-7
|
||||
env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++03
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: g++-7
|
||||
env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: g++-7
|
||||
env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++14
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: g++-7
|
||||
env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++17
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++03
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.6
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.6
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++03
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.7
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.7
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++03
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.8
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.8
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.8
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.8
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++03
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.9
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.9
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++14
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.9
|
||||
|
||||
- os: linux
|
||||
env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.9
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-4.0
|
||||
env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++03
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- 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=c++11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- 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=c++14
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- 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=c++1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-4.0
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-trusty-4.0
|
||||
|
||||
- os: osx
|
||||
env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
|
||||
|
||||
- os: osx
|
||||
env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
|
||||
|
||||
- os: osx
|
||||
env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
|
||||
|
||||
- os: osx
|
||||
env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++1z
|
||||
|
||||
install:
|
||||
- cd ..
|
||||
- git clone -b $TRAVIS_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
|
||||
- ./bootstrap.sh
|
||||
- ./b2 headers
|
||||
|
||||
script:
|
||||
- |-
|
||||
echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
|
||||
- ./b2 libs/system/test toolset=$TOOLSET
|
||||
|
||||
notifications:
|
||||
email:
|
||||
on_success: always
|
||||
@@ -1,69 +0,0 @@
|
||||
# Copyright 2016, 2017 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)
|
||||
|
||||
version: 1.0.{build}-{branch}
|
||||
|
||||
shallow_clone: true
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- develop
|
||||
|
||||
environment:
|
||||
matrix:
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
|
||||
TOOLSET: msvc-9.0
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
|
||||
TOOLSET: msvc-10.0
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
|
||||
TOOLSET: msvc-11.0
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
|
||||
TOOLSET: msvc-12.0
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
|
||||
ADDPATH: C:\cygwin\bin;
|
||||
TOOLSET: gcc
|
||||
CXXFLAGS: cxxflags=-std=c++03
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
|
||||
ADDPATH: C:\cygwin\bin;
|
||||
TOOLSET: gcc
|
||||
CXXFLAGS: cxxflags=-std=c++11
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
|
||||
ADDPATH: C:\mingw\bin;
|
||||
TOOLSET: gcc
|
||||
CXXFLAGS: cxxflags=-std=c++03
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
|
||||
ADDPATH: C:\mingw\bin;
|
||||
TOOLSET: gcc
|
||||
CXXFLAGS: cxxflags=-std=c++11
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
|
||||
ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
|
||||
TOOLSET: gcc
|
||||
CXXFLAGS: cxxflags=-std=c++03
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
|
||||
ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
|
||||
TOOLSET: gcc
|
||||
CXXFLAGS: cxxflags=-std=c++11
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
TOOLSET: msvc-14.0
|
||||
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
TOOLSET: msvc-14.1
|
||||
|
||||
install:
|
||||
- cd ..
|
||||
- git clone -b %APPVEYOR_REPO_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
|
||||
- python tools/boostdep/depinst/depinst.py system
|
||||
- cmd /c bootstrap
|
||||
- b2 headers
|
||||
|
||||
build: off
|
||||
|
||||
test_script:
|
||||
- PATH=%ADDPATH%%PATH%
|
||||
- b2 libs/system/test toolset=%TOOLSET% %CXXFLAGS%
|
||||
+8
-26
@@ -6,15 +6,15 @@
|
||||
<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">
|
||||
<link rel="stylesheet" type="text/css" href="../../../doc/html/minimal.css">
|
||||
</head>
|
||||
|
||||
<body>
|
||||
|
||||
<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111">
|
||||
<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="637">
|
||||
<tr>
|
||||
<td width="277">
|
||||
<a href="../../../index.html">
|
||||
<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>
|
||||
@@ -38,7 +38,6 @@
|
||||
<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>
|
||||
@@ -94,21 +93,6 @@ supports both error reporting by exception and by error code.</p>
|
||||
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> and <code>error_condition</code> are designed as a value types so
|
||||
they can be copied
|
||||
@@ -148,16 +132,14 @@ 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>© Copyright Beman Dawes, 1999<br>
|
||||
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>
|
||||
|
||||
<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>
|
||||
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->November 12, 2007<!--webbot bot="Timestamp" endspan i-checksum="39581" --> </font>
|
||||
</p>
|
||||
|
||||
<p>© 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 <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>) </p>
|
||||
|
||||
</body>
|
||||
|
||||
</html>
|
||||
+214
-294
@@ -6,7 +6,7 @@
|
||||
<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">
|
||||
<link rel="stylesheet" type="text/css" href="../../../doc/html/minimal.css">
|
||||
</head>
|
||||
|
||||
<body>
|
||||
@@ -38,10 +38,7 @@
|
||||
<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 <boost/system/error_code.hpp></a><br>
|
||||
<a href="#Class-error_category">Class <code>error_category</code></a><br>
|
||||
<a href="#Class-error_category-synopsis">Class <code>error_category</code> synopsis</a><br>
|
||||
@@ -55,13 +52,11 @@
|
||||
<a href="#Class-error_code-constructors">Class <code>error_code</code> constructors</a><br>
|
||||
<a href="#Class-error_code-modifiers">Class <code>error_code</code> modifiers</a><br>
|
||||
<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>
|
||||
<a href="#Class-error_condition</code>">Class <code>error_condition</code></a><br>
|
||||
<a href="#Class-error_condition-synopsis">Class <code>error_condition</code> synopsis</a><br>
|
||||
<a href="#Class-error_condition-constructors">Class <code>error_condition</code> constructors</a><br>
|
||||
<a href="#Class-error_condition-modifiers">Class <code>error_condition</code> modifiers</a><br>
|
||||
<a href="#Class-error_condition-observers">Class <code>error_condition</code> observers</a><br>
|
||||
<a href="#throws-object"><code>throws</code> object</a><br>
|
||||
<a href="#Semantics-of-throws">Semantics of <code>throws</code> object</a><br>
|
||||
<a href="#Non-member-functions">Non-member functions</a><br>
|
||||
<a href="#Header-system_error">Header <boost/system/system_error.hpp></a><br>
|
||||
<a href="#Class-system_error">Class <code>system_error</code></a><br>
|
||||
@@ -71,116 +66,54 @@
|
||||
|
||||
<h2><a name="Introduction">Introduction</a></h2>
|
||||
|
||||
<p>This reference documentation describes components that programs may use to report error conditions originating from the operating
|
||||
<p>This reference documentation describes components that
|
||||
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 defined 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">
|
||||
<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111">
|
||||
<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>
|
||||
<td><b><i>Macro Name</i></b></td>
|
||||
<td><b><i>Default</i></b></td>
|
||||
<td><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>
|
||||
<td valign="top"><code>BOOST_WINDOWS_API</code></td>
|
||||
<td valign="top">Defined if Windows is detected by Boost.System's automatic configuration
|
||||
code, otherwise not defined.</td>
|
||||
<td valign="top">Implementation uses the Microsoft Windows native
|
||||
application program interface (API).</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,
|
||||
<td valign="top"><code>BOOST_POSIX_API</code></td>
|
||||
<td valign="top">Defined if Windows is not detected by Boost.System's automatic configuration
|
||||
code.</td>
|
||||
<td valign="top">Implementation uses the POSIX native
|
||||
application program interface (API).</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top"><code>BOOST_SYSTEM_DYN_LINK</code></td>
|
||||
<td valign="top">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,
|
||||
<td valign="top">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,
|
||||
<td valign="top"><code>BOOST_SYSTEM_NO_LIB</code></td>
|
||||
<td valign="top">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
|
||||
<td valign="top">Boost.System library does not use the Boost auto-link
|
||||
facility.</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top" height="32"><code>BOOST_SYSTEM_NO_DEPRECATED</code></td>
|
||||
<td valign="top" height="32">Not defined.</td>
|
||||
<td valign="top" height="32">Deprecated features are excluded.</td>
|
||||
</tr>
|
||||
</table>
|
||||
<h2><a name="Deprecated-names">Deprecated names</a></h2>
|
||||
<p>In the process of adding Boost.System to C++0x standard library, the C++
|
||||
committee changed some
|
||||
names. To ease transition, Boost.System deprecates the old
|
||||
names, but continues to provide them unless macro <code>BOOST_SYSTEM_NO_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>
|
||||
<td valign="top"><code>BOOST_SYSTEM_NO_DEPRECATED</code></td>
|
||||
<td valign="top">Not defined.</td>
|
||||
<td valign="top">Deprecated features are excluded.</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 <boost/system/error_code.hpp></a></h2>
|
||||
<h3><boost/system/error_code.hpp> synopsis</h3>
|
||||
<blockquote>
|
||||
@@ -189,9 +122,6 @@ fixed by globally adding () to these names to turn them into function calls.</p>
|
||||
namespace system
|
||||
{
|
||||
class <a href="#Class-error_category">error_category</a>;
|
||||
const error_category & <a href="#system_category">system_category</a>() noexcept;
|
||||
const error_category & <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>;
|
||||
|
||||
@@ -202,10 +132,10 @@ fixed by globally adding () to these names to turn them into function calls.</p>
|
||||
template< class T="" >
|
||||
struct is_error_condition_enum { static const bool value = false; };
|
||||
|
||||
// generic error_conditions
|
||||
namespace errc
|
||||
// portable error_conditions
|
||||
namespace posix_error
|
||||
{
|
||||
enum errc_t
|
||||
enum posix_errno
|
||||
{
|
||||
success = 0,
|
||||
address_family_not_supported, //EAFNOSUPPORT
|
||||
@@ -288,28 +218,26 @@ fixed by globally adding () to these names to turn them into function calls.</p>
|
||||
wrong_protocol_type //EPROTOTYPE
|
||||
};
|
||||
|
||||
} // namespace errc
|
||||
} // namespace posix_error
|
||||
|
||||
template<> struct is_error_condition_enum<posix::posix_errno><errc::errc_t>
|
||||
template<> struct is_error_condition_enum<posix::posix_errno><posix_error::posix_errno>
|
||||
{ static const bool value = true; };
|
||||
|
||||
// <a href="#Non-member-functions">non-member functions</a>
|
||||
bool operator==( const error_code & lhs, const error_code & rhs );
|
||||
bool operator==( const error_code & code, const error_condition & condition );
|
||||
bool operator==( const error_condition & condition, const error_code & code );
|
||||
bool operator==( const error_condition & lhs, const error_condition & rhs );
|
||||
|
||||
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;
|
||||
bool operator==( const error_condition & lhs, const error_condition & rhs ) noexcept;
|
||||
bool operator!=( const error_code & lhs, const error_code & rhs );
|
||||
bool operator!=( const error_code & code, const error_condition & condition );
|
||||
bool operator!=( const error_condition & condition, const error_code & code );
|
||||
bool operator!=( const error_condition & lhs, const error_condition & rhs );
|
||||
|
||||
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;
|
||||
bool operator!=( const error_condition & lhs, const error_condition & rhs ) noexcept;
|
||||
bool operator<( const error_code & lhs, const error_code & rhs );
|
||||
bool operator<( const error_condition & lhs, const error_condition & rhs );
|
||||
|
||||
bool operator<( const error_code & lhs, const error_code & rhs ) noexcept;
|
||||
bool operator<( const error_condition & lhs, const error_condition & rhs ) noexcept;
|
||||
|
||||
error_code make_error_code( errc::errc_t e ) noexcept;
|
||||
error_condition make_error_condition( errc::errc_t e ) noexcept;
|
||||
error_code make_error_code( posix_error::posix_errno e );
|
||||
error_condition make_error_condition( posix_error::posix_errno e );
|
||||
|
||||
template <class charT, class traits>
|
||||
std::basic_ostream<charT,traits>&
|
||||
@@ -319,24 +247,13 @@ fixed by globally adding () to these names to turn them into function calls.</p>
|
||||
}
|
||||
}</pre>
|
||||
</blockquote>
|
||||
<p>The value of each<code> errc_t</code> constant shall be the same as the
|
||||
<p>The value of each<code> posix_errno</code> constant shall be the same as the
|
||||
value of the <code><cerrno></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 & <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 & <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>
|
||||
@@ -361,69 +278,99 @@ types should create a single object of each such type. <i>
|
||||
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 & condition )
|
||||
const noexcept;
|
||||
virtual bool equivalent( const error_code & code, int condition ) const noexcept;
|
||||
virtual const char * name() const = 0;
|
||||
virtual string message( error_code::value_type ev ) const = 0;
|
||||
virtual error_condition default_error_condition( int ev ) const;
|
||||
virtual bool equivalent( int code, const error_condition & condition ) const;
|
||||
virtual bool equivalent( const error_code & code, int condition ) const;
|
||||
|
||||
bool operator==( const error_category & rhs ) const noexcept;
|
||||
bool operator!=( const error_category & rhs ) const noexcept;
|
||||
bool operator< ( const error_category & rhs ) const noexcept;
|
||||
bool operator==( const error_category & rhs ) const;
|
||||
bool operator!=( const error_category & rhs ) const;
|
||||
bool operator< ( const error_category & rhs ) const;
|
||||
};
|
||||
|
||||
const error_category & get_system_category();
|
||||
const error_category & get_posix_category();
|
||||
|
||||
static const error_category & system_category = get_system_category();
|
||||
static const error_category & posix_category = get_posix_category();
|
||||
}
|
||||
}</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>
|
||||
<pre>virtual const char * name() const=0;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns: </i>a string naming the error category.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>virtual string message( int ev ) const noexcept =0;</pre>
|
||||
<pre>virtual string message( error_code::value_type ev ) const=0;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> A string that describes the error denoted by
|
||||
<code>ev</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>virtual error_condition default_error_condition( int ev ) const noexcept;</pre>
|
||||
<p><code>virtual error_condition default_error_condition( int ev ) const;</code></p>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>error_condition( ev, *this )</code>.</p>
|
||||
<blockquote>
|
||||
<p dir="ltr"> [<i>--Note:</i> Derived classes will typically convert <code>ev</code>
|
||||
to some portable <code>error_category</code>, such as <code>generic_category()</code>,
|
||||
<p> [<i>--Note:</i> Derived classes will typically convert <code>ev</code>
|
||||
to some portable <code>error_category</code>, such as <code>posix_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 & condition ) const noexcept;</pre>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<p><code>virtual bool equivalent( int code, const error_condition &
|
||||
condition )
|
||||
const;</code></p>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>default_error_condition( code ) == condition</code>.</p>
|
||||
</blockquote>
|
||||
<pre>virtual bool equivalent( const error_code & code, int condition ) const noexcept;</pre>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<p><code>virtual bool equivalent( const error_code & code, int condition ) const;</code></p>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>*this == code.category() && code.value() == condition</code>.</p>
|
||||
</blockquote>
|
||||
<p><i>Throws:</i> Nothing.</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 & rhs ) const noexcept;</pre>
|
||||
<p><code>bool operator==( const error_category & rhs ) const;</code></p>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>this == &rhs</code>.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator!=( const error_category & rhs ) const noexcept;</pre>
|
||||
<p><code>bool operator!=( const error_category & rhs ) const;</code></p>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>this != &rhs</code>.</p>
|
||||
</blockquote>
|
||||
|
||||
<pre>bool operator<( const error_category & rhs ) const noexcept;</pre>
|
||||
<pre>bool operator<( const error_category & rhs ) const;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>std::less<const error_category*>()( this, &rhs
|
||||
noexcept)</code>.</p>
|
||||
<p><i>Returns:</i> <code>std::less<const error_category*>()( this, &rhs )</code>.</p>
|
||||
<blockquote>
|
||||
<p><i>[Note:</i> <code>std::less</code> provides a total ordering for
|
||||
pointers. <i>--end note]</i></p>
|
||||
</blockquote>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<h3><a name="Class-error_category-non-member-functions">Class <code>error_category</code>
|
||||
non-member functions</a></h3>
|
||||
<pre>const error_category & get_system_category();</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> A reference to a <code>error_category</code> object
|
||||
identifying errors originating from the operating system.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>const error_category & get_posix_category();</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> A reference to a <code>error_category</code> object
|
||||
identifying portable error conditions.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<h3><a name="Class-error_category-predefined-objects">Class <code>error_category</code>
|
||||
predefined objects</a></h3>
|
||||
<p>Predefined objects <code>system_category</code>
|
||||
and <code>posix_category</code> identify operating system error codes and portable error conditions, respectively.</p>
|
||||
<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
|
||||
@@ -442,92 +389,98 @@ error_code</code> synopsis</a></h3>
|
||||
public:
|
||||
|
||||
// constructors:
|
||||
error_code() noexcept;
|
||||
error_code( val, const error_category & cat ) noexcept;
|
||||
error_code();
|
||||
error_code( val, const error_category & cat );
|
||||
template <class <code>ErrorCodeEnum</code>>
|
||||
error_code(<code> ErrorCodeEnum</code> e ) noexcept;
|
||||
error_code(<code> errorCodeEnum</code> e,
|
||||
typename enable_if<is_error_code_enum<<code>ErrorCodeEnum</code>> >::type* = 0);
|
||||
|
||||
// modifiers:
|
||||
void assign( int val, const error_category & cat ) noexcept;
|
||||
void assign( int val, const error_category & cat );
|
||||
template<typename <code>ErrorCodeEnum</code>>
|
||||
error_code & operator=( <code>ErrorCodeEnum</code> val ) noexcept;
|
||||
void clear() noexcept;
|
||||
typename enable_if<is_error_code_enum<<code>ErrorCodeEnum</code>>, error_code>::type &
|
||||
operator=( <code>ErrorCodeEnum</code> val );;
|
||||
void clear();
|
||||
|
||||
// observers:
|
||||
int value() const noexcept;
|
||||
cont error_category & category() const noexcept;
|
||||
error_condition default_error_condition() const noexcept;
|
||||
int value() const;
|
||||
cont error_category & category() const;
|
||||
error_condition default_error_condition() const;
|
||||
string message() const;
|
||||
operator unspecified-bool-type() const;
|
||||
|
||||
private:
|
||||
int val_; // <i>exposition only</i>
|
||||
const error_category * cat_; // <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>
|
||||
<pre>error_code();</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects: </i>Constructs an object of type <code>error_code</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>val_ == 0 && cat_ == &system_category()</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>val_ == 0 && cat_ == &system_category</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>error_code( int val, const error_category & cat ) noexcept;</pre>
|
||||
<pre>error_code( int val, const error_category & cat );</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects: </i>Constructs an object of type <code>error_code</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>val_ == val && cat_ == &cat</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>template <class <code>ErrorCodeEnum</code>>
|
||||
error_code(<code> ErrorCodeEnum</code> val ) noexcept;</pre>
|
||||
error_code(<code> errorCodeEnum</code> val,
|
||||
typename enable_if<is_error_code_enum<<code>ErrorCodeEnum</code>> >::type* = 0);</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<ErrorCodeEnum>::value</code> is
|
||||
<code>true</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</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 & cat ) noexcept;</pre>
|
||||
<pre>void assign( int val, const error_category & cat );</pre>
|
||||
<blockquote>
|
||||
<p><i>Postconditions:</i> <code>val_ == val && cat_ == &cat</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>val_ == val && cat_ == cat</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename <code>ErrorCodeEnum</code>>
|
||||
error_code & operator=( <code>ErrorCodeEnum</code> val ) noexcept;</pre>
|
||||
typename enable_if<is_error_code_enum<<code>ErrorCodeEnum</code>>, error_code>::type &
|
||||
operator=( <code>ErrorCodeEnum</code> val );</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<ErrorCodeEnum>::value</code> is <code>true</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre><code>void clear() noexcept;</code></pre>
|
||||
<p><code>void clear();</code></p>
|
||||
<blockquote>
|
||||
<p><i>postcondition:</i> <code>value() == 0 && category() ==
|
||||
system_category()</code></p>
|
||||
<p><i>postcondition:</i> <code>value() == 0 && category() == posix_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>
|
||||
<p><code>int value() const;</code></p>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>val_</code>.</p>
|
||||
</blockquote>
|
||||
<pre><code>const error_category & category() const noexcept;</code></pre>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<p><code>error_category category() const;</code></p>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>*cat_</code>.</p>
|
||||
</blockquote>
|
||||
<pre>error_condition default_error_condition() const noexcept;</pre>
|
||||
<p><i>Returns:</i> <code>cat_</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>error_condition default_error_condition() const;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>category().default_error_condition( value())</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre><code>string message() const;</code></pre>
|
||||
<p><code>string message() const;</code></p>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>category().message( value())</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>operator unspecified-bool-type() const;</pre>
|
||||
<p><code>operator <i>unspecified-bool-type</i>() const;</code></p>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> if <code>value() != 0</code>, returns a value that will evaluate
|
||||
<p><i>Returns:</i> if <code>value() != value_type()</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>
|
||||
@@ -554,83 +507,88 @@ implementation specific. <i>--end note ]</i></p>
|
||||
public:
|
||||
|
||||
// constructors:
|
||||
error_condition() noexcept;
|
||||
error_condition( int val, const error_category & cat ) noexcept;
|
||||
error_condition();
|
||||
error_condition( int val, const error_category & cat );
|
||||
template <class ErrorConditionEnum>
|
||||
error_condition( errorConditionEnum val ) noexcept;
|
||||
error_condition( errorConditionEnum val,
|
||||
typename enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0 );
|
||||
|
||||
// modifiers:
|
||||
void assign( int val, const error_category & cat ) noexcept;
|
||||
void assign( int val, const error_category & cat );
|
||||
template<typename ErrorConditionEnum>
|
||||
error_condition & operator=( ErrorConditionEnum val ) noexcept;
|
||||
void clear() noexcept;
|
||||
typename enable_if<is_error_condition_enum<ErrorConditionEnum>, error_code>::type &
|
||||
operator=( ErrorConditionEnum val );
|
||||
void clear();
|
||||
|
||||
// observers:
|
||||
int value() const noexcept;
|
||||
const error_category & category() const noexcept;
|
||||
int value() const;
|
||||
const error_category & category() const;
|
||||
string message() const;
|
||||
operator unspecified-bool-type () const noexcept;
|
||||
operator unspecified-bool-type () const;
|
||||
|
||||
private:
|
||||
int val_; // <i>exposition only</i>
|
||||
const error_category * cat_; // <i>exposition only</i>
|
||||
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>
|
||||
<pre>error_condition(); </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_ == &generic_category()</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>val_ == 0 and cat_ == posix_category</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>error_condition( int val, const error_category & cat ) noexcept;</pre>
|
||||
<pre>error_condition( value_type val, const error_category & cat );</pre>
|
||||
<blockquote>
|
||||
<p><i>Effects: </i>Constructs an object of type error_condition.</p>
|
||||
<p><i>Postconditions:</i> <code>val_ == val and cat_ == &cat</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>val_ == val and cat_ == cat</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>template <class ErrorConditionEnum>
|
||||
error_condition( ErrorConditionEnum e ) noexcept;</pre>
|
||||
error_condition( errorConditionEnum val,
|
||||
typename enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0 );</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<ErrorConditionEnum>::value</code>
|
||||
is <code>true</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>*this == make_error_condition( val )</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</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 & cat ) noexcept; </pre>
|
||||
<pre>void assign( value_type val, const error_category & cat ); </pre>
|
||||
<blockquote>
|
||||
<p><i>Postconditions:</i> <code>val_ == val and cat_ == &cat</code>. </p>
|
||||
<p><i>Postconditions:</i> <code>val_ == val and cat_ == cat</code>. </p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>template<typename ErrorConditionEnum>
|
||||
error_condition & operator=( ErrorConditionEnum e ) noexcept;</pre>
|
||||
typename enable_if<is_error_condition_enum<ErrorConditionEnum>, error_code>::type &
|
||||
operator=( ErrorConditionEnum val );</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<ErrorConditionEnum>::value</code> is
|
||||
<code>true</code>.</p>
|
||||
<p><i>Postconditions:</i> <code>*this == make_error_condition( val )</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>void clear() noexcept;</pre>
|
||||
<p><code>void clear();</code></p>
|
||||
<blockquote>
|
||||
<p><i>Postcondition:</i> <code>value() == 0 && category() == generic_category()</code></p>
|
||||
<p><i>postcondition:</i> <code>value() == 0 && category() == posix_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>
|
||||
<pre>value_type value() const;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>val_</code>.</p>
|
||||
<p><i>Throws:</i> Nothing</p>
|
||||
</blockquote>
|
||||
<pre>const error_category & category() const noexcept;</pre>
|
||||
<pre>const error_category & category() const;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>*cat_</code>.</p>
|
||||
<p><i>Returns:</i> <code>cat_</code>.</p>
|
||||
<p>Throws: Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>string message() const;</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>category().message( value() )</code>.</p>
|
||||
<p><i>Throws:</i> Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>operator unspecified-bool-type () const;</pre>
|
||||
<blockquote>
|
||||
@@ -645,83 +603,61 @@ observers</a></h3>
|
||||
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="throws-object"><code>throws</code> object</a></h2>
|
||||
<pre>extern error_code throws;</pre>
|
||||
<p>The predefined <code>error_code</code> object <code>throws</code> is supplied
|
||||
for use as a "throw on error" tag.</p>
|
||||
<h2><a name="Semantics-of-throws">Semantics of <code>throws</code></a> object</h2>
|
||||
<p>Functions that specify an argument in the form <code>error_code& ec=throws</code>,
|
||||
with appropriate namespace qualifiers, have the following error handling
|
||||
semantics:</p>
|
||||
<blockquote>
|
||||
<p><i>Postconditions:</i></p>
|
||||
<blockquote>
|
||||
<p>If <code>&ec != &throws</code> and an error occurred:</p>
|
||||
<ul>
|
||||
<li> <code>ec.value()</code> returns the implementation specific error
|
||||
number for the particular error that occurred.</li>
|
||||
<li><code>ec.category()</code> returns the <code>
|
||||
<a href="#Class-error_category">error_category</a></code> for <code>ec.value()</code>.</li>
|
||||
</ul>
|
||||
<p>if <code>&ec != &throws</code> and an error did not occur, <code>ec.clear()</code>.</p>
|
||||
</blockquote>
|
||||
<p><i>Throws:</i></p>
|
||||
<blockquote>
|
||||
<p>If an error occurs and <code>&ec == &throws</code>, throws an exception of type
|
||||
<code><a href="#Class-system_error">system_error</a></code> or of a type
|
||||
derived from <code><a href="#Class-system_error">system_error</a></code>. The
|
||||
exception's <code>code()</code> member function returns a reference to an
|
||||
<code>error_code</code> object with the behavior specified in <i>
|
||||
Postconditions</i>.</p>
|
||||
</blockquote>
|
||||
</blockquote>
|
||||
<h2><a name="Non-member-functions">Non-member functions</a></h2>
|
||||
<pre>bool operator==( const error_code & lhs, const error_code & rhs ) noexcept;</pre>
|
||||
<h2><a name="Non-member-functions">Non-member functions</a></h2>
|
||||
<pre>bool operator==( const error_code & lhs, const error_code & rhs );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>lhs.category() == rhs.category() && lhs.value() ==
|
||||
rhs.value()</code>.</p>
|
||||
<p><i>Throws: </i>Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator==( const error_code & code, const error_condition & condition ) noexcept;
|
||||
bool operator==( const error_condition & condition, const error_code & code ) noexcept;</pre>
|
||||
<pre>bool operator==( const error_code & code, const error_condition & condition );
|
||||
bool operator==( const error_condition & condition, const error_code & code );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>code.category().equivalent( code.value(), condition )<br>
|
||||
|| condition.category().equivalent( code, condition.value() )</code>.</p>
|
||||
<p><i>Throws: </i>Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator==( const error_condition & lhs, const error_condition & rhs ) noexcept;</pre>
|
||||
<pre>bool operator==( const error_condition & lhs, const error_condition & rhs );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>lhs.category() == rhs.category() && lhs.value() ==
|
||||
rhs.value()</code>.</p>
|
||||
<p><i>Throws: </i>Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator!=( const error_code & lhs, const error_code & rhs ) noexcept;</pre>
|
||||
<pre>bool operator!=( const error_code & lhs, const error_code & rhs );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>!(lhs == rhs )</code>.</p>
|
||||
<p><i>Throws: </i>Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator!=( const error_code & code, const error_condition & condition ) noexcept;
|
||||
bool operator!=( const error_condition & condition, const error_code & code ) noexcept;</pre>
|
||||
<pre>bool operator!=( const error_code & code, const error_condition & condition );
|
||||
bool operator!=( const error_condition & condition, const error_code & code );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i><code> !( code == condition )</code>.</p>
|
||||
<p><i>Throws: </i>Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator!=( const error_condition & lhs, const error_condition & rhs ) noexcept;</pre>
|
||||
<pre>bool operator!=( const error_condition & lhs, const error_condition & rhs );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>!(lhs == rhs )</code>.</p>
|
||||
<p><i>Throws: </i>Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator<( const error_code & lhs, const error_code & rhs ) noexcept;</pre>
|
||||
<pre>bool operator<( const error_code & lhs, const error_code & rhs );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>lhs.category() < rhs.category()<br>
|
||||
|| (lhs.category() == rhs.category() && lhs.value() < rhs.value())</code>.</p>
|
||||
<p><i>Throws: </i>Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>bool operator<( const error_condition & lhs, const error_condition & rhs ) noexcept;</pre>
|
||||
<pre>bool operator<( const error_condition & lhs, const error_condition & rhs );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>lhs.category() < rhs.category()<br>
|
||||
|| (lhs.category() == rhs.category() && lhs.value() < rhs.value())</code>.</p>
|
||||
<p><i>Throws: </i>Nothing.</p>
|
||||
</blockquote>
|
||||
<pre>error_code make_error_code( errc::errc_t e ) noexcept;</pre>
|
||||
<pre>error_code make_error_code( posix_error::posix_errno e );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>error_code( e, generic_category())</code>.</p>
|
||||
<p><i>Returns:</i> <code>error_code( e, posix_category)</code>.</p>
|
||||
</blockquote>
|
||||
<pre>error_condition make_error_condition( errc::errc_t e ) noexcept;</pre>
|
||||
<pre>error_condition make_error_condition( posix_error::posix_errno e );</pre>
|
||||
<blockquote>
|
||||
<p><i>Returns:</i> <code>error_condition( static_cast<int>( e ), generic_category())</code>.</p>
|
||||
<p><i>Returns:</i> <code>error_condition( e, posix_category)</code>.</p>
|
||||
</blockquote>
|
||||
|
||||
<pre>template <class charT, class traits>
|
||||
@@ -741,7 +677,8 @@ bool operator!=( const error_condition & condition, const error_code & c
|
||||
<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
|
||||
report error conditions that have an associated error code. Such error
|
||||
conditions typically originate from the operating system or other low-level
|
||||
application program interfaces.</p>
|
||||
<blockquote>
|
||||
<pre>namespace boost
|
||||
@@ -752,13 +689,10 @@ application program interfaces.</p>
|
||||
{
|
||||
public:
|
||||
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,
|
||||
const char * what_arg );
|
||||
system_error( int ev, const error_category & ecat,
|
||||
system_error( error_code::value_type ev, const error_category & ecat,
|
||||
const std::string & what_arg );
|
||||
system_error( int ev, const error_category & ecat);
|
||||
system_error( error_code::value_type ev, const error_category & ecat);
|
||||
|
||||
const error_code & code() const throw();
|
||||
const char * what() const throw();
|
||||
@@ -772,33 +706,20 @@ application program interfaces.</p>
|
||||
<p><i>Postcondition:</i> <code>code() == ec <br>
|
||||
&& std::strcmp( this->runtime_error::what(), "" ) == 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>
|
||||
&& std::strcmp( this->runtime_error::what(), what_arg ) == 0</code></p>
|
||||
</blockquote>
|
||||
<pre>system_error( error_code ec, const std::string & 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>
|
||||
&& std::strcmp( this->runtime_error::what(), what_arg.c_str() ) == 0</code></p>
|
||||
</blockquote>
|
||||
<pre>system_error( int ev, const error_category & 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>
|
||||
&& std::strcmp( this->runtime_error::what(), what_arg ) == 0</code></p>
|
||||
</blockquote>
|
||||
<pre>system_error( int ev, const error_category & ecat,
|
||||
<pre>system_error( error_code::value_type ev, const error_category & ecat,
|
||||
const std::string & 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>
|
||||
&& std::strcmp( this->runtime_error::what(), what_arg.c_str() ) == 0</code></p>
|
||||
</blockquote>
|
||||
<pre>system_error( int ev, const error_category & ecat );</pre>
|
||||
<pre>system_error( error_code::value_type ev, const error_category & 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>
|
||||
@@ -817,15 +738,14 @@ application program interfaces.</p>
|
||||
</blockquote>
|
||||
<hr>
|
||||
|
||||
<p>Revised
|
||||
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->January 06, 2014<!--webbot bot="Timestamp" endspan i-checksum="31400" --> </font>
|
||||
</p>
|
||||
|
||||
<p>© Copyright Beman Dawes, 2006, 2007, 2008, 2013</p>
|
||||
|
||||
<p>Distributed under the Boost Software License, Version 1.0. See
|
||||
<p>© Copyright Beman Dawes, 2006, 2007<br>
|
||||
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>
|
||||
|
||||
<p>Revised
|
||||
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->November 12, 2007<!--webbot bot="Timestamp" endspan i-checksum="39581" --> </font>
|
||||
</p>
|
||||
|
||||
</body>
|
||||
|
||||
</html>
|
||||
@@ -7,8 +7,8 @@
|
||||
|
||||
// See library home page at http://www.boost.org/libs/system
|
||||
|
||||
#ifndef BOOST_SYSTEM_CERRNO_HPP
|
||||
#define BOOST_SYSTEM_CERRNO_HPP
|
||||
#ifndef BOOST_CERRNO_HPP
|
||||
#define BOOST_CERRNO_HPP
|
||||
|
||||
#include <cerrno>
|
||||
|
||||
|
||||
@@ -1,42 +0,0 @@
|
||||
// boost/system/api_config.hpp -------------------------------------------------------//
|
||||
|
||||
// Copyright Beman Dawes 2003, 2006, 2010
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
// See http://www.boost.org/libs/system for documentation.
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
// Boost.System calls operating system API functions to implement system error category
|
||||
// functions. Usually there is no question as to which API is to be used.
|
||||
//
|
||||
// In the case of MinGW or Cygwin/MinGW, however, both POSIX and Windows API's are
|
||||
// available. Chaos ensues if other code thinks one is in use when Boost.System was
|
||||
// actually built with the other. This header centralizes the API choice and prevents
|
||||
// user definition of API macros, thus elminating the possibility of mismatches and the
|
||||
// need to test configurations with little or no practical value.
|
||||
//
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
#ifndef BOOST_SYSTEM_API_CONFIG_HPP
|
||||
#define BOOST_SYSTEM_API_CONFIG_HPP
|
||||
|
||||
# if defined(BOOST_POSIX_API) || defined(BOOST_WINDOWS_API)
|
||||
# error user defined BOOST_POSIX_API or BOOST_WINDOWS_API not supported
|
||||
# endif
|
||||
|
||||
// BOOST_POSIX_API or BOOST_WINDOWS_API specify which API to use
|
||||
// Cygwin/MinGW does not predefine _WIN32.
|
||||
// Standalone MinGW and all other known Windows compilers do predefine _WIN32
|
||||
// Compilers that predefine _WIN32 or __MINGW32__ do so for Windows 64-bit builds too.
|
||||
|
||||
# if defined(_WIN32) || defined(__CYGWIN__) // Windows default, including MinGW and Cygwin
|
||||
# define BOOST_WINDOWS_API
|
||||
# else
|
||||
# define BOOST_POSIX_API
|
||||
# endif
|
||||
|
||||
#endif // BOOST_SYSTEM_API_CONFIG_HPP
|
||||
@@ -1,4 +1,4 @@
|
||||
// boost/system/config.hpp -----------------------------------------------------------//
|
||||
// boost/system/config.hpp -------------------------------------------------//
|
||||
|
||||
// Copyright Beman Dawes 2003, 2006
|
||||
|
||||
@@ -11,42 +11,47 @@
|
||||
#define BOOST_SYSTEM_CONFIG_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/predef/platform.h>
|
||||
#include <boost/system/api_config.hpp> // for BOOST_POSIX_API or BOOST_WINDOWS_API
|
||||
|
||||
// This header implements separate compilation features as described in
|
||||
// http://www.boost.org/more/separate_compilation.html
|
||||
// BOOST_POSIX_API or BOOST_WINDOWS_API specify which API to use.
|
||||
// If not specified, a sensible default will be applied.
|
||||
|
||||
// normalize macros ------------------------------------------------------------------//
|
||||
|
||||
#if !defined(BOOST_SYSTEM_DYN_LINK) && !defined(BOOST_SYSTEM_STATIC_LINK) \
|
||||
&& !defined(BOOST_ALL_DYN_LINK) && !defined(BOOST_ALL_STATIC_LINK)
|
||||
# define BOOST_SYSTEM_STATIC_LINK
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_ALL_DYN_LINK) && !defined(BOOST_SYSTEM_DYN_LINK)
|
||||
# define BOOST_SYSTEM_DYN_LINK
|
||||
#elif defined(BOOST_ALL_STATIC_LINK) && !defined(BOOST_SYSTEM_STATIC_LINK)
|
||||
# define BOOST_SYSTEM_STATIC_LINK
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_SYSTEM_DYN_LINK) && defined(BOOST_SYSTEM_STATIC_LINK)
|
||||
# error Must not define both BOOST_SYSTEM_DYN_LINK and BOOST_SYSTEM_STATIC_LINK
|
||||
#endif
|
||||
|
||||
// enable dynamic or static linking as requested --------------------------------------//
|
||||
|
||||
#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)
|
||||
# if defined(BOOST_SYSTEM_SOURCE)
|
||||
# define BOOST_SYSTEM_DECL BOOST_SYMBOL_EXPORT
|
||||
# else
|
||||
# define BOOST_SYSTEM_DECL BOOST_SYMBOL_IMPORT
|
||||
# if defined( BOOST_WINDOWS_API ) && defined( BOOST_POSIX_API )
|
||||
# error both BOOST_WINDOWS_API and BOOST_POSIX_API are defined
|
||||
# elif !defined( BOOST_WINDOWS_API ) && !defined( BOOST_POSIX_API )
|
||||
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__)
|
||||
# define BOOST_WINDOWS_API
|
||||
# else
|
||||
# define BOOST_POSIX_API
|
||||
# endif
|
||||
# endif
|
||||
|
||||
// enable dynamic linking on Windows ---------------------------------------//
|
||||
|
||||
//# if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)) && defined(__BORLANDC__) && defined(__WIN32__)
|
||||
//# error Dynamic linking Boost.System does not work for Borland; use static linking instead
|
||||
//# endif
|
||||
|
||||
#ifdef BOOST_HAS_DECLSPEC // defined in config system
|
||||
// we need to import/export our code only if the user has specifically
|
||||
// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
|
||||
// libraries to be dynamically linked, or BOOST_SYSTEM_DYN_LINK
|
||||
// if they want just this one to be dynamically liked:
|
||||
#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)
|
||||
// export if this is our own source, otherwise import:
|
||||
#ifdef BOOST_SYSTEM_SOURCE
|
||||
# define BOOST_SYSTEM_DECL __declspec(dllexport)
|
||||
#else
|
||||
# define BOOST_SYSTEM_DECL
|
||||
# define BOOST_SYSTEM_DECL __declspec(dllimport)
|
||||
#endif // BOOST_SYSTEM_SOURCE
|
||||
#endif // DYN_LINK
|
||||
#endif // BOOST_HAS_DECLSPEC
|
||||
//
|
||||
// if BOOST_SYSTEM_DECL isn't defined yet define it now:
|
||||
#ifndef BOOST_SYSTEM_DECL
|
||||
#define BOOST_SYSTEM_DECL
|
||||
#endif
|
||||
|
||||
// enable automatic library variant selection ----------------------------------------//
|
||||
// enable automatic library variant selection ------------------------------//
|
||||
|
||||
#if !defined(BOOST_SYSTEM_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SYSTEM_NO_LIB)
|
||||
//
|
||||
|
||||
@@ -7,8 +7,8 @@
|
||||
|
||||
// See library home page at http://www.boost.org/libs/system
|
||||
|
||||
#ifndef BOOST_SYSTEM_CYGWIN_ERROR_HPP
|
||||
#define BOOST_SYSTEM_CYGWIN_ERROR_HPP
|
||||
#ifndef BOOST_CYGWIN_ERROR_HPP
|
||||
#define BOOST_CYGWIN_ERROR_HPP
|
||||
|
||||
// This header is effectively empty for compiles on operating systems where
|
||||
// it is not applicable.
|
||||
@@ -23,7 +23,7 @@ namespace boost
|
||||
{
|
||||
// To construct an error_code after a API error:
|
||||
//
|
||||
// error_code( errno, system_category() )
|
||||
// error_code( errno, system_category )
|
||||
|
||||
// User code should use the portable "posix" enums for POSIX errors; this
|
||||
// allows such code to be portable to non-POSIX systems. For the non-POSIX
|
||||
@@ -46,11 +46,11 @@ namespace boost
|
||||
namespace cygwin_error
|
||||
{
|
||||
inline error_code make_error_code( cygwin_errno e )
|
||||
{ return error_code( e, system_category() ); }
|
||||
{ return error_code( e, get_system_category() ); }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif // __CYGWIN__
|
||||
|
||||
#endif // BOOST_SYSTEM_CYGWIN_ERROR_HPP
|
||||
#endif // BOOST_CYGWIN_ERROR_HPP
|
||||
|
||||
@@ -1,483 +0,0 @@
|
||||
// error_code support implementation file --------------------------------------------//
|
||||
|
||||
// Copyright Beman Dawes 2002, 2006
|
||||
// Copyright (c) Microsoft Corporation 2014
|
||||
// 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/warning_disable.hpp>
|
||||
|
||||
#include <boost/system/config.hpp>
|
||||
#include <boost/system/error_code.hpp>
|
||||
#include <boost/cerrno.hpp>
|
||||
#include <vector>
|
||||
#include <cstdlib>
|
||||
#include <cassert>
|
||||
|
||||
#include <cstring> // for strerror/strerror_r
|
||||
|
||||
# if defined( BOOST_WINDOWS_API )
|
||||
# include <boost/detail/winapi/error_codes.hpp>
|
||||
# include <boost/detail/winapi/error_handling.hpp>
|
||||
# include <boost/detail/winapi/character_code_conversion.hpp>
|
||||
# if !BOOST_PLAT_WINDOWS_RUNTIME
|
||||
# include <boost/system/detail/local_free_on_destruction.hpp>
|
||||
# endif
|
||||
# ifndef ERROR_INCORRECT_SIZE
|
||||
# define ERROR_INCORRECT_SIZE ERROR_BAD_ARGUMENTS
|
||||
# endif
|
||||
# endif
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
// standard error categories -------------------------------------------------------//
|
||||
|
||||
class generic_error_category : public error_category
|
||||
{
|
||||
public:
|
||||
generic_error_category(){}
|
||||
const char * name() const BOOST_SYSTEM_NOEXCEPT;
|
||||
std::string message( int ev ) const;
|
||||
};
|
||||
|
||||
class system_error_category : public error_category
|
||||
{
|
||||
public:
|
||||
system_error_category(){}
|
||||
const char * name() const BOOST_SYSTEM_NOEXCEPT;
|
||||
std::string message( int ev ) const;
|
||||
error_condition default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT;
|
||||
};
|
||||
|
||||
// generic_error_category implementation ---------------------------------//
|
||||
|
||||
const char * generic_error_category::name() const BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return "generic";
|
||||
}
|
||||
|
||||
std::string generic_error_category::message( int ev ) const
|
||||
{
|
||||
using namespace boost::system::errc;
|
||||
#if defined(__PGI)
|
||||
using boost::system::errc::invalid_argument;
|
||||
#endif
|
||||
|
||||
static std::string unknown_err( "Unknown error" );
|
||||
// strerror_r is preferred because it is always thread safe,
|
||||
// however, we fallback to strerror in certain cases because:
|
||||
// -- Windows doesn't provide strerror_r.
|
||||
// -- HP and Sun do provide strerror_r on newer systems, but there is
|
||||
// no way to tell if is available at runtime and in any case their
|
||||
// versions of strerror are thread safe anyhow.
|
||||
// -- Linux only sometimes provides strerror_r.
|
||||
// -- Tru64 provides strerror_r only when compiled -pthread.
|
||||
// -- VMS doesn't provide strerror_r, but on this platform, strerror is
|
||||
// thread safe.
|
||||
# if defined(BOOST_WINDOWS_API) || defined(__hpux) || defined(__sun)\
|
||||
|| (defined(__linux) && (!defined(__USE_XOPEN2K)\
|
||||
|| defined(BOOST_SYSTEM_USE_STRERROR)))\
|
||||
|| (defined(__osf__) && !defined(_REENTRANT))\
|
||||
|| (defined(__INTEGRITY))\
|
||||
|| (defined(__vms))\
|
||||
|| (defined(__QNXNTO__))
|
||||
const char * c_str = std::strerror( ev );
|
||||
return c_str
|
||||
? std::string( c_str )
|
||||
: unknown_err;
|
||||
# else // use strerror_r
|
||||
char buf[64];
|
||||
char * bp = buf;
|
||||
std::size_t sz = sizeof(buf);
|
||||
# if defined(__CYGWIN__) || defined(__USE_GNU)
|
||||
// Oddball version of strerror_r
|
||||
const char * c_str = strerror_r( ev, bp, sz );
|
||||
return c_str
|
||||
? std::string( c_str )
|
||||
: unknown_err;
|
||||
# else
|
||||
// POSIX version of strerror_r
|
||||
int result;
|
||||
for (;;)
|
||||
{
|
||||
// strerror_r returns 0 on success, otherwise ERANGE if buffer too small,
|
||||
// invalid_argument if ev not a valid error number
|
||||
# if defined (__sgi)
|
||||
const char * c_str = strerror( ev );
|
||||
result = 0;
|
||||
return c_str
|
||||
? std::string( c_str )
|
||||
: unknown_err;
|
||||
# else
|
||||
result = strerror_r( ev, bp, sz );
|
||||
# endif
|
||||
if (result == 0 )
|
||||
break;
|
||||
else
|
||||
{
|
||||
# if defined(__linux)
|
||||
// Linux strerror_r returns -1 on error, with error number in errno
|
||||
result = errno;
|
||||
# endif
|
||||
if ( result != ERANGE ) break;
|
||||
if ( sz > sizeof(buf) ) std::free( bp );
|
||||
sz *= 2;
|
||||
if ( (bp = static_cast<char*>(std::malloc( sz ))) == 0 )
|
||||
return std::string( "ENOMEM" );
|
||||
}
|
||||
}
|
||||
std::string msg;
|
||||
# ifndef BOOST_NO_EXCEPTIONS
|
||||
try
|
||||
# endif
|
||||
{
|
||||
msg = ( ( result == invalid_argument ) ? "Unknown error" : bp );
|
||||
}
|
||||
|
||||
# ifndef BOOST_NO_EXCEPTIONS
|
||||
// See ticket #2098
|
||||
catch(...)
|
||||
{
|
||||
// just eat the exception
|
||||
}
|
||||
# endif
|
||||
|
||||
if ( sz > sizeof(buf) ) std::free( bp );
|
||||
sz = 0;
|
||||
return msg;
|
||||
# endif // else POSIX version of strerror_r
|
||||
# endif // else use strerror_r
|
||||
}
|
||||
// system_error_category implementation --------------------------------------------//
|
||||
|
||||
const char * system_error_category::name() const BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return "system";
|
||||
}
|
||||
|
||||
error_condition system_error_category::default_error_condition( int ev ) const
|
||||
BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
using namespace boost::system::errc;
|
||||
#if defined(__PGI)
|
||||
using boost::system::errc::invalid_argument;
|
||||
#endif
|
||||
|
||||
# if defined(BOOST_WINDOWS_API)
|
||||
# if defined(WINAPI_FAMILY) && ((WINAPI_FAMILY & WINAPI_PARTITION_APP) != 0)
|
||||
// When using the Windows Runtime, most system errors are reported as HRESULTs.
|
||||
// We want to map the common Win32 errors to their equivalent error condition,
|
||||
// whether or not they are reported via an HRESULT.
|
||||
if ( ev < 0 ) // Check for failed HRESULTs only.
|
||||
if ( HRESULT_FACILITY( ev ) == FACILITY_WIN32 )
|
||||
ev = HRESULT_CODE( ev );
|
||||
# endif
|
||||
# endif
|
||||
|
||||
# if defined(BOOST_WINDOWS_API)
|
||||
|
||||
using namespace boost::detail::winapi; // for error codes
|
||||
|
||||
# endif
|
||||
|
||||
switch ( ev )
|
||||
{
|
||||
case 0: return make_error_condition( success );
|
||||
# if defined(BOOST_POSIX_API)
|
||||
// POSIX-like O/S -> posix_errno decode table -------------------------------------//
|
||||
case E2BIG: return make_error_condition( argument_list_too_long );
|
||||
case EACCES: return make_error_condition( permission_denied );
|
||||
case EADDRINUSE: return make_error_condition( address_in_use );
|
||||
case EADDRNOTAVAIL: return make_error_condition( address_not_available );
|
||||
case EAFNOSUPPORT: return make_error_condition( address_family_not_supported );
|
||||
case EAGAIN: return make_error_condition( resource_unavailable_try_again );
|
||||
# if EALREADY != EBUSY // EALREADY and EBUSY are the same on QNX Neutrino
|
||||
case EALREADY: return make_error_condition( connection_already_in_progress );
|
||||
# endif
|
||||
case EBADF: return make_error_condition( bad_file_descriptor );
|
||||
case EBADMSG: return make_error_condition( bad_message );
|
||||
case EBUSY: return make_error_condition( device_or_resource_busy );
|
||||
case ECANCELED: return make_error_condition( operation_canceled );
|
||||
case ECHILD: return make_error_condition( no_child_process );
|
||||
case ECONNABORTED: return make_error_condition( connection_aborted );
|
||||
case ECONNREFUSED: return make_error_condition( connection_refused );
|
||||
case ECONNRESET: return make_error_condition( connection_reset );
|
||||
case EDEADLK: return make_error_condition( resource_deadlock_would_occur );
|
||||
case EDESTADDRREQ: return make_error_condition( destination_address_required );
|
||||
case EDOM: return make_error_condition( argument_out_of_domain );
|
||||
case EEXIST: return make_error_condition( file_exists );
|
||||
case EFAULT: return make_error_condition( bad_address );
|
||||
case EFBIG: return make_error_condition( file_too_large );
|
||||
case EHOSTUNREACH: return make_error_condition( host_unreachable );
|
||||
case EIDRM: return make_error_condition( identifier_removed );
|
||||
case EILSEQ: return make_error_condition( illegal_byte_sequence );
|
||||
case EINPROGRESS: return make_error_condition( operation_in_progress );
|
||||
case EINTR: return make_error_condition( interrupted );
|
||||
case EINVAL: return make_error_condition( invalid_argument );
|
||||
case EIO: return make_error_condition( io_error );
|
||||
case EISCONN: return make_error_condition( already_connected );
|
||||
case EISDIR: return make_error_condition( is_a_directory );
|
||||
case ELOOP: return make_error_condition( too_many_symbolic_link_levels );
|
||||
case EMFILE: return make_error_condition( too_many_files_open );
|
||||
case EMLINK: return make_error_condition( too_many_links );
|
||||
case EMSGSIZE: return make_error_condition( message_size );
|
||||
case ENAMETOOLONG: return make_error_condition( filename_too_long );
|
||||
case ENETDOWN: return make_error_condition( network_down );
|
||||
case ENETRESET: return make_error_condition( network_reset );
|
||||
case ENETUNREACH: return make_error_condition( network_unreachable );
|
||||
case ENFILE: return make_error_condition( too_many_files_open_in_system );
|
||||
case ENOBUFS: return make_error_condition( no_buffer_space );
|
||||
case ENODATA: return make_error_condition( no_message_available );
|
||||
case ENODEV: return make_error_condition( no_such_device );
|
||||
case ENOENT: return make_error_condition( no_such_file_or_directory );
|
||||
case ENOEXEC: return make_error_condition( executable_format_error );
|
||||
case ENOLCK: return make_error_condition( no_lock_available );
|
||||
case ENOLINK: return make_error_condition( no_link );
|
||||
case ENOMEM: return make_error_condition( not_enough_memory );
|
||||
case ENOMSG: return make_error_condition( no_message );
|
||||
case ENOPROTOOPT: return make_error_condition( no_protocol_option );
|
||||
case ENOSPC: return make_error_condition( no_space_on_device );
|
||||
case ENOSR: return make_error_condition( no_stream_resources );
|
||||
case ENOSTR: return make_error_condition( not_a_stream );
|
||||
case ENOSYS: return make_error_condition( function_not_supported );
|
||||
case ENOTCONN: return make_error_condition( not_connected );
|
||||
case ENOTDIR: return make_error_condition( not_a_directory );
|
||||
# if ENOTEMPTY != EEXIST // AIX treats ENOTEMPTY and EEXIST as the same value
|
||||
case ENOTEMPTY: return make_error_condition( directory_not_empty );
|
||||
# endif // ENOTEMPTY != EEXIST
|
||||
# if ENOTRECOVERABLE != ECONNRESET // the same on some Broadcom chips
|
||||
case ENOTRECOVERABLE: return make_error_condition( state_not_recoverable );
|
||||
# endif // ENOTRECOVERABLE != ECONNRESET
|
||||
case ENOTSOCK: return make_error_condition( not_a_socket );
|
||||
case ENOTSUP: return make_error_condition( not_supported );
|
||||
case ENOTTY: return make_error_condition( inappropriate_io_control_operation );
|
||||
case ENXIO: return make_error_condition( no_such_device_or_address );
|
||||
# if EOPNOTSUPP != ENOTSUP
|
||||
case EOPNOTSUPP: return make_error_condition( operation_not_supported );
|
||||
# endif // EOPNOTSUPP != ENOTSUP
|
||||
case EOVERFLOW: return make_error_condition( value_too_large );
|
||||
# if EOWNERDEAD != ECONNABORTED // the same on some Broadcom chips
|
||||
case EOWNERDEAD: return make_error_condition( owner_dead );
|
||||
# endif // EOWNERDEAD != ECONNABORTED
|
||||
case EPERM: return make_error_condition( operation_not_permitted );
|
||||
case EPIPE: return make_error_condition( broken_pipe );
|
||||
case EPROTO: return make_error_condition( protocol_error );
|
||||
case EPROTONOSUPPORT: return make_error_condition( protocol_not_supported );
|
||||
case EPROTOTYPE: return make_error_condition( wrong_protocol_type );
|
||||
case ERANGE: return make_error_condition( result_out_of_range );
|
||||
case EROFS: return make_error_condition( read_only_file_system );
|
||||
case ESPIPE: return make_error_condition( invalid_seek );
|
||||
case ESRCH: return make_error_condition( no_such_process );
|
||||
case ETIME: return make_error_condition( stream_timeout );
|
||||
case ETIMEDOUT: return make_error_condition( timed_out );
|
||||
case ETXTBSY: return make_error_condition( text_file_busy );
|
||||
# if EAGAIN != EWOULDBLOCK
|
||||
case EWOULDBLOCK: return make_error_condition( operation_would_block );
|
||||
# endif // EAGAIN != EWOULDBLOCK
|
||||
case EXDEV: return make_error_condition( cross_device_link );
|
||||
#else
|
||||
// Windows system -> posix_errno decode table ---------------------------//
|
||||
// see WinError.h comments for descriptions of errors
|
||||
case ERROR_ACCESS_DENIED_: return make_error_condition( permission_denied );
|
||||
case ERROR_ALREADY_EXISTS_: return make_error_condition( file_exists );
|
||||
case ERROR_BAD_UNIT_: return make_error_condition( no_such_device );
|
||||
case ERROR_BUFFER_OVERFLOW_: return make_error_condition( filename_too_long );
|
||||
case ERROR_BUSY_: return make_error_condition( device_or_resource_busy );
|
||||
case ERROR_BUSY_DRIVE_: return make_error_condition( device_or_resource_busy );
|
||||
case ERROR_CANNOT_MAKE_: return make_error_condition( permission_denied );
|
||||
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_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 );
|
||||
case ERROR_DIR_NOT_EMPTY_: return make_error_condition( directory_not_empty );
|
||||
case ERROR_DIRECTORY_: return make_error_condition( invalid_argument );\
|
||||
// WinError.h: "The directory name is invalid"
|
||||
case ERROR_DISK_FULL_: return make_error_condition( no_space_on_device );
|
||||
case ERROR_FILE_EXISTS_: return make_error_condition( file_exists );
|
||||
case ERROR_FILE_NOT_FOUND_: return make_error_condition( no_such_file_or_directory );
|
||||
case ERROR_HANDLE_DISK_FULL_: return make_error_condition( no_space_on_device );
|
||||
case ERROR_INVALID_ACCESS_: return make_error_condition( permission_denied );
|
||||
case ERROR_INVALID_DRIVE_: return make_error_condition( no_such_device );
|
||||
case ERROR_INVALID_FUNCTION_: return make_error_condition( function_not_supported );
|
||||
case ERROR_INVALID_HANDLE_: return make_error_condition( invalid_argument );
|
||||
case ERROR_INVALID_NAME_: return make_error_condition( invalid_argument );
|
||||
case ERROR_LOCK_VIOLATION_: return make_error_condition( no_lock_available );
|
||||
case ERROR_LOCKED_: return make_error_condition( no_lock_available );
|
||||
case ERROR_NEGATIVE_SEEK_: return make_error_condition( invalid_argument );
|
||||
case ERROR_NOACCESS_: return make_error_condition( permission_denied );
|
||||
case ERROR_NOT_ENOUGH_MEMORY_: return make_error_condition( not_enough_memory );
|
||||
case ERROR_NOT_READY_: return make_error_condition( resource_unavailable_try_again );
|
||||
case ERROR_NOT_SAME_DEVICE_: return make_error_condition( cross_device_link );
|
||||
case ERROR_OPEN_FAILED_: return make_error_condition( io_error );
|
||||
case ERROR_OPEN_FILES_: return make_error_condition( device_or_resource_busy );
|
||||
case ERROR_OPERATION_ABORTED_: return make_error_condition( operation_canceled );
|
||||
case ERROR_OUTOFMEMORY_: return make_error_condition( not_enough_memory );
|
||||
case ERROR_PATH_NOT_FOUND_: return make_error_condition( no_such_file_or_directory );
|
||||
case ERROR_READ_FAULT_: return make_error_condition( io_error );
|
||||
case ERROR_RETRY_: return make_error_condition( resource_unavailable_try_again );
|
||||
case ERROR_SEEK_: return make_error_condition( io_error );
|
||||
case ERROR_SHARING_VIOLATION_: return make_error_condition( permission_denied );
|
||||
case ERROR_TOO_MANY_OPEN_FILES_: return make_error_condition( too_many_files_open );
|
||||
case ERROR_WRITE_FAULT_: return make_error_condition( io_error );
|
||||
case ERROR_WRITE_PROTECT_: return make_error_condition( permission_denied );
|
||||
case WSAEACCES_: return make_error_condition( permission_denied );
|
||||
case WSAEADDRINUSE_: return make_error_condition( address_in_use );
|
||||
case WSAEADDRNOTAVAIL_: return make_error_condition( address_not_available );
|
||||
case WSAEAFNOSUPPORT_: return make_error_condition( address_family_not_supported );
|
||||
case WSAEALREADY_: return make_error_condition( connection_already_in_progress );
|
||||
case WSAEBADF_: return make_error_condition( bad_file_descriptor );
|
||||
case WSAECONNABORTED_: return make_error_condition( connection_aborted );
|
||||
case WSAECONNREFUSED_: return make_error_condition( connection_refused );
|
||||
case WSAECONNRESET_: return make_error_condition( connection_reset );
|
||||
case WSAEDESTADDRREQ_: return make_error_condition( destination_address_required );
|
||||
case WSAEFAULT_: return make_error_condition( bad_address );
|
||||
case WSAEHOSTUNREACH_: return make_error_condition( host_unreachable );
|
||||
case WSAEINPROGRESS_: return make_error_condition( operation_in_progress );
|
||||
case WSAEINTR_: return make_error_condition( interrupted );
|
||||
case WSAEINVAL_: return make_error_condition( invalid_argument );
|
||||
case WSAEISCONN_: return make_error_condition( already_connected );
|
||||
case WSAEMFILE_: return make_error_condition( too_many_files_open );
|
||||
case WSAEMSGSIZE_: return make_error_condition( message_size );
|
||||
case WSAENAMETOOLONG_: return make_error_condition( filename_too_long );
|
||||
case WSAENETDOWN_: return make_error_condition( network_down );
|
||||
case WSAENETRESET_: return make_error_condition( network_reset );
|
||||
case WSAENETUNREACH_: return make_error_condition( network_unreachable );
|
||||
case WSAENOBUFS_: return make_error_condition( no_buffer_space );
|
||||
case WSAENOPROTOOPT_: return make_error_condition( no_protocol_option );
|
||||
case WSAENOTCONN_: return make_error_condition( not_connected );
|
||||
case WSAENOTSOCK_: return make_error_condition( not_a_socket );
|
||||
case WSAEOPNOTSUPP_: return make_error_condition( operation_not_supported );
|
||||
case WSAEPROTONOSUPPORT_: return make_error_condition( protocol_not_supported );
|
||||
case WSAEPROTOTYPE_: return make_error_condition( wrong_protocol_type );
|
||||
case WSAETIMEDOUT_: return make_error_condition( timed_out );
|
||||
case WSAEWOULDBLOCK_: return make_error_condition( operation_would_block );
|
||||
#endif
|
||||
default: return error_condition( ev, system_category() );
|
||||
}
|
||||
}
|
||||
|
||||
# if !defined( BOOST_WINDOWS_API )
|
||||
|
||||
std::string system_error_category::message( int ev ) const
|
||||
{
|
||||
return generic_category().message( ev );
|
||||
}
|
||||
# else
|
||||
|
||||
std::string system_error_category::message( int ev ) const
|
||||
{
|
||||
#if defined(UNDER_CE) || BOOST_PLAT_WINDOWS_RUNTIME || defined(BOOST_NO_ANSI_APIS)
|
||||
std::wstring buf(128, wchar_t());
|
||||
for (;;)
|
||||
{
|
||||
boost::detail::winapi::DWORD_ retval = boost::detail::winapi::FormatMessageW(
|
||||
boost::detail::winapi::FORMAT_MESSAGE_FROM_SYSTEM_ |
|
||||
boost::detail::winapi::FORMAT_MESSAGE_IGNORE_INSERTS_,
|
||||
NULL,
|
||||
ev,
|
||||
boost::detail::winapi::MAKELANGID_(boost::detail::winapi::LANG_NEUTRAL_,
|
||||
boost::detail::winapi::SUBLANG_DEFAULT_), // Default language
|
||||
&buf[0],
|
||||
buf.size(),
|
||||
NULL
|
||||
);
|
||||
|
||||
if (retval > 0)
|
||||
{
|
||||
buf.resize(retval);
|
||||
break;
|
||||
}
|
||||
else if (boost::detail::winapi::GetLastError() !=
|
||||
boost::detail::winapi::ERROR_INSUFFICIENT_BUFFER_)
|
||||
{
|
||||
return std::string("Unknown error");
|
||||
}
|
||||
else
|
||||
{
|
||||
buf.resize(buf.size() + buf.size() / 2);
|
||||
}
|
||||
}
|
||||
|
||||
int num_chars = (buf.size() + 1) * 2;
|
||||
boost::detail::winapi::LPSTR_ narrow_buffer =
|
||||
(boost::detail::winapi::LPSTR_)_alloca(num_chars);
|
||||
if (boost::detail::winapi::WideCharToMultiByte(boost::detail::winapi::CP_ACP_, 0,
|
||||
buf.c_str(), -1, narrow_buffer, num_chars, NULL, NULL) == 0)
|
||||
{
|
||||
return std::string("Unknown error");
|
||||
}
|
||||
|
||||
std::string str( narrow_buffer );
|
||||
#else
|
||||
boost::detail::winapi::LPVOID_ lpMsgBuf = 0;
|
||||
boost::detail::winapi::DWORD_ retval = boost::detail::winapi::FormatMessageA(
|
||||
boost::detail::winapi::FORMAT_MESSAGE_ALLOCATE_BUFFER_ |
|
||||
boost::detail::winapi::FORMAT_MESSAGE_FROM_SYSTEM_ |
|
||||
boost::detail::winapi::FORMAT_MESSAGE_IGNORE_INSERTS_,
|
||||
NULL,
|
||||
ev,
|
||||
boost::detail::winapi::MAKELANGID_(boost::detail::winapi::LANG_NEUTRAL_,
|
||||
boost::detail::winapi::SUBLANG_DEFAULT_), // Default language
|
||||
(boost::detail::winapi::LPSTR_) &lpMsgBuf,
|
||||
0,
|
||||
NULL
|
||||
);
|
||||
detail::local_free_on_destruction lfod(lpMsgBuf);
|
||||
if (retval == 0)
|
||||
return std::string("Unknown error");
|
||||
|
||||
std::string str(static_cast<boost::detail::winapi::LPCSTR_>(lpMsgBuf));
|
||||
# endif
|
||||
while ( str.size()
|
||||
&& (str[str.size()-1] == '\n' || str[str.size()-1] == '\r') )
|
||||
str.erase( str.size()-1 );
|
||||
if ( str.size() && str[str.size()-1] == '.' )
|
||||
{ str.erase( str.size()-1 ); }
|
||||
return str;
|
||||
}
|
||||
# endif
|
||||
|
||||
} // unnamed namespace
|
||||
|
||||
|
||||
# ifndef BOOST_SYSTEM_NO_DEPRECATED
|
||||
BOOST_SYSTEM_DECL error_code throws; // "throw on error" special error_code;
|
||||
// note that it doesn't matter if this
|
||||
// isn't initialized before use since
|
||||
// the only use is to take its
|
||||
// address for comparison purposes
|
||||
# endif
|
||||
|
||||
# ifdef BOOST_ERROR_CODE_HEADER_ONLY
|
||||
# define BOOST_SYSTEM_LINKAGE inline
|
||||
# else
|
||||
# define BOOST_SYSTEM_LINKAGE BOOST_SYSTEM_DECL
|
||||
# endif
|
||||
|
||||
BOOST_SYSTEM_LINKAGE const error_category & system_category() BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
static const system_error_category system_category_const;
|
||||
return system_category_const;
|
||||
}
|
||||
|
||||
BOOST_SYSTEM_LINKAGE const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
static const generic_error_category generic_category_const;
|
||||
return generic_category_const;
|
||||
}
|
||||
|
||||
} // namespace system
|
||||
} // namespace boost
|
||||
@@ -1,42 +0,0 @@
|
||||
// local_free_on_exit.hpp ------------------------------------------------------------//
|
||||
|
||||
// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
// Copyright (c) 2010 Beman Dawes
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
// This is derived from boost/asio/detail/local_free_on_block_exit.hpp to avoid
|
||||
// a dependency on asio. Thanks to Chris Kohlhoff for pointing it out.
|
||||
|
||||
#ifndef BOOST_SYSTEM_LOCAL_FREE_ON_EXIT_HPP
|
||||
#define BOOST_SYSTEM_LOCAL_FREE_ON_EXIT_HPP
|
||||
|
||||
#include <boost/detail/winapi/local_memory.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace system {
|
||||
namespace detail {
|
||||
|
||||
class local_free_on_destruction
|
||||
{
|
||||
public:
|
||||
explicit local_free_on_destruction(void* p)
|
||||
: p_(p) {}
|
||||
|
||||
~local_free_on_destruction()
|
||||
{
|
||||
boost::detail::winapi::LocalFree(p_);
|
||||
}
|
||||
|
||||
private:
|
||||
void* p_;
|
||||
local_free_on_destruction(const local_free_on_destruction&); // = deleted
|
||||
local_free_on_destruction& operator=(const local_free_on_destruction&); // = deleted
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace system
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_SYSTEM_LOCAL_FREE_ON_EXIT_HPP
|
||||
+128
-355
@@ -1,4 +1,4 @@
|
||||
// boost/system/error_code.hpp -------------------------------------------------------//
|
||||
// boost/system/error_code.hpp ---------------------------------------------//
|
||||
|
||||
// Copyright Beman Dawes 2006, 2007
|
||||
// Copyright Christoper Kohlhoff 2007
|
||||
@@ -8,12 +8,13 @@
|
||||
|
||||
// See library home page at http://www.boost.org/libs/system
|
||||
|
||||
#ifndef BOOST_SYSTEM_ERROR_CODE_HPP
|
||||
#define BOOST_SYSTEM_ERROR_CODE_HPP
|
||||
#ifndef BOOST_ERROR_CODE_HPP
|
||||
#define BOOST_ERROR_CODE_HPP
|
||||
|
||||
#include <boost/system/config.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/operators.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <ostream>
|
||||
@@ -22,32 +23,23 @@
|
||||
#include <functional>
|
||||
|
||||
// TODO: undef these macros if not already defined
|
||||
#include <boost/cerrno.hpp>
|
||||
#include <boost/cerrno.hpp>
|
||||
|
||||
#if !defined(BOOST_POSIX_API) && !defined(BOOST_WINDOWS_API)
|
||||
# error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
|
||||
#include <system_error>
|
||||
#endif
|
||||
|
||||
#include <boost/config/abi_prefix.hpp> // must be the last #include
|
||||
|
||||
#ifndef BOOST_SYSTEM_NOEXCEPT
|
||||
#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT
|
||||
#endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
|
||||
class error_code; // values defined by the operating system
|
||||
class error_condition; // portable generic values defined below, but ultimately
|
||||
// based on the POSIX standard
|
||||
class error_code;
|
||||
class error_condition;
|
||||
|
||||
// "Concept" helpers -------------------------------------------------------------//
|
||||
// "Concept" helpers ---------------------------------------------------//
|
||||
|
||||
template< class T >
|
||||
struct is_error_code_enum { static const bool value = false; };
|
||||
@@ -55,11 +47,11 @@ namespace boost
|
||||
template< class T >
|
||||
struct is_error_condition_enum { static const bool value = false; };
|
||||
|
||||
// generic error_conditions ------------------------------------------------------//
|
||||
// portable error_conditions -------------------------------------------//
|
||||
|
||||
namespace errc
|
||||
namespace posix_error
|
||||
{
|
||||
enum errc_t
|
||||
enum posix_errno
|
||||
{
|
||||
success = 0,
|
||||
address_family_not_supported = EAFNOSUPPORT,
|
||||
@@ -137,25 +129,24 @@ namespace boost
|
||||
too_many_files_open_in_system = ENFILE,
|
||||
too_many_files_open = EMFILE,
|
||||
too_many_links = EMLINK,
|
||||
too_many_symbolic_link_levels = ELOOP,
|
||||
too_many_synbolic_link_levels = ELOOP,
|
||||
value_too_large = EOVERFLOW,
|
||||
wrong_protocol_type = EPROTOTYPE
|
||||
};
|
||||
|
||||
} // namespace errc
|
||||
} // namespace posix_error
|
||||
|
||||
# ifndef BOOST_SYSTEM_NO_DEPRECATED
|
||||
namespace posix = errc;
|
||||
namespace posix_error = errc;
|
||||
namespace posix = posix_error;
|
||||
# endif
|
||||
|
||||
template<> struct is_error_condition_enum<errc::errc_t>
|
||||
template<> struct is_error_condition_enum<posix_error::posix_errno>
|
||||
{ static const bool value = true; };
|
||||
|
||||
|
||||
// --------------------------------------------------------------------------------//
|
||||
// ----------------------------------------------------------------------//
|
||||
|
||||
// Operating system specific interfaces ------------------------------------------//
|
||||
// Operating system specific interfaces --------------------------------//
|
||||
|
||||
|
||||
// The interface is divided into general and system-specific portions to
|
||||
@@ -183,209 +174,97 @@ namespace boost
|
||||
// These headers are effectively empty for compiles on operating systems
|
||||
// where they are not applicable.
|
||||
|
||||
// --------------------------------------------------------------------------------//
|
||||
|
||||
class error_category;
|
||||
|
||||
// predefined error categories ---------------------------------------------------//
|
||||
|
||||
#ifdef BOOST_ERROR_CODE_HEADER_ONLY
|
||||
inline const error_category & system_category() BOOST_SYSTEM_NOEXCEPT;
|
||||
inline const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT;
|
||||
#else
|
||||
BOOST_SYSTEM_DECL const error_category & system_category() BOOST_SYSTEM_NOEXCEPT;
|
||||
BOOST_SYSTEM_DECL const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT;
|
||||
#endif
|
||||
// deprecated synonyms ------------------------------------------------------------//
|
||||
|
||||
#ifndef BOOST_SYSTEM_NO_DEPRECATED
|
||||
inline const error_category & get_system_category() { return system_category(); }
|
||||
inline const error_category & get_generic_category() { return generic_category(); }
|
||||
inline const error_category & get_posix_category() { return generic_category(); }
|
||||
static const error_category & posix_category BOOST_ATTRIBUTE_UNUSED
|
||||
= generic_category();
|
||||
static const error_category & errno_ecat BOOST_ATTRIBUTE_UNUSED
|
||||
= generic_category();
|
||||
static const error_category & native_ecat BOOST_ATTRIBUTE_UNUSED
|
||||
= system_category();
|
||||
#endif
|
||||
// ----------------------------------------------------------------------//
|
||||
|
||||
// class error_category ------------------------------------------------//
|
||||
|
||||
class error_category : public noncopyable
|
||||
{
|
||||
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
|
||||
|
||||
private:
|
||||
|
||||
class std_category: public std::error_category
|
||||
{
|
||||
private:
|
||||
|
||||
boost::system::error_category const * pc_;
|
||||
|
||||
public:
|
||||
|
||||
explicit std_category( boost::system::error_category const * pc ): pc_( pc )
|
||||
{
|
||||
}
|
||||
|
||||
virtual const char * name() const BOOST_NOEXCEPT
|
||||
{
|
||||
return pc_->name();
|
||||
}
|
||||
|
||||
virtual std::string message( int ev ) const
|
||||
{
|
||||
return pc_->message( ev );
|
||||
}
|
||||
|
||||
virtual std::error_condition default_error_condition( int ev ) const
|
||||
BOOST_NOEXCEPT;
|
||||
virtual bool equivalent( int code, const std::error_condition & condition ) const
|
||||
BOOST_NOEXCEPT;
|
||||
virtual bool equivalent( const std::error_code & code, int condition ) const
|
||||
BOOST_NOEXCEPT;
|
||||
};
|
||||
|
||||
std_category std_cat_;
|
||||
|
||||
public:
|
||||
|
||||
error_category() BOOST_SYSTEM_NOEXCEPT: std_cat_( this ) {}
|
||||
|
||||
operator std::error_category const & () const BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
// do not map generic to std::generic on purpose; occasionally,
|
||||
// there are two std::generic categories in a program, which leads
|
||||
// to error codes/conditions mysteriously not being equal to themselves
|
||||
return std_cat_;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
// to maintain ABI compatibility between 03 and 11,
|
||||
// define a class with the same layout
|
||||
|
||||
private:
|
||||
|
||||
class std_category
|
||||
{
|
||||
private:
|
||||
|
||||
boost::system::error_category const * pc_;
|
||||
|
||||
public:
|
||||
|
||||
explicit std_category( boost::system::error_category const * pc ): pc_( pc )
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~std_category() {}
|
||||
|
||||
virtual const char * name() const BOOST_NOEXCEPT
|
||||
{
|
||||
return pc_->name();
|
||||
}
|
||||
|
||||
// we can't define message, because (1) it returns an std::string,
|
||||
// which can be different between 03 and 11, and (2) on mingw, there
|
||||
// are actually two `message` functions, not one, so it doesn't work
|
||||
// even if we do
|
||||
|
||||
// neither can we define default_error_condition or equivalent
|
||||
|
||||
// if these functions are called, it will crash, but that's still
|
||||
// better than the alternative of having the class layout change
|
||||
};
|
||||
|
||||
std_category std_cat_;
|
||||
|
||||
public:
|
||||
|
||||
error_category() BOOST_SYSTEM_NOEXCEPT: std_cat_( this ) {}
|
||||
|
||||
#endif
|
||||
|
||||
public:
|
||||
virtual ~error_category(){}
|
||||
virtual inline const char * name() const; // see implementation note below
|
||||
virtual inline std::string message( int ev ) const; // see implementation note below
|
||||
virtual inline error_condition default_error_condition( int ev ) const;
|
||||
virtual inline bool equivalent( int code, const error_condition & condition ) const;
|
||||
virtual inline bool equivalent( const error_code & code, int condition ) const;
|
||||
|
||||
virtual const char * name() const BOOST_SYSTEM_NOEXCEPT = 0;
|
||||
virtual std::string message( int ev ) const = 0;
|
||||
inline virtual error_condition default_error_condition( int ev ) const
|
||||
BOOST_SYSTEM_NOEXCEPT;
|
||||
inline virtual bool equivalent( int code,
|
||||
const error_condition & condition ) const
|
||||
BOOST_SYSTEM_NOEXCEPT;
|
||||
inline virtual bool equivalent( const error_code & code,
|
||||
int condition ) const BOOST_SYSTEM_NOEXCEPT;
|
||||
|
||||
bool operator==(const error_category & rhs) const BOOST_SYSTEM_NOEXCEPT
|
||||
{ return this == &rhs; }
|
||||
bool operator!=(const error_category & rhs) const BOOST_SYSTEM_NOEXCEPT
|
||||
{ return this != &rhs; }
|
||||
bool operator<( const error_category & rhs ) const BOOST_SYSTEM_NOEXCEPT
|
||||
{ return std::less<const error_category*>()( this, &rhs ); }
|
||||
bool operator==(const error_category & rhs) const { return this == &rhs; }
|
||||
bool operator!=(const error_category & rhs) const { return this != &rhs; }
|
||||
bool operator<( const error_category & rhs ) const
|
||||
{
|
||||
return std::less<const error_category*>()( this, &rhs );
|
||||
}
|
||||
};
|
||||
|
||||
// class error_condition ---------------------------------------------------------//
|
||||
// predefined error categories -----------------------------------------//
|
||||
|
||||
// error_conditions are portable, error_codes are system or library specific
|
||||
BOOST_SYSTEM_DECL const error_category & get_system_category();
|
||||
BOOST_SYSTEM_DECL const error_category & get_posix_category();
|
||||
|
||||
static const error_category & system_category = get_system_category();
|
||||
static const error_category & posix_category = get_posix_category();
|
||||
|
||||
# ifndef BOOST_SYSTEM_NO_DEPRECATED
|
||||
// deprecated synonyms
|
||||
static const error_category & errno_ecat = get_posix_category();
|
||||
static const error_category & native_ecat = get_system_category();
|
||||
# endif
|
||||
|
||||
// class error_condition -----------------------------------------------//
|
||||
|
||||
// error_conditions are portable, error_codes are system or lib specific
|
||||
|
||||
class error_condition
|
||||
{
|
||||
public:
|
||||
|
||||
// constructors:
|
||||
error_condition() BOOST_SYSTEM_NOEXCEPT : m_val(0), m_cat(&generic_category()) {}
|
||||
error_condition( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
|
||||
: m_val(val), m_cat(&cat) {}
|
||||
error_condition() : m_val(0), m_cat(&get_posix_category()) {}
|
||||
error_condition( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
|
||||
|
||||
template <class ErrorConditionEnum>
|
||||
error_condition(ErrorConditionEnum e,
|
||||
typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type*
|
||||
= 0) BOOST_SYSTEM_NOEXCEPT
|
||||
template <class ConditionEnum>
|
||||
error_condition(ConditionEnum e,
|
||||
typename boost::enable_if<is_error_condition_enum<ConditionEnum> >::type* = 0)
|
||||
{
|
||||
*this = make_error_condition(e);
|
||||
}
|
||||
|
||||
// modifiers:
|
||||
|
||||
void assign( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
void assign( int val, const error_category & cat )
|
||||
{
|
||||
m_val = val;
|
||||
m_cat = &cat;
|
||||
}
|
||||
|
||||
template<typename ErrorConditionEnum>
|
||||
typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>,
|
||||
error_condition>::type &
|
||||
operator=( ErrorConditionEnum val ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
|
||||
template<typename ConditionEnum>
|
||||
typename boost::enable_if<is_error_condition_enum<ConditionEnum>, error_condition>::type &
|
||||
operator=( ConditionEnum val )
|
||||
{
|
||||
*this = make_error_condition(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void clear() BOOST_SYSTEM_NOEXCEPT
|
||||
void clear()
|
||||
{
|
||||
m_val = 0;
|
||||
m_cat = &generic_category();
|
||||
m_cat = &get_posix_category();
|
||||
}
|
||||
|
||||
// observers:
|
||||
int value() const BOOST_SYSTEM_NOEXCEPT { return m_val; }
|
||||
const error_category & category() const BOOST_SYSTEM_NOEXCEPT { return *m_cat; }
|
||||
int value() const { return m_val; }
|
||||
const error_category & category() const { return *m_cat; }
|
||||
std::string message() const { return m_cat->message(value()); }
|
||||
|
||||
typedef void (*unspecified_bool_type)();
|
||||
static void unspecified_bool_true() {}
|
||||
|
||||
operator unspecified_bool_type() const BOOST_SYSTEM_NOEXCEPT // true if error
|
||||
{
|
||||
operator unspecified_bool_type() const // true if error
|
||||
{
|
||||
return m_val == 0 ? 0 : unspecified_bool_true;
|
||||
}
|
||||
|
||||
bool operator!() const BOOST_SYSTEM_NOEXCEPT // true if no error
|
||||
bool operator!() const // true if no error
|
||||
{
|
||||
return m_val == 0;
|
||||
}
|
||||
@@ -394,13 +273,13 @@ namespace boost
|
||||
// the more symmetrical non-member syntax allows enum
|
||||
// conversions work for both rhs and lhs.
|
||||
inline friend bool operator==( const error_condition & lhs,
|
||||
const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
const error_condition & rhs )
|
||||
{
|
||||
return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
|
||||
}
|
||||
}
|
||||
|
||||
inline friend bool operator<( const error_condition & lhs,
|
||||
const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
const error_condition & rhs )
|
||||
// the more symmetrical non-member syntax allows enum
|
||||
// conversions work for both rhs and lhs.
|
||||
{
|
||||
@@ -408,22 +287,13 @@ namespace boost
|
||||
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
|
||||
|
||||
operator std::error_condition () const BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return std::error_condition( value(), category() );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
private:
|
||||
int m_val;
|
||||
const error_category * m_cat;
|
||||
|
||||
};
|
||||
|
||||
// class error_code --------------------------------------------------------------//
|
||||
// class error_code ----------------------------------------------------//
|
||||
|
||||
// We want error_code to be a value type that can be copied without slicing
|
||||
// and without requiring heap allocation, but we also want it to have
|
||||
@@ -436,62 +306,59 @@ namespace boost
|
||||
public:
|
||||
|
||||
// constructors:
|
||||
error_code() BOOST_SYSTEM_NOEXCEPT : m_val(0), m_cat(&system_category()) {}
|
||||
error_code( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
|
||||
: m_val(val), m_cat(&cat) {}
|
||||
error_code() : m_val(0), m_cat(&get_system_category()) {}
|
||||
error_code( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
|
||||
|
||||
template <class ErrorCodeEnum>
|
||||
error_code(ErrorCodeEnum e,
|
||||
typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0)
|
||||
BOOST_SYSTEM_NOEXCEPT
|
||||
template <class CodeEnum>
|
||||
error_code(CodeEnum e,
|
||||
typename boost::enable_if<is_error_code_enum<CodeEnum> >::type* = 0)
|
||||
{
|
||||
*this = make_error_code(e);
|
||||
}
|
||||
|
||||
// modifiers:
|
||||
void assign( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
void assign( int val, const error_category & cat )
|
||||
{
|
||||
m_val = val;
|
||||
m_cat = &cat;
|
||||
}
|
||||
|
||||
template<typename ErrorCodeEnum>
|
||||
typename boost::enable_if<is_error_code_enum<ErrorCodeEnum>, error_code>::type &
|
||||
operator=( ErrorCodeEnum val ) BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
|
||||
template<typename CodeEnum>
|
||||
typename boost::enable_if<is_error_code_enum<CodeEnum>, error_code>::type &
|
||||
operator=( CodeEnum val )
|
||||
{
|
||||
*this = make_error_code(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void clear() BOOST_SYSTEM_NOEXCEPT
|
||||
void clear()
|
||||
{
|
||||
m_val = 0;
|
||||
m_cat = &system_category();
|
||||
m_cat = &get_system_category();
|
||||
}
|
||||
|
||||
// observers:
|
||||
int value() const BOOST_SYSTEM_NOEXCEPT { return m_val; }
|
||||
const error_category & category() const BOOST_SYSTEM_NOEXCEPT { return *m_cat; }
|
||||
error_condition default_error_condition() const BOOST_SYSTEM_NOEXCEPT
|
||||
{ return m_cat->default_error_condition(value()); }
|
||||
int value() const { return m_val; }
|
||||
const error_category & category() const { return *m_cat; }
|
||||
error_condition default_error_condition() const { return m_cat->default_error_condition(value()); }
|
||||
std::string message() const { return m_cat->message(value()); }
|
||||
|
||||
typedef void (*unspecified_bool_type)();
|
||||
static void unspecified_bool_true() {}
|
||||
|
||||
operator unspecified_bool_type() const BOOST_SYSTEM_NOEXCEPT // true if error
|
||||
{
|
||||
operator unspecified_bool_type() const // true if error
|
||||
{
|
||||
return m_val == 0 ? 0 : unspecified_bool_true;
|
||||
}
|
||||
|
||||
bool operator!() const BOOST_SYSTEM_NOEXCEPT // true if no error
|
||||
bool operator!() const // true if no error
|
||||
{
|
||||
return m_val == 0;
|
||||
}
|
||||
|
||||
// relationals:
|
||||
inline friend bool operator==( const error_code & lhs,
|
||||
const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
const error_code & rhs )
|
||||
// the more symmetrical non-member syntax allows enum
|
||||
// conversions work for both rhs and lhs.
|
||||
{
|
||||
@@ -499,94 +366,60 @@ namespace boost
|
||||
}
|
||||
|
||||
inline friend bool operator<( const error_code & lhs,
|
||||
const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
const error_code & rhs )
|
||||
// the more symmetrical non-member syntax allows enum
|
||||
// conversions work for both rhs and lhs.
|
||||
{
|
||||
return lhs.m_cat < rhs.m_cat
|
||||
|| (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
|
||||
|
||||
operator std::error_code () const BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
return std::error_code( value(), category() );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
private:
|
||||
|
||||
private:
|
||||
int m_val;
|
||||
const error_category * m_cat;
|
||||
|
||||
};
|
||||
|
||||
// predefined error_code object used as "throw on error" tag
|
||||
# ifndef BOOST_SYSTEM_NO_DEPRECATED
|
||||
BOOST_SYSTEM_DECL extern error_code throws;
|
||||
# endif
|
||||
|
||||
// Moving from a "throws" object to a "throws" function without breaking
|
||||
// existing code is a bit of a problem. The workaround is to place the
|
||||
// "throws" function in namespace boost rather than namespace boost::system.
|
||||
|
||||
} // namespace system
|
||||
|
||||
namespace detail { inline system::error_code * throws() { return 0; } }
|
||||
// Misuse of the error_code object is turned into a noisy failure by
|
||||
// poisoning the reference. This particular implementation doesn't
|
||||
// produce warnings or errors from popular compilers, is very efficient
|
||||
// (as determined by inspecting generated code), and does not suffer
|
||||
// from order of initialization problems. In practice, it also seems
|
||||
// cause user function error handling implementation errors to be detected
|
||||
// very early in the development cycle.
|
||||
|
||||
inline system::error_code & throws()
|
||||
{ return *detail::throws(); }
|
||||
|
||||
namespace system
|
||||
{
|
||||
// non-member functions ------------------------------------------------//
|
||||
|
||||
inline bool operator!=( const error_code & lhs,
|
||||
const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
const error_code & rhs )
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
inline bool operator!=( const error_condition & lhs,
|
||||
const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
const error_condition & rhs )
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
inline bool operator==( const error_code & code,
|
||||
const error_condition & condition ) BOOST_SYSTEM_NOEXCEPT
|
||||
const error_condition & condition )
|
||||
{
|
||||
return code.category().equivalent( code.value(), condition )
|
||||
|| condition.category().equivalent( code, condition.value() );
|
||||
}
|
||||
|
||||
|
||||
inline bool operator!=( const error_code & lhs,
|
||||
const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
const error_condition & rhs )
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
|
||||
inline bool operator==( const error_condition & condition,
|
||||
const error_code & code ) BOOST_SYSTEM_NOEXCEPT
|
||||
const error_code & code )
|
||||
{
|
||||
return condition.category().equivalent( code, condition.value() )
|
||||
|| code.category().equivalent( code.value(), condition );
|
||||
}
|
||||
|
||||
|
||||
inline bool operator!=( const error_condition & lhs,
|
||||
const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
|
||||
const error_code & rhs )
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
|
||||
// TODO: both of these may move elsewhere, but the LWG hasn't spoken yet.
|
||||
|
||||
template <class charT, class traits>
|
||||
@@ -603,120 +436,60 @@ namespace boost
|
||||
+ reinterpret_cast<std::size_t>(&ec.category());
|
||||
}
|
||||
|
||||
// make_* functions for errc::errc_t ---------------------------------------------//
|
||||
// make_* functions for posix_error::posix_errno -----------------------------//
|
||||
|
||||
namespace errc
|
||||
namespace posix_error
|
||||
{
|
||||
// explicit conversion:
|
||||
inline error_code make_error_code( errc_t e ) BOOST_SYSTEM_NOEXCEPT
|
||||
{ return error_code( e, generic_category() ); }
|
||||
inline error_code make_error_code( posix_errno e )
|
||||
{ return error_code( e, get_posix_category() ); }
|
||||
|
||||
// implicit conversion:
|
||||
inline error_condition make_error_condition( errc_t e ) BOOST_SYSTEM_NOEXCEPT
|
||||
{ return error_condition( e, generic_category() ); }
|
||||
inline error_condition make_error_condition( posix_errno e )
|
||||
{ return error_condition( e, get_posix_category() ); }
|
||||
}
|
||||
|
||||
// error_category default implementation -----------------------------------------//
|
||||
// error_category default implementation -------------------------------//
|
||||
|
||||
error_condition error_category::default_error_condition( int ev ) const
|
||||
BOOST_SYSTEM_NOEXCEPT
|
||||
{
|
||||
inline error_condition error_category::default_error_condition( int ev ) const
|
||||
{
|
||||
return error_condition( ev, *this );
|
||||
}
|
||||
|
||||
bool error_category::equivalent( int code,
|
||||
const error_condition & condition ) const BOOST_SYSTEM_NOEXCEPT
|
||||
inline bool error_category::equivalent( int code,
|
||||
const error_condition & condition ) const
|
||||
{
|
||||
return default_error_condition( code ) == condition;
|
||||
}
|
||||
|
||||
bool error_category::equivalent( const error_code & code,
|
||||
int condition ) const BOOST_SYSTEM_NOEXCEPT
|
||||
inline bool error_category::equivalent( const error_code & code,
|
||||
int condition ) const
|
||||
{
|
||||
return *this == code.category() && code.value() == condition;
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
|
||||
|
||||
inline std::error_condition error_category::std_category::default_error_condition(
|
||||
int ev ) const BOOST_NOEXCEPT
|
||||
{
|
||||
return pc_->default_error_condition( ev );
|
||||
// error_category implementation note: VC++ 8.0 objects to name() and
|
||||
// message() being pure virtual functions. Thus these implementations.
|
||||
inline const char * error_category::name() const
|
||||
{
|
||||
return "error: should never be called";
|
||||
}
|
||||
|
||||
inline bool error_category::std_category::equivalent( int code,
|
||||
const std::error_condition & condition ) const BOOST_NOEXCEPT
|
||||
{
|
||||
if( condition.category() == *this )
|
||||
{
|
||||
boost::system::error_condition bn( condition.value(), *pc_ );
|
||||
return pc_->equivalent( code, bn );
|
||||
}
|
||||
else if( condition.category() == std::generic_category()
|
||||
|| condition.category() == boost::system::generic_category() )
|
||||
{
|
||||
boost::system::error_condition bn( condition.value(),
|
||||
boost::system::generic_category() );
|
||||
|
||||
return pc_->equivalent( code, bn );
|
||||
}
|
||||
#ifndef BOOST_NO_RTTI
|
||||
else if( std_category const* pc2 = dynamic_cast< std_category const* >(
|
||||
&condition.category() ) )
|
||||
{
|
||||
boost::system::error_condition bn( condition.value(), *pc2->pc_ );
|
||||
return pc_->equivalent( code, bn );
|
||||
}
|
||||
#endif
|
||||
else
|
||||
{
|
||||
return default_error_condition( code ) == condition;
|
||||
}
|
||||
inline std::string error_category::message( int ) const
|
||||
{
|
||||
static std::string s("error: should never be called");
|
||||
return s;
|
||||
}
|
||||
|
||||
inline bool error_category::std_category::equivalent( const std::error_code & code,
|
||||
int condition ) const BOOST_NOEXCEPT
|
||||
{
|
||||
if( code.category() == *this )
|
||||
{
|
||||
boost::system::error_code bc( code.value(), *pc_ );
|
||||
return pc_->equivalent( bc, condition );
|
||||
}
|
||||
else if( code.category() == std::generic_category()
|
||||
|| code.category() == boost::system::generic_category() )
|
||||
{
|
||||
boost::system::error_code bc( code.value(),
|
||||
boost::system::generic_category() );
|
||||
|
||||
return pc_->equivalent( bc, condition );
|
||||
}
|
||||
#ifndef BOOST_NO_RTTI
|
||||
else if( std_category const* pc2 = dynamic_cast< std_category const* >(
|
||||
&code.category() ) )
|
||||
{
|
||||
boost::system::error_code bc( code.value(), *pc2->pc_ );
|
||||
return pc_->equivalent( bc, condition );
|
||||
}
|
||||
#endif
|
||||
else if( *pc_ == boost::system::generic_category() )
|
||||
{
|
||||
return std::generic_category().equivalent( code, condition );
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace system
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
|
||||
|
||||
# ifdef BOOST_ERROR_CODE_HEADER_ONLY
|
||||
# include <boost/system/detail/error_code.ipp>
|
||||
# include <boost/../libs/system/src/error_code.cpp>
|
||||
# endif
|
||||
|
||||
#endif // BOOST_SYSTEM_ERROR_CODE_HPP
|
||||
#endif // BOOST_ERROR_CODE_HPP
|
||||
|
||||
|
||||
|
||||
@@ -7,8 +7,8 @@
|
||||
|
||||
// See library home page at http://www.boost.org/libs/system
|
||||
|
||||
#ifndef BOOST_SYSTEM_LINUX_ERROR_HPP
|
||||
#define BOOST_SYSTEM_LINUX_ERROR_HPP
|
||||
#ifndef BOOST_LINUX_ERROR_HPP
|
||||
#define BOOST_LINUX_ERROR_HPP
|
||||
|
||||
// This header is effectively empty for compiles on operating systems where
|
||||
// it is not applicable.
|
||||
@@ -23,7 +23,7 @@ namespace boost
|
||||
{
|
||||
// To construct an error_code after a API error:
|
||||
//
|
||||
// error_code( errno, system_category() )
|
||||
// error_code( errno, system_category )
|
||||
|
||||
// User code should use the portable "posix" enums for POSIX errors; this
|
||||
// allows such code to be portable to non-POSIX systems. For the non-POSIX
|
||||
@@ -99,7 +99,7 @@ namespace boost
|
||||
namespace linux_error
|
||||
{
|
||||
inline error_code make_error_code( linux_errno e )
|
||||
{ return error_code( e, system_category() ); }
|
||||
{ return error_code( e, get_system_category() ); }
|
||||
}
|
||||
|
||||
} // namespace system
|
||||
@@ -107,4 +107,4 @@ namespace boost
|
||||
|
||||
#endif // Linux
|
||||
|
||||
#endif // BOOST_SYSTEM_LINUX_ERROR_HPP
|
||||
#endif // BOOST_LINUX_ERROR_HPP
|
||||
|
||||
@@ -5,8 +5,8 @@
|
||||
// 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)
|
||||
|
||||
#ifndef BOOST_SYSTEM_SYSTEM_ERROR_HPP
|
||||
#define BOOST_SYSTEM_SYSTEM_ERROR_HPP
|
||||
#ifndef BOOST_SYSTEM_ERROR_HPP
|
||||
#define BOOST_SYSTEM_ERROR_HPP
|
||||
|
||||
#include <string>
|
||||
#include <stdexcept>
|
||||
@@ -17,37 +17,25 @@ namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
// class system_error ------------------------------------------------------------//
|
||||
// class system_error --------------------------------------------------//
|
||||
|
||||
class BOOST_SYMBOL_VISIBLE system_error : public std::runtime_error
|
||||
// BOOST_SYMBOL_VISIBLE is needed by GCC to ensure system_error thrown from a shared
|
||||
// library can be caught. See svn.boost.org/trac/boost/ticket/3697
|
||||
class system_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
system_error( error_code ec )
|
||||
: std::runtime_error(""), m_error_code(ec) {}
|
||||
|
||||
system_error( error_code ec, const std::string & what_arg )
|
||||
: std::runtime_error(what_arg), m_error_code(ec) {}
|
||||
|
||||
system_error( error_code ec, const char* what_arg )
|
||||
: std::runtime_error(what_arg), m_error_code(ec) {}
|
||||
|
||||
system_error( int ev, const error_category & ecat )
|
||||
: std::runtime_error(""), m_error_code(ev,ecat) {}
|
||||
|
||||
system_error( int ev, const error_category & ecat,
|
||||
const std::string & what_arg )
|
||||
: std::runtime_error(what_arg), m_error_code(ev,ecat) {}
|
||||
system_error( int ev, const error_category & ecat )
|
||||
: std::runtime_error(""), m_error_code(ev,ecat) {}
|
||||
|
||||
system_error( int ev, const error_category & ecat,
|
||||
const char * what_arg )
|
||||
: std::runtime_error(what_arg), m_error_code(ev,ecat) {}
|
||||
virtual ~system_error() throw() {}
|
||||
|
||||
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;
|
||||
const error_code & code() const throw() { return m_error_code; }
|
||||
const char * what() const throw();
|
||||
|
||||
private:
|
||||
error_code m_error_code;
|
||||
@@ -56,22 +44,21 @@ namespace boost
|
||||
|
||||
// implementation ------------------------------------------------------//
|
||||
|
||||
inline const char * system_error::what() const BOOST_NOEXCEPT_OR_NOTHROW
|
||||
inline const char * system_error::what() const throw()
|
||||
// see http://www.boost.org/more/error_handling.html for lazy build rationale
|
||||
{
|
||||
if ( m_what.empty() )
|
||||
{
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
try
|
||||
#endif
|
||||
{
|
||||
m_what = this->std::runtime_error::what();
|
||||
if ( !m_what.empty() ) m_what += ": ";
|
||||
m_what += m_error_code.message();
|
||||
if ( m_error_code )
|
||||
{
|
||||
if ( !m_what.empty() ) m_what += ": ";
|
||||
m_what += m_error_code.message();
|
||||
}
|
||||
}
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
catch (...) { return std::runtime_error::what(); }
|
||||
#endif
|
||||
}
|
||||
return m_what.c_str();
|
||||
}
|
||||
@@ -79,6 +66,6 @@ namespace boost
|
||||
} // namespace system
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_SYSTEM_SYSTEM_ERROR_HPP
|
||||
#endif // BOOST_SYSTEM_ERROR_HPP
|
||||
|
||||
|
||||
|
||||
@@ -7,8 +7,8 @@
|
||||
|
||||
// See library home page at http://www.boost.org/libs/system
|
||||
|
||||
#ifndef BOOST_SYSTEM_WINDOWS_ERROR_HPP
|
||||
#define BOOST_SYSTEM_WINDOWS_ERROR_HPP
|
||||
#ifndef BOOST_WINDOWS_ERROR_HPP
|
||||
#define BOOST_WINDOWS_ERROR_HPP
|
||||
|
||||
// This header is effectively empty for compiles on operating systems where
|
||||
// it is not applicable.
|
||||
@@ -18,17 +18,7 @@
|
||||
#ifdef BOOST_WINDOWS_API
|
||||
|
||||
#include <boost/system/error_code.hpp>
|
||||
|
||||
//// Neither MinGW or Cygwin versions of winerror.h work if used alone, so on
|
||||
//// either of those platforms include the full windows.h
|
||||
//
|
||||
//#if defined(__MINGW32__) || defined(__CYGWIN__)
|
||||
//#include <windows.h>
|
||||
//#else
|
||||
//#include <winerror.h>
|
||||
//#endif
|
||||
|
||||
#include <boost/detail/winapi/error_codes.hpp>
|
||||
#include <winerror.h>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
@@ -39,7 +29,7 @@ namespace boost
|
||||
|
||||
// To construct an error_code after a API error:
|
||||
//
|
||||
// error_code( ::GetLastError(), system_category() )
|
||||
// error_code( ::GetLastError(), system_category )
|
||||
|
||||
namespace windows_error
|
||||
{
|
||||
@@ -47,59 +37,59 @@ namespace boost
|
||||
{
|
||||
success = 0,
|
||||
// These names and values are based on Windows winerror.h
|
||||
invalid_function = boost::detail::winapi::ERROR_INVALID_FUNCTION_,
|
||||
file_not_found = boost::detail::winapi::ERROR_FILE_NOT_FOUND_,
|
||||
path_not_found = boost::detail::winapi::ERROR_PATH_NOT_FOUND_,
|
||||
too_many_open_files = boost::detail::winapi::ERROR_TOO_MANY_OPEN_FILES_,
|
||||
access_denied = boost::detail::winapi::ERROR_ACCESS_DENIED_,
|
||||
invalid_handle = boost::detail::winapi::ERROR_INVALID_HANDLE_,
|
||||
arena_trashed = boost::detail::winapi::ERROR_ARENA_TRASHED_,
|
||||
not_enough_memory = boost::detail::winapi::ERROR_NOT_ENOUGH_MEMORY_,
|
||||
invalid_block = boost::detail::winapi::ERROR_INVALID_BLOCK_,
|
||||
bad_environment = boost::detail::winapi::ERROR_BAD_ENVIRONMENT_,
|
||||
bad_format = boost::detail::winapi::ERROR_BAD_FORMAT_,
|
||||
invalid_access = boost::detail::winapi::ERROR_INVALID_ACCESS_,
|
||||
outofmemory = boost::detail::winapi::ERROR_OUTOFMEMORY_,
|
||||
invalid_drive = boost::detail::winapi::ERROR_INVALID_DRIVE_,
|
||||
current_directory = boost::detail::winapi::ERROR_CURRENT_DIRECTORY_,
|
||||
not_same_device = boost::detail::winapi::ERROR_NOT_SAME_DEVICE_,
|
||||
no_more_files = boost::detail::winapi::ERROR_NO_MORE_FILES_,
|
||||
write_protect = boost::detail::winapi::ERROR_WRITE_PROTECT_,
|
||||
bad_unit = boost::detail::winapi::ERROR_BAD_UNIT_,
|
||||
not_ready = boost::detail::winapi::ERROR_NOT_READY_,
|
||||
bad_command = boost::detail::winapi::ERROR_BAD_COMMAND_,
|
||||
crc = boost::detail::winapi::ERROR_CRC_,
|
||||
bad_length = boost::detail::winapi::ERROR_BAD_LENGTH_,
|
||||
seek = boost::detail::winapi::ERROR_SEEK_,
|
||||
not_dos_disk = boost::detail::winapi::ERROR_NOT_DOS_DISK_,
|
||||
sector_not_found = boost::detail::winapi::ERROR_SECTOR_NOT_FOUND_,
|
||||
out_of_paper = boost::detail::winapi::ERROR_OUT_OF_PAPER_,
|
||||
write_fault = boost::detail::winapi::ERROR_WRITE_FAULT_,
|
||||
read_fault = boost::detail::winapi::ERROR_READ_FAULT_,
|
||||
gen_failure = boost::detail::winapi::ERROR_GEN_FAILURE_,
|
||||
sharing_violation = boost::detail::winapi::ERROR_SHARING_VIOLATION_,
|
||||
lock_violation = boost::detail::winapi::ERROR_LOCK_VIOLATION_,
|
||||
wrong_disk = boost::detail::winapi::ERROR_WRONG_DISK_,
|
||||
sharing_buffer_exceeded = boost::detail::winapi::ERROR_SHARING_BUFFER_EXCEEDED_,
|
||||
handle_eof = boost::detail::winapi::ERROR_HANDLE_EOF_,
|
||||
handle_disk_full= boost::detail::winapi::ERROR_HANDLE_DISK_FULL_,
|
||||
rem_not_list = boost::detail::winapi::ERROR_REM_NOT_LIST_,
|
||||
dup_name = boost::detail::winapi::ERROR_DUP_NAME_,
|
||||
bad_net_path = boost::detail::winapi::ERROR_BAD_NETPATH_,
|
||||
network_busy = boost::detail::winapi::ERROR_NETWORK_BUSY_,
|
||||
invalid_function = ERROR_INVALID_FUNCTION,
|
||||
file_not_found = ERROR_FILE_NOT_FOUND,
|
||||
path_not_found = ERROR_PATH_NOT_FOUND,
|
||||
too_many_open_files = ERROR_TOO_MANY_OPEN_FILES,
|
||||
access_denied = ERROR_ACCESS_DENIED,
|
||||
invalid_handle = ERROR_INVALID_HANDLE,
|
||||
arena_trashed = ERROR_ARENA_TRASHED,
|
||||
not_enough_memory = ERROR_NOT_ENOUGH_MEMORY,
|
||||
invalid_block = ERROR_INVALID_BLOCK,
|
||||
bad_environment = ERROR_BAD_ENVIRONMENT,
|
||||
bad_format = ERROR_BAD_FORMAT,
|
||||
invalid_access = ERROR_INVALID_ACCESS,
|
||||
outofmemory = ERROR_OUTOFMEMORY,
|
||||
invalid_drive = ERROR_INVALID_DRIVE,
|
||||
current_directory = ERROR_CURRENT_DIRECTORY,
|
||||
not_same_device = ERROR_NOT_SAME_DEVICE,
|
||||
no_more_files = ERROR_NO_MORE_FILES,
|
||||
write_protect = ERROR_WRITE_PROTECT,
|
||||
bad_unit = ERROR_BAD_UNIT,
|
||||
not_ready = ERROR_NOT_READY,
|
||||
bad_command = ERROR_BAD_COMMAND,
|
||||
crc = ERROR_CRC,
|
||||
bad_length = ERROR_BAD_LENGTH,
|
||||
seek = ERROR_SEEK,
|
||||
not_dos_disk = ERROR_NOT_DOS_DISK,
|
||||
sector_not_found = ERROR_SECTOR_NOT_FOUND,
|
||||
out_of_paper = ERROR_OUT_OF_PAPER,
|
||||
write_fault = ERROR_WRITE_FAULT,
|
||||
read_fault = ERROR_READ_FAULT,
|
||||
gen_failure = ERROR_GEN_FAILURE,
|
||||
sharing_violation = ERROR_SHARING_VIOLATION,
|
||||
lock_violation = ERROR_LOCK_VIOLATION,
|
||||
wrong_disk = ERROR_WRONG_DISK,
|
||||
sharing_buffer_exceeded = ERROR_SHARING_BUFFER_EXCEEDED,
|
||||
handle_eof = ERROR_HANDLE_EOF,
|
||||
handle_disk_full= ERROR_HANDLE_DISK_FULL,
|
||||
rem_not_list = ERROR_REM_NOT_LIST,
|
||||
dup_name = ERROR_DUP_NAME,
|
||||
bad_net_path = ERROR_BAD_NETPATH,
|
||||
network_busy = ERROR_NETWORK_BUSY,
|
||||
// ...
|
||||
file_exists = boost::detail::winapi::ERROR_FILE_EXISTS_,
|
||||
cannot_make = boost::detail::winapi::ERROR_CANNOT_MAKE_,
|
||||
file_exists = ERROR_FILE_EXISTS,
|
||||
cannot_make = ERROR_CANNOT_MAKE,
|
||||
// ...
|
||||
broken_pipe = boost::detail::winapi::ERROR_BROKEN_PIPE_,
|
||||
open_failed = boost::detail::winapi::ERROR_OPEN_FAILED_,
|
||||
buffer_overflow = boost::detail::winapi::ERROR_BUFFER_OVERFLOW_,
|
||||
disk_full= boost::detail::winapi::ERROR_DISK_FULL_,
|
||||
broken_pipe = ERROR_BROKEN_PIPE,
|
||||
open_failed = ERROR_OPEN_FAILED,
|
||||
buffer_overflow = ERROR_BUFFER_OVERFLOW,
|
||||
disk_full= ERROR_DISK_FULL,
|
||||
// ...
|
||||
lock_failed = boost::detail::winapi::ERROR_LOCK_FAILED_,
|
||||
busy = boost::detail::winapi::ERROR_BUSY_,
|
||||
cancel_violation = boost::detail::winapi::ERROR_CANCEL_VIOLATION_,
|
||||
already_exists = boost::detail::winapi::ERROR_ALREADY_EXISTS_
|
||||
lock_failed = ERROR_LOCK_FAILED,
|
||||
busy = ERROR_BUSY,
|
||||
cancel_violation = ERROR_CANCEL_VIOLATION,
|
||||
already_exists = ERROR_ALREADY_EXISTS
|
||||
// ...
|
||||
|
||||
// TODO: add more Windows errors
|
||||
@@ -117,7 +107,7 @@ namespace boost
|
||||
namespace windows_error
|
||||
{
|
||||
inline error_code make_error_code( windows_error_code e )
|
||||
{ return error_code( e, system_category() ); }
|
||||
{ return error_code( e, get_system_category() ); }
|
||||
}
|
||||
|
||||
} // namespace system
|
||||
@@ -125,4 +115,4 @@ namespace boost
|
||||
|
||||
#endif // BOOST_WINDOWS_API
|
||||
|
||||
#endif // BOOST_SYSTEM_WINDOWS_ERROR_HPP
|
||||
#endif // BOOST_WINDOWS_ERROR_HPP
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
{
|
||||
"key": "system",
|
||||
"name": "System",
|
||||
"authors": [
|
||||
"Beman Dawes"
|
||||
],
|
||||
"description": "Operating system support, including the diagnostics support that will be part of the C++0x standard library.",
|
||||
"category": [
|
||||
"System"
|
||||
]
|
||||
}
|
||||
+403
-4
@@ -9,12 +9,411 @@
|
||||
|
||||
//----------------------------------------------------------------------------//
|
||||
|
||||
// VC++ 8.0 warns on usage of certain Standard Library and API functions that
|
||||
// can be cause buffer overruns or other possible security issues if misused.
|
||||
// See http://msdn.microsoft.com/msdnmag/issues/05/05/SafeCandC/default.aspx
|
||||
// But the wording of the warning is misleading and unsettling, there are no
|
||||
// portable alternative functions, and VC++ 8.0's own libraries use the
|
||||
// functions in question. So turn off the warnings.
|
||||
#define _CRT_SECURE_NO_DEPRECATE
|
||||
#define _SCL_SECURE_NO_DEPRECATE
|
||||
|
||||
// define BOOST_SYSTEM_SOURCE so that <boost/system/config.hpp> knows
|
||||
// the library is being built (possibly exporting rather than importing code)
|
||||
#define BOOST_SYSTEM_SOURCE
|
||||
#define BOOST_SYSTEM_SOURCE
|
||||
|
||||
#include <boost/system/config.hpp>
|
||||
#include <boost/system/error_code.hpp>
|
||||
#include <boost/cerrno.hpp>
|
||||
#include <vector>
|
||||
#include <cstdlib>
|
||||
#include <cassert>
|
||||
|
||||
#ifndef BOOST_ERROR_CODE_HEADER_ONLY
|
||||
#include <boost/system/detail/error_code.ipp>
|
||||
#endif
|
||||
using namespace boost::system;
|
||||
using namespace boost::system::posix_error;
|
||||
|
||||
#include <cstring> // for strerror/strerror_r
|
||||
|
||||
# if defined( BOOST_WINDOWS_API )
|
||||
# include <windows.h>
|
||||
# ifndef ERROR_INCORRECT_SIZE
|
||||
# define ERROR_INCORRECT_SIZE ERROR_BAD_ARGUMENTS
|
||||
# endif
|
||||
# endif
|
||||
|
||||
//----------------------------------------------------------------------------//
|
||||
|
||||
namespace
|
||||
{
|
||||
// standard error categories -------------------------------------------//
|
||||
|
||||
class posix_error_category : public error_category
|
||||
{
|
||||
public:
|
||||
posix_error_category(){}
|
||||
const char * name() const;
|
||||
std::string message( int ev ) const;
|
||||
};
|
||||
|
||||
class system_error_category : public error_category
|
||||
{
|
||||
public:
|
||||
system_error_category(){}
|
||||
const char * name() const;
|
||||
std::string message( int ev ) const;
|
||||
error_condition default_error_condition( int ev ) const;
|
||||
};
|
||||
|
||||
// posix_error_category implementation ---------------------------------//
|
||||
|
||||
const char * posix_error_category::name() const
|
||||
{
|
||||
return "POSIX";
|
||||
}
|
||||
|
||||
std::string posix_error_category::message( int ev ) const
|
||||
{
|
||||
// strerror_r is preferred because it is always thread safe,
|
||||
// however, we fallback to strerror in certain cases because:
|
||||
// -- Windows doesn't provide strerror_r.
|
||||
// -- HP and Sundo provide strerror_r on newer systems, but there is
|
||||
// no way to tell if is available at runtime and in any case their
|
||||
// versions of strerror are thread safe anyhow.
|
||||
// -- Linux only sometimes provides strerror_r.
|
||||
// -- Tru64 provides strerror_r only when compiled -pthread.
|
||||
// -- VMS doesn't provide strerror_r, but on this platform, strerror is
|
||||
// thread safe.
|
||||
# if defined(BOOST_WINDOWS_API) || defined(__hpux) || defined(__sun)\
|
||||
|| (defined(__linux) && (!defined(__USE_XOPEN2K) || defined(BOOST_SYSTEM_USE_STRERROR)))\
|
||||
|| (defined(__osf__) && !defined(_REENTRANT))\
|
||||
|| (defined(__vms))
|
||||
const char * c_str = std::strerror( ev );
|
||||
return std::string( c_str ? c_str : "Unknown error" );
|
||||
# else
|
||||
char buf[64];
|
||||
char * bp = buf;
|
||||
std::size_t sz = sizeof(buf);
|
||||
# if defined(__CYGWIN__) || defined(__USE_GNU)
|
||||
// Oddball version of strerror_r
|
||||
const char * c_str = strerror_r( ev, bp, sz );
|
||||
return std::string( c_str ? c_str : "Unknown error" );
|
||||
# else
|
||||
// POSIX version of strerror_r
|
||||
int result;
|
||||
for (;;)
|
||||
{
|
||||
// strerror_r returns 0 on success, otherwise ERANGE if buffer too small,
|
||||
// invalid_argument if ev not a valid error number
|
||||
# if defined (__sgi)
|
||||
const char * c_str = strerror( ev );
|
||||
result = 0;
|
||||
return std::string( c_str ? c_str : "Unknown error" );
|
||||
# else
|
||||
result = strerror_r( ev, bp, sz );
|
||||
# endif
|
||||
if (result == 0 )
|
||||
break;
|
||||
else
|
||||
{
|
||||
# if defined(__linux)
|
||||
// Linux strerror_r returns -1 on error, with error number in errno
|
||||
result = errno;
|
||||
# endif
|
||||
if ( result != ERANGE ) break;
|
||||
if ( sz > sizeof(buf) ) std::free( bp );
|
||||
sz *= 2;
|
||||
if ( (bp = static_cast<char*>(std::malloc( sz ))) == 0 )
|
||||
return std::string( "ENOMEM" );
|
||||
}
|
||||
}
|
||||
try
|
||||
{
|
||||
std::string msg( ( result == invalid_argument ) ? "Unknown error" : bp );
|
||||
if ( sz > sizeof(buf) ) std::free( bp );
|
||||
sz = 0;
|
||||
return msg;
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
if ( sz > sizeof(buf) ) std::free( bp );
|
||||
throw;
|
||||
}
|
||||
# endif
|
||||
# endif
|
||||
}
|
||||
// system_error_category implementation --------------------------------//
|
||||
|
||||
const char * system_error_category::name() const
|
||||
{
|
||||
return "system";
|
||||
}
|
||||
|
||||
error_condition system_error_category::default_error_condition( int ev ) const
|
||||
{
|
||||
switch ( ev )
|
||||
{
|
||||
case 0: return make_error_condition( success );
|
||||
# if defined(BOOST_POSIX_API)
|
||||
// POSIX-like O/S -> posix_errno decode table ---------------------------//
|
||||
case E2BIG: return make_error_condition( argument_list_too_long );
|
||||
case EACCES: return make_error_condition( permission_denied );
|
||||
case EADDRINUSE: return make_error_condition( address_in_use );
|
||||
case EADDRNOTAVAIL: return make_error_condition( address_not_available );
|
||||
case EAFNOSUPPORT: return make_error_condition( address_family_not_supported );
|
||||
case EAGAIN: return make_error_condition( resource_unavailable_try_again );
|
||||
case EALREADY: return make_error_condition( connection_already_in_progress );
|
||||
case EBADF: return make_error_condition( bad_file_descriptor );
|
||||
case EBADMSG: return make_error_condition( bad_message );
|
||||
case EBUSY: return make_error_condition( device_or_resource_busy );
|
||||
case ECANCELED: return make_error_condition( operation_canceled );
|
||||
case ECHILD: return make_error_condition( no_child_process );
|
||||
case ECONNABORTED: return make_error_condition( connection_aborted );
|
||||
case ECONNREFUSED: return make_error_condition( connection_refused );
|
||||
case ECONNRESET: return make_error_condition( connection_reset );
|
||||
case EDEADLK: return make_error_condition( resource_deadlock_would_occur );
|
||||
case EDESTADDRREQ: return make_error_condition( destination_address_required );
|
||||
case EDOM: return make_error_condition( argument_out_of_domain );
|
||||
case EEXIST: return make_error_condition( file_exists );
|
||||
case EFAULT: return make_error_condition( bad_address );
|
||||
case EFBIG: return make_error_condition( file_too_large );
|
||||
case EHOSTUNREACH: return make_error_condition( host_unreachable );
|
||||
case EIDRM: return make_error_condition( identifier_removed );
|
||||
case EILSEQ: return make_error_condition( illegal_byte_sequence );
|
||||
case EINPROGRESS: return make_error_condition( operation_in_progress );
|
||||
case EINTR: return make_error_condition( interrupted );
|
||||
case EINVAL: return make_error_condition( invalid_argument );
|
||||
case EIO: return make_error_condition( io_error );
|
||||
case EISCONN: return make_error_condition( already_connected );
|
||||
case EISDIR: return make_error_condition( is_a_directory );
|
||||
case ELOOP: return make_error_condition( too_many_synbolic_link_levels );
|
||||
case EMFILE: return make_error_condition( too_many_files_open );
|
||||
case EMLINK: return make_error_condition( too_many_links );
|
||||
case EMSGSIZE: return make_error_condition( message_size );
|
||||
case ENAMETOOLONG: return make_error_condition( filename_too_long );
|
||||
case ENETDOWN: return make_error_condition( network_down );
|
||||
case ENETRESET: return make_error_condition( network_reset );
|
||||
case ENETUNREACH: return make_error_condition( network_unreachable );
|
||||
case ENFILE: return make_error_condition( too_many_files_open_in_system );
|
||||
case ENOBUFS: return make_error_condition( no_buffer_space );
|
||||
case ENODATA: return make_error_condition( no_message_available );
|
||||
case ENODEV: return make_error_condition( no_such_device );
|
||||
case ENOENT: return make_error_condition( no_such_file_or_directory );
|
||||
case ENOEXEC: return make_error_condition( executable_format_error );
|
||||
case ENOLCK: return make_error_condition( no_lock_available );
|
||||
case ENOLINK: return make_error_condition( no_link );
|
||||
case ENOMEM: return make_error_condition( not_enough_memory );
|
||||
case ENOMSG: return make_error_condition( no_message );
|
||||
case ENOPROTOOPT: return make_error_condition( no_protocol_option );
|
||||
case ENOSPC: return make_error_condition( no_space_on_device );
|
||||
case ENOSR: return make_error_condition( no_stream_resources );
|
||||
case ENOSTR: return make_error_condition( not_a_stream );
|
||||
case ENOSYS: return make_error_condition( function_not_supported );
|
||||
case ENOTCONN: return make_error_condition( not_connected );
|
||||
case ENOTDIR: return make_error_condition( not_a_directory );
|
||||
# if ENOTEMPTY != EEXIST // AIX treats ENOTEMPTY and EEXIST as the same value
|
||||
case ENOTEMPTY: return make_error_condition( directory_not_empty );
|
||||
# endif // ENOTEMPTY != EEXIST
|
||||
case ENOTRECOVERABLE: return make_error_condition( state_not_recoverable );
|
||||
case ENOTSOCK: return make_error_condition( not_a_socket );
|
||||
case ENOTSUP: return make_error_condition( not_supported );
|
||||
case ENOTTY: return make_error_condition( inappropriate_io_control_operation );
|
||||
case ENXIO: return make_error_condition( no_such_device_or_address );
|
||||
# if EOPNOTSUPP != ENOTSUP
|
||||
case EOPNOTSUPP: return make_error_condition( operation_not_supported );
|
||||
# endif // EOPNOTSUPP != ENOTSUP
|
||||
case EOVERFLOW: return make_error_condition( value_too_large );
|
||||
case EOWNERDEAD: return make_error_condition( owner_dead );
|
||||
case EPERM: return make_error_condition( operation_not_permitted );
|
||||
case EPIPE: return make_error_condition( broken_pipe );
|
||||
case EPROTO: return make_error_condition( protocol_error );
|
||||
case EPROTONOSUPPORT: return make_error_condition( protocol_not_supported );
|
||||
case EPROTOTYPE: return make_error_condition( wrong_protocol_type );
|
||||
case ERANGE: return make_error_condition( result_out_of_range );
|
||||
case EROFS: return make_error_condition( read_only_file_system );
|
||||
case ESPIPE: return make_error_condition( invalid_seek );
|
||||
case ESRCH: return make_error_condition( no_such_process );
|
||||
case ETIME: return make_error_condition( stream_timeout );
|
||||
case ETIMEDOUT: return make_error_condition( timed_out );
|
||||
case ETXTBSY: return make_error_condition( text_file_busy );
|
||||
# if EAGAIN != EWOULDBLOCK
|
||||
case EWOULDBLOCK: return make_error_condition( operation_would_block );
|
||||
# endif // EAGAIN != EWOULDBLOCK
|
||||
case EXDEV: return make_error_condition( cross_device_link );
|
||||
#else
|
||||
// Windows system -> posix_errno decode table ---------------------------//
|
||||
// see WinError.h comments for descriptions of errors
|
||||
case ERROR_ACCESS_DENIED: return make_error_condition( permission_denied );
|
||||
case ERROR_ALREADY_EXISTS: return make_error_condition( file_exists );
|
||||
case ERROR_BAD_UNIT: return make_error_condition( no_such_device );
|
||||
case ERROR_BUFFER_OVERFLOW: return make_error_condition( filename_too_long );
|
||||
case ERROR_BUSY: return make_error_condition( device_or_resource_busy );
|
||||
case ERROR_BUSY_DRIVE: return make_error_condition( device_or_resource_busy );
|
||||
case ERROR_CANNOT_MAKE: return make_error_condition( permission_denied );
|
||||
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_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 );
|
||||
case ERROR_DIR_NOT_EMPTY: return make_error_condition( directory_not_empty );
|
||||
case ERROR_DIRECTORY: return make_error_condition( invalid_argument ); // WinError.h: "The directory name is invalid"
|
||||
case ERROR_DISK_FULL: return make_error_condition( no_space_on_device );
|
||||
case ERROR_FILE_EXISTS: return make_error_condition( file_exists );
|
||||
case ERROR_FILE_NOT_FOUND: return make_error_condition( no_such_file_or_directory );
|
||||
case ERROR_HANDLE_DISK_FULL: return make_error_condition( no_space_on_device );
|
||||
case ERROR_INVALID_ACCESS: return make_error_condition( permission_denied );
|
||||
case ERROR_INVALID_DRIVE: return make_error_condition( no_such_device );
|
||||
case ERROR_INVALID_FUNCTION: return make_error_condition( function_not_supported );
|
||||
case ERROR_INVALID_HANDLE: return make_error_condition( invalid_argument );
|
||||
case ERROR_INVALID_NAME: return make_error_condition( invalid_argument );
|
||||
case ERROR_LOCK_VIOLATION: return make_error_condition( no_lock_available );
|
||||
case ERROR_LOCKED: return make_error_condition( no_lock_available );
|
||||
case ERROR_NEGATIVE_SEEK: return make_error_condition( invalid_argument );
|
||||
case ERROR_NOACCESS: return make_error_condition( permission_denied );
|
||||
case ERROR_NOT_ENOUGH_MEMORY: return make_error_condition( not_enough_memory );
|
||||
case ERROR_NOT_READY: return make_error_condition( resource_unavailable_try_again );
|
||||
case ERROR_NOT_SAME_DEVICE: return make_error_condition( cross_device_link );
|
||||
case ERROR_OPEN_FAILED: return make_error_condition( io_error );
|
||||
case ERROR_OPEN_FILES: return make_error_condition( device_or_resource_busy );
|
||||
case ERROR_OPERATION_ABORTED: return make_error_condition( operation_canceled );
|
||||
case ERROR_OUTOFMEMORY: return make_error_condition( not_enough_memory );
|
||||
case ERROR_PATH_NOT_FOUND: return make_error_condition( no_such_file_or_directory );
|
||||
case ERROR_READ_FAULT: return make_error_condition( io_error );
|
||||
case ERROR_RETRY: return make_error_condition( resource_unavailable_try_again );
|
||||
case ERROR_SEEK: return make_error_condition( io_error );
|
||||
case ERROR_SHARING_VIOLATION: return make_error_condition( permission_denied );
|
||||
case ERROR_TOO_MANY_OPEN_FILES: return make_error_condition( too_many_files_open );
|
||||
case ERROR_WRITE_FAULT: return make_error_condition( io_error );
|
||||
case ERROR_WRITE_PROTECT: return make_error_condition( permission_denied );
|
||||
case WSAEACCES: return make_error_condition( permission_denied );
|
||||
case WSAEADDRINUSE: return make_error_condition( address_in_use );
|
||||
case WSAEADDRNOTAVAIL: return make_error_condition( address_not_available );
|
||||
case WSAEAFNOSUPPORT: return make_error_condition( address_family_not_supported );
|
||||
case WSAEALREADY: return make_error_condition( connection_already_in_progress );
|
||||
case WSAEBADF: return make_error_condition( bad_file_descriptor );
|
||||
case WSAECONNABORTED: return make_error_condition( connection_aborted );
|
||||
case WSAECONNREFUSED: return make_error_condition( connection_refused );
|
||||
case WSAECONNRESET: return make_error_condition( connection_reset );
|
||||
case WSAEDESTADDRREQ: return make_error_condition( destination_address_required );
|
||||
case WSAEFAULT: return make_error_condition( bad_address );
|
||||
case WSAEHOSTUNREACH: return make_error_condition( host_unreachable );
|
||||
case WSAEINPROGRESS: return make_error_condition( operation_in_progress );
|
||||
case WSAEINTR: return make_error_condition( interrupted );
|
||||
case WSAEINVAL: return make_error_condition( invalid_argument );
|
||||
case WSAEISCONN: return make_error_condition( already_connected );
|
||||
case WSAEMFILE: return make_error_condition( too_many_files_open );
|
||||
case WSAEMSGSIZE: return make_error_condition( message_size );
|
||||
case WSAENAMETOOLONG: return make_error_condition( filename_too_long );
|
||||
case WSAENETDOWN: return make_error_condition( network_down );
|
||||
case WSAENETRESET: return make_error_condition( network_reset );
|
||||
case WSAENETUNREACH: return make_error_condition( network_unreachable );
|
||||
case WSAENOBUFS: return make_error_condition( no_buffer_space );
|
||||
case WSAENOPROTOOPT: return make_error_condition( no_protocol_option );
|
||||
case WSAENOTCONN: return make_error_condition( not_connected );
|
||||
case WSAENOTSOCK: return make_error_condition( not_a_socket );
|
||||
case WSAEOPNOTSUPP: return make_error_condition( operation_not_supported );
|
||||
case WSAEPROTONOSUPPORT: return make_error_condition( protocol_not_supported );
|
||||
case WSAEPROTOTYPE: return make_error_condition( wrong_protocol_type );
|
||||
case WSAETIMEDOUT: return make_error_condition( timed_out );
|
||||
case WSAEWOULDBLOCK: return make_error_condition( operation_would_block );
|
||||
#endif
|
||||
default: return error_condition( ev, system_category );
|
||||
}
|
||||
}
|
||||
|
||||
# if !defined( BOOST_WINDOWS_API )
|
||||
|
||||
std::string system_error_category::message( int ev ) const
|
||||
{
|
||||
return posix_category.message( ev );
|
||||
}
|
||||
# else
|
||||
// TODO:
|
||||
|
||||
//Some quick notes on the implementation (sorry for the noise if
|
||||
//someone has already mentioned them):
|
||||
//
|
||||
//- The ::LocalFree() usage isn't exception safe.
|
||||
//
|
||||
//See:
|
||||
//
|
||||
//<http://boost.cvs.sourceforge.net/boost/boost/boost/asio/system_exception.hpp?revision=1.1&view=markup>
|
||||
//
|
||||
//in the implementation of what() for an example.
|
||||
//
|
||||
//Cheers,
|
||||
//Chris
|
||||
std::string system_error_category::message( int ev ) const
|
||||
{
|
||||
# ifndef BOOST_NO_ANSI_APIS
|
||||
LPVOID lpMsgBuf;
|
||||
DWORD retval = ::FormatMessageA(
|
||||
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
||||
FORMAT_MESSAGE_FROM_SYSTEM |
|
||||
FORMAT_MESSAGE_IGNORE_INSERTS,
|
||||
NULL,
|
||||
ev,
|
||||
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
|
||||
(LPSTR) &lpMsgBuf,
|
||||
0,
|
||||
NULL
|
||||
);
|
||||
if (retval == 0)
|
||||
return std::string("Unknown error");
|
||||
|
||||
std::string str( static_cast<LPCSTR>(lpMsgBuf) );
|
||||
::LocalFree( lpMsgBuf ); // free the buffer
|
||||
# else // WinCE workaround
|
||||
LPVOID lpMsgBuf;
|
||||
DWORD retval = ::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)
|
||||
return std::string("Unknown error");
|
||||
|
||||
int num_chars = (wcslen( static_cast<LPCWSTR>(lpMsgBuf) ) + 1) * 2;
|
||||
LPSTR narrow_buffer = (LPSTR)_alloca( num_chars );
|
||||
if (::WideCharToMultiByte(CP_ACP, 0, static_cast<LPCWSTR>(lpMsgBuf), -1, narrow_buffer, num_chars, NULL, NULL) == 0)
|
||||
return std::string("Unknown error");
|
||||
|
||||
std::string str( narrow_buffer );
|
||||
::LocalFree( lpMsgBuf ); // free the buffer
|
||||
# endif
|
||||
while ( str.size()
|
||||
&& (str[str.size()-1] == '\n' || str[str.size()-1] == '\r') )
|
||||
str.erase( str.size()-1 );
|
||||
if ( str.size() && str[str.size()-1] == '.' )
|
||||
{ str.erase( str.size()-1 ); }
|
||||
return str;
|
||||
}
|
||||
# endif
|
||||
|
||||
} // unnamed namespace
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
|
||||
BOOST_SYSTEM_DECL const error_category & get_system_category()
|
||||
{
|
||||
static const system_error_category system_category_const;
|
||||
return system_category_const;
|
||||
}
|
||||
|
||||
BOOST_SYSTEM_DECL const error_category & get_posix_category()
|
||||
{
|
||||
static const posix_error_category posix_category_const;
|
||||
return posix_category_const;
|
||||
}
|
||||
|
||||
} // namespace system
|
||||
} // namespace boost
|
||||
|
||||
+13
-86
@@ -7,118 +7,45 @@
|
||||
|
||||
# See library home page at http://www.boost.org/libs/system
|
||||
|
||||
import testing ;
|
||||
|
||||
project
|
||||
: requirements
|
||||
<library>/boost/system//boost_system
|
||||
<define>BOOST_ALL_NO_LIB
|
||||
<toolset>msvc:<asynch-exceptions>on
|
||||
;
|
||||
|
||||
lib throw_test
|
||||
: throw_test.cpp
|
||||
: <link>shared:<define>BOOST_SYSTEM_DYN_LINK=1
|
||||
<link>static:<define>BOOST_SYSTEM_STATIC_LINK=1
|
||||
;
|
||||
|
||||
rule cxx03 ( properties * )
|
||||
{
|
||||
local result ;
|
||||
|
||||
if <toolset>gcc in $(properties) || <toolset>clang in $(properties)
|
||||
{
|
||||
result = <cxxflags>-std=c++03 ;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = <build>no ;
|
||||
}
|
||||
|
||||
return $(result) ;
|
||||
}
|
||||
|
||||
rule cxx11 ( properties * )
|
||||
{
|
||||
local result ;
|
||||
|
||||
if <toolset-gcc:version>4.6 in $(properties)
|
||||
{
|
||||
result = <cxxflags>-std=c++0x ;
|
||||
}
|
||||
else if <toolset>gcc in $(properties) || <toolset>clang in $(properties)
|
||||
{
|
||||
result = <cxxflags>-std=c++11 ;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = <build>no ;
|
||||
}
|
||||
|
||||
return $(result) ;
|
||||
}
|
||||
|
||||
test-suite "system"
|
||||
: [ run error_code_test.cpp
|
||||
: # command line
|
||||
: # input files
|
||||
: # requirements
|
||||
<define>BOOST_SYSTEM_STATIC_LINK
|
||||
<link>static
|
||||
]
|
||||
[ run error_code_test.cpp
|
||||
: : : <link>shared : error_code_test_shared
|
||||
]
|
||||
[ run error_code_test.cpp
|
||||
: : : <link>static <conditional>@cxx03 : error_code_test_03
|
||||
]
|
||||
[ run error_code_test.cpp
|
||||
: : : <link>shared <conditional>@cxx03 : error_code_test_shared_03
|
||||
]
|
||||
[ run error_code_test.cpp
|
||||
: : : <link>static <conditional>@cxx11 : error_code_test_11
|
||||
]
|
||||
[ run error_code_test.cpp
|
||||
: : : <link>shared <conditional>@cxx11 : error_code_test_shared_11
|
||||
: : : <define>BOOST_SYSTEM_DYN_LINK
|
||||
: error_code_test_dll
|
||||
]
|
||||
[ run error_code_user_test.cpp
|
||||
: : : <link>static
|
||||
: : : <define>BOOST_SYSTEM_STATIC_LINK
|
||||
<link>static
|
||||
]
|
||||
[ run error_code_user_test.cpp
|
||||
: : : <link>shared : error_code_user_test_shared
|
||||
: : : <define>BOOST_SYSTEM_DYN_LINK
|
||||
: error_code_user_test_dll
|
||||
]
|
||||
[ run system_error_test.cpp
|
||||
: : : <link>static
|
||||
: : : <define>BOOST_SYSTEM_STATIC_LINK
|
||||
<link>static
|
||||
]
|
||||
[ run system_error_test.cpp
|
||||
: : : <link>shared : system_error_test_shared
|
||||
]
|
||||
[ run dynamic_link_test.cpp throw_test
|
||||
: : : <link>shared : throw_test_shared
|
||||
: : : <define>BOOST_SYSTEM_DYN_LINK
|
||||
: system_error_test_dll
|
||||
]
|
||||
[ run initialization_test.cpp
|
||||
: : : <link>shared : initialization_test_shared
|
||||
: : : <define>BOOST_SYSTEM_DYN_LINK
|
||||
]
|
||||
[ run header_only_test.cpp
|
||||
: : : <link>static
|
||||
]
|
||||
[ run config_test.cpp
|
||||
: : : <test-info>always_show_run_output
|
||||
]
|
||||
[ run std_interop_test.cpp
|
||||
: : : <link>static
|
||||
]
|
||||
[ run std_interop_test.cpp
|
||||
: : : <link>shared : std_interop_test_shared
|
||||
]
|
||||
[ run std_mismatch_test.cpp
|
||||
: : : <link>static <conditional>@cxx03 : std_mismatch_test_03
|
||||
]
|
||||
[ run std_mismatch_test.cpp
|
||||
: : : <link>shared <conditional>@cxx03 : std_mismatch_test_shared_03
|
||||
]
|
||||
[ run std_mismatch_test.cpp
|
||||
: : : <link>static <conditional>@cxx11 : std_mismatch_test_11
|
||||
]
|
||||
[ run std_mismatch_test.cpp
|
||||
: : : <link>shared <conditional>@cxx11 : std_mismatch_test_shared_11
|
||||
]
|
||||
;
|
||||
|
||||
@@ -1,65 +0,0 @@
|
||||
// error_code_test.cpp ---------------------------------------------------------------//
|
||||
|
||||
// Copyright Beman Dawes 2014
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
// See library home page at http://www.boost.org/libs/system
|
||||
|
||||
#include <boost/system/config.hpp>
|
||||
#include <iostream>
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
|
||||
int main()
|
||||
{
|
||||
#ifdef BOOST_WINDOWS_API
|
||||
std::cout << "BOOST_WINDOWS_API is defined" << std::endl;
|
||||
#else
|
||||
std::cout << "BOOST_WINDOWS_API is not defined" << std::endl;
|
||||
#endif
|
||||
#ifdef _MSC_VER
|
||||
std::cout << "_MSC_VER is defined as " << _MSC_VER << std::endl;
|
||||
#else
|
||||
std::cout << "_MSC_VER is not defined" << std::endl;
|
||||
#endif
|
||||
#ifdef __CYGWIN__
|
||||
std::cout << "__CYGWIN__ is defined" << std::endl;
|
||||
#else
|
||||
std::cout << "__CYGWIN__ is not defined" << std::endl;
|
||||
#endif
|
||||
#ifdef __MINGW32__
|
||||
std::cout << "__MINGW32__ is defined" << std::endl;
|
||||
#else
|
||||
std::cout << "__MINGW32__ is not defined" << std::endl;
|
||||
#endif
|
||||
#ifdef BOOST_POSIX_API
|
||||
std::cout << "BOOST_POSIX_API is defined" << std::endl;
|
||||
#else
|
||||
std::cout << "BOOST_POSIX_API is not defined" << std::endl;
|
||||
#endif
|
||||
#ifdef BOOST_PLAT_WINDOWS_DESKTOP
|
||||
std::cout << "BOOST_PLAT_WINDOWS_DESKTOP is defined as "
|
||||
<< BOOST_PLAT_WINDOWS_DESKTOP << std::endl;
|
||||
#else
|
||||
std::cout << "BOOST_PLAT_WINDOWS_DESKTOP is not defined" << std::endl;
|
||||
#endif
|
||||
#ifdef BOOST_NO_ANSI_APIS
|
||||
std::cout << "BOOST_NO_ANSI_APIS is defined" << std::endl;
|
||||
#else
|
||||
std::cout << "BOOST_NO_ANSI_APIS is not defined" << std::endl;
|
||||
#endif
|
||||
#ifdef BOOST_NO_CXX11_NOEXCEPT
|
||||
std::cout << "BOOST_NO_CXX11_NOEXCEPT is defined" << std::endl;
|
||||
#else
|
||||
std::cout << "BOOST_NO_CXX11_NOEXCEPT is not defined" << std::endl;
|
||||
#endif
|
||||
#ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
|
||||
std::cout << "BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS is defined" << std::endl;
|
||||
#else
|
||||
std::cout << "BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS is not defined" << std::endl;
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
// dynamic_link_test.cpp -------------------------------------------------------------//
|
||||
|
||||
// Copyright Beman Dawes 2010
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
// Library home page is www.boost.org/libs/system
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
// Dynamic link libraries (DLL's), also know as dynamic shared objects (DSO's),
|
||||
// can cause symbol visability problems unless carefully configured. One of the
|
||||
// manifestations, particularly with GCC, is that a system_error exception thrown from
|
||||
// a DLL or DSO is not caught.
|
||||
//
|
||||
// The purpose of this program is to test for that error.
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
#include <boost/system/system_error.hpp>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
BOOST_SYSTEM_DECL void throw_test();
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
try
|
||||
{
|
||||
boost::system::throw_test();
|
||||
}
|
||||
catch (const boost::system::system_error& ex)
|
||||
{
|
||||
std::cout << " caught boost::system::system_error as expected\n";
|
||||
std::cout << " what() reports " << ex.what() << '\n';
|
||||
return 0;
|
||||
}
|
||||
|
||||
catch (const std::runtime_error& ex)
|
||||
{
|
||||
std::cout << " error: caught std::runtime_error instead of boost::system::system_error\n";
|
||||
std::cout << " what() reports " << ex.what() << '\n';
|
||||
return 1;
|
||||
}
|
||||
|
||||
std::cout << " error: failed to catch boost::system::system_error\n";
|
||||
return 1;
|
||||
}
|
||||
+149
-162
@@ -7,14 +7,18 @@
|
||||
|
||||
// See library home page at http://www.boost.org/libs/system
|
||||
|
||||
//----------------------------------------------------------------------------//
|
||||
//----------------------------------------------------------------------------//
|
||||
|
||||
// test without deprecated features
|
||||
#define BOOST_SYSTEM_NO_DEPRECATED
|
||||
// VC++ 8.0 warns on usage of certain Standard Library and API functions that
|
||||
// can cause buffer overruns or other possible security issues if misused.
|
||||
// See http://msdn.microsoft.com/msdnmag/issues/05/05/SafeCandC/default.aspx
|
||||
// But the wording of the warning is misleading and unsettling, there are no
|
||||
// portable alternative functions, and VC++ 8.0's own libraries use the
|
||||
// functions in question. So turn off the warnings.
|
||||
#define _CRT_SECURE_NO_DEPRECATE
|
||||
#define _SCL_SECURE_NO_DEPRECATE
|
||||
|
||||
#include <boost/config/warning_disable.hpp>
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/system/error_code.hpp>
|
||||
#include <boost/system/cygwin_error.hpp>
|
||||
#include <boost/system/linux_error.hpp>
|
||||
@@ -30,20 +34,14 @@
|
||||
// with a boost::system using directive increases use scenario coverage.
|
||||
using namespace boost::system;
|
||||
|
||||
#if defined( BOOST_WINDOWS_API )
|
||||
// Neither MinGW or Cygwin versions of winerror.h work if used alone, so on
|
||||
// either of those platforms include the full windows.h
|
||||
# if defined(__MINGW32__) || defined(__CYGWIN__)
|
||||
# include <windows.h>
|
||||
# else
|
||||
# include <winerror.h>
|
||||
# endif
|
||||
# define BOOST_ACCESS_ERROR_MACRO ERROR_ACCESS_DENIED
|
||||
#elif defined( BOOST_POSIX_API )
|
||||
# define BOOST_ACCESS_ERROR_MACRO EACCES
|
||||
#else
|
||||
# error "Only supported for POSIX and Windows"
|
||||
#endif
|
||||
# if defined( BOOST_WINDOWS_API )
|
||||
# include "winerror.h"
|
||||
# define BOOST_ACCESS_ERROR_MACRO ERROR_ACCESS_DENIED
|
||||
# elif defined( BOOST_POSIX_API )
|
||||
# define BOOST_ACCESS_ERROR_MACRO EACCES
|
||||
# else
|
||||
# error "Only supported for POSIX and Windows"
|
||||
# endif
|
||||
|
||||
namespace
|
||||
{
|
||||
@@ -54,232 +52,221 @@ namespace
|
||||
|
||||
ss << ec;
|
||||
ss >> s;
|
||||
BOOST_TEST( s == expected );
|
||||
BOOST_CHECK( s == expected );
|
||||
}
|
||||
}
|
||||
|
||||
// main ------------------------------------------------------------------------------//
|
||||
// test_main ---------------------------------------------------------------//
|
||||
|
||||
// TODO: add hash_value tests
|
||||
|
||||
int main( int, char ** )
|
||||
int test_main( int, char ** )
|
||||
{
|
||||
|
||||
std::cout << "Conversion use cases...\n";
|
||||
error_condition x1( errc::file_exists );
|
||||
//error_code x2( errc::file_exists ); // should fail to compile
|
||||
make_error_code(errc::file_exists);
|
||||
make_error_condition(errc::file_exists);
|
||||
|
||||
std::cout << "General tests...\n";
|
||||
// unit tests:
|
||||
|
||||
BOOST_TEST( generic_category() == generic_category() );
|
||||
BOOST_TEST( system_category() == system_category() );
|
||||
BOOST_TEST( generic_category() != system_category() );
|
||||
BOOST_TEST( system_category() != generic_category() );
|
||||
BOOST_CHECK( posix_category == posix_category );
|
||||
BOOST_CHECK( system_category == system_category );
|
||||
BOOST_CHECK( posix_category != system_category );
|
||||
BOOST_CHECK( system_category != posix_category );
|
||||
|
||||
if ( std::less<const error_category*>()( &generic_category(), &system_category() ) )
|
||||
if ( std::less<const error_category*>()( &posix_category, &system_category ) )
|
||||
{
|
||||
BOOST_TEST( generic_category() < system_category() );
|
||||
BOOST_TEST( !(system_category() < generic_category()) );
|
||||
BOOST_CHECK( posix_category < system_category );
|
||||
BOOST_CHECK( !(system_category < posix_category) );
|
||||
}
|
||||
else
|
||||
{
|
||||
BOOST_TEST( system_category() < generic_category() );
|
||||
BOOST_TEST( !(generic_category() < system_category()) );
|
||||
BOOST_CHECK( system_category < posix_category );
|
||||
BOOST_CHECK( !(posix_category < system_category) );
|
||||
}
|
||||
|
||||
|
||||
error_code ec;
|
||||
error_condition econd;
|
||||
BOOST_TEST( !ec );
|
||||
BOOST_TEST( ec.value() == 0 );
|
||||
econd = ec.default_error_condition();
|
||||
BOOST_TEST( econd.value() == 0 );
|
||||
BOOST_TEST( econd.category() == generic_category() );
|
||||
BOOST_TEST( ec == errc::success );
|
||||
BOOST_TEST( ec.category() == system_category() );
|
||||
BOOST_TEST( std::strcmp( ec.category().name(), "system") == 0 );
|
||||
BOOST_TEST( !(ec < error_code( 0, system_category() )) );
|
||||
BOOST_TEST( !(error_code( 0, system_category() ) < ec) );
|
||||
BOOST_TEST( ec < error_code( 1, system_category() ) );
|
||||
BOOST_TEST( !(error_code( 1, system_category() ) < ec) );
|
||||
error_condition dec;
|
||||
BOOST_CHECK( !ec );
|
||||
BOOST_CHECK( ec.value() == 0 );
|
||||
dec = ec.default_error_condition();
|
||||
BOOST_CHECK( dec.value() == 0 );
|
||||
BOOST_CHECK( dec.category() == posix_category );
|
||||
BOOST_CHECK( ec == posix::success );
|
||||
BOOST_CHECK( ec.category() == system_category );
|
||||
BOOST_CHECK( std::strcmp( ec.category().name(), "system") == 0 );
|
||||
BOOST_CHECK( !(ec < error_code( 0, system_category )) );
|
||||
BOOST_CHECK( !(error_code( 0, system_category ) < ec) );
|
||||
BOOST_CHECK( ec < error_code( 1, system_category ) );
|
||||
BOOST_CHECK( !(error_code( 1, system_category ) < ec) );
|
||||
|
||||
error_code ec_0_system( 0, system_category() );
|
||||
BOOST_TEST( !ec_0_system );
|
||||
BOOST_TEST( ec_0_system.value() == 0 );
|
||||
econd = ec_0_system.default_error_condition();
|
||||
BOOST_TEST( econd.value() == 0 );
|
||||
BOOST_TEST( econd.category() == generic_category() );
|
||||
BOOST_TEST( ec_0_system == errc::success );
|
||||
BOOST_TEST( ec_0_system.category() == system_category() );
|
||||
BOOST_TEST( std::strcmp( ec_0_system.category().name(), "system") == 0 );
|
||||
error_code ec_0_system( 0, system_category );
|
||||
BOOST_CHECK( !ec_0_system );
|
||||
BOOST_CHECK( ec_0_system.value() == 0 );
|
||||
dec = ec_0_system.default_error_condition();
|
||||
BOOST_CHECK( dec.value() == 0 );
|
||||
BOOST_CHECK( dec.category() == posix_category );
|
||||
BOOST_CHECK( ec_0_system == posix::success );
|
||||
BOOST_CHECK( ec_0_system.category() == system_category );
|
||||
BOOST_CHECK( std::strcmp( ec_0_system.category().name(), "system") == 0 );
|
||||
check_ostream( ec_0_system, "system:0" );
|
||||
|
||||
BOOST_TEST( ec_0_system == ec );
|
||||
BOOST_CHECK( ec_0_system == ec );
|
||||
|
||||
error_code ec_1_system( 1, system_category() );
|
||||
BOOST_TEST( ec_1_system );
|
||||
BOOST_TEST( ec_1_system.value() == 1 );
|
||||
BOOST_TEST( ec_1_system.value() != 0 );
|
||||
BOOST_TEST( ec != ec_1_system );
|
||||
BOOST_TEST( ec_0_system != ec_1_system );
|
||||
error_code ec_1_system( 1, system_category );
|
||||
BOOST_CHECK( ec_1_system );
|
||||
BOOST_CHECK( ec_1_system.value() == 1 );
|
||||
BOOST_CHECK( ec_1_system.value() != 0 );
|
||||
BOOST_CHECK( ec != ec_1_system );
|
||||
BOOST_CHECK( ec_0_system != ec_1_system );
|
||||
check_ostream( ec_1_system, "system:1" );
|
||||
|
||||
ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category() );
|
||||
BOOST_TEST( ec );
|
||||
BOOST_TEST( ec.value() == BOOST_ACCESS_ERROR_MACRO );
|
||||
econd = ec.default_error_condition();
|
||||
BOOST_TEST( econd.value() == static_cast<int>(errc::permission_denied) );
|
||||
BOOST_TEST( econd.category() == generic_category() );
|
||||
BOOST_TEST( econd == error_condition( errc::permission_denied, generic_category() ) );
|
||||
BOOST_TEST( econd == errc::permission_denied );
|
||||
BOOST_TEST( errc::permission_denied == econd );
|
||||
BOOST_TEST( ec == errc::permission_denied );
|
||||
BOOST_TEST( ec.category() == system_category() );
|
||||
BOOST_TEST( std::strcmp( ec.category().name(), "system") == 0 );
|
||||
ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category );
|
||||
BOOST_CHECK( ec );
|
||||
BOOST_CHECK( ec.value() == BOOST_ACCESS_ERROR_MACRO );
|
||||
dec = ec.default_error_condition();
|
||||
BOOST_CHECK( dec.value() == static_cast<int>(posix::permission_denied) );
|
||||
BOOST_CHECK( dec.category() == posix_category );
|
||||
BOOST_CHECK( dec == error_condition( posix::permission_denied, posix_category ) );
|
||||
BOOST_CHECK( dec == posix::permission_denied );
|
||||
BOOST_CHECK( posix::permission_denied == dec );
|
||||
BOOST_CHECK( ec == posix::permission_denied );
|
||||
BOOST_CHECK( ec.category() == system_category );
|
||||
BOOST_CHECK( std::strcmp( ec.category().name(), "system") == 0 );
|
||||
|
||||
// test the explicit make_error_code conversion for errc
|
||||
ec = make_error_code( errc::bad_message );
|
||||
BOOST_TEST( ec );
|
||||
BOOST_TEST( ec == errc::bad_message );
|
||||
BOOST_TEST( errc::bad_message == ec );
|
||||
BOOST_TEST( ec != errc::permission_denied );
|
||||
BOOST_TEST( errc::permission_denied != ec );
|
||||
BOOST_TEST( ec.category() == generic_category() );
|
||||
// test the explicit make_error_code conversion for posix
|
||||
ec = make_error_code( posix::bad_message );
|
||||
BOOST_CHECK( ec );
|
||||
BOOST_CHECK( ec == posix::bad_message );
|
||||
BOOST_CHECK( posix::bad_message == ec );
|
||||
BOOST_CHECK( ec != posix::permission_denied );
|
||||
BOOST_CHECK( posix::permission_denied != ec );
|
||||
BOOST_CHECK( ec.category() == posix_category );
|
||||
|
||||
//// test the deprecated predefined error_category synonyms
|
||||
//BOOST_TEST( &system_category() == &native_ecat );
|
||||
//BOOST_TEST( &generic_category() == &errno_ecat );
|
||||
//BOOST_TEST( system_category() == native_ecat );
|
||||
//BOOST_TEST( generic_category() == errno_ecat );
|
||||
// test the deprecated predefined error_category synonyms
|
||||
BOOST_CHECK( &system_category == &native_ecat );
|
||||
BOOST_CHECK( &posix_category == &errno_ecat );
|
||||
BOOST_CHECK( system_category == native_ecat );
|
||||
BOOST_CHECK( posix_category == errno_ecat );
|
||||
|
||||
// test error_code and error_condition message();
|
||||
// see Boost.Filesystem operations_test for code specific message() tests
|
||||
ec = error_code( -1, system_category() );
|
||||
ec = error_code( -1, system_category );
|
||||
std::cout << "error_code message for -1 is \"" << ec.message() << "\"\n";
|
||||
std::cout << "error_code message for 0 is \"" << ec_0_system.message() << "\"\n";
|
||||
#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" );
|
||||
BOOST_CHECK( ec.message().substr(0,13) == "Unknown error" );
|
||||
#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" );
|
||||
BOOST_CHECK( ec.message().substr(0,13) == "Unknown error" );
|
||||
#elif defined(__hpux)
|
||||
BOOST_TEST( ec.message() == "" );
|
||||
BOOST_CHECK( ec.message() == "" );
|
||||
#elif defined(__osf__)
|
||||
BOOST_TEST( ec.message() == "Error -1 occurred." );
|
||||
BOOST_CHECK( ec.message() == "Error -1 occurred." );
|
||||
#elif defined(__vms)
|
||||
BOOST_TEST( ec.message() == "error -1" );
|
||||
BOOST_CHECK( ec.message() == "error -1" );
|
||||
#endif
|
||||
|
||||
ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category() );
|
||||
BOOST_TEST( ec.message() != "" );
|
||||
BOOST_TEST( ec.message().substr( 0, 13) != "Unknown error" );
|
||||
ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category );
|
||||
BOOST_CHECK( ec.message() != "" );
|
||||
BOOST_CHECK( ec.message().substr( 0, 13) != "Unknown error" );
|
||||
|
||||
econd = error_condition( -1, generic_category() );
|
||||
error_condition econd_ok;
|
||||
std::cout << "error_condition message for -1 is \"" << econd.message() << "\"\n";
|
||||
std::cout << "error_condition message for 0 is \"" << econd_ok.message() << "\"\n";
|
||||
dec = error_condition( -1, posix_category );
|
||||
std::cout << "error_condition message for -1 is \"" << dec.message() << "\"\n";
|
||||
#if defined(BOOST_WINDOWS_API)
|
||||
// Borland appends newline, so just check text
|
||||
BOOST_TEST( econd.message().substr(0,13) == "Unknown error" );
|
||||
BOOST_TEST( econd_ok.message().substr(0,8) == "No error" );
|
||||
BOOST_CHECK( dec.message().substr(0,13) == "Unknown error" );
|
||||
#elif defined(linux) || defined(__linux) || defined(__linux__)
|
||||
// Linux appends value to message as unsigned, so it varies with # of bits
|
||||
BOOST_TEST( econd.message().substr(0,13) == "Unknown error" );
|
||||
BOOST_CHECK( dec.message().substr(0,13) == "Unknown error" );
|
||||
#elif defined(__hpux)
|
||||
BOOST_TEST( econd.message() == "" );
|
||||
BOOST_CHECK( dec.message() == "" );
|
||||
#elif defined(__osf__)
|
||||
BOOST_TEST( econd.message() == "Error -1 occurred." );
|
||||
BOOST_CHECK( dec.message() == "Error -1 occurred." );
|
||||
#elif defined(__vms)
|
||||
BOOST_TEST( econd.message() == "error -1" );
|
||||
BOOST_CHECK( dec.message() == "error -1" );
|
||||
#endif
|
||||
|
||||
econd = error_condition( BOOST_ACCESS_ERROR_MACRO, generic_category() );
|
||||
BOOST_TEST( econd.message() != "" );
|
||||
BOOST_TEST( econd.message().substr( 0, 13) != "Unknown error" );
|
||||
dec = error_condition( BOOST_ACCESS_ERROR_MACRO, posix_category );
|
||||
BOOST_CHECK( dec.message() != "" );
|
||||
BOOST_CHECK( dec.message().substr( 0, 13) != "Unknown error" );
|
||||
|
||||
#ifdef BOOST_WINDOWS_API
|
||||
std::cout << "Windows tests...\n";
|
||||
// these tests probe the Windows errc decoder
|
||||
// these tests probe the Windows posix decoder
|
||||
// test the first entry in the decoder table:
|
||||
ec = error_code( ERROR_ACCESS_DENIED, system_category() );
|
||||
BOOST_TEST( ec.value() == ERROR_ACCESS_DENIED );
|
||||
BOOST_TEST( ec == errc::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
|
||||
ec = error_code( ERROR_ACCESS_DENIED, system_category );
|
||||
BOOST_CHECK( ec.value() == ERROR_ACCESS_DENIED );
|
||||
BOOST_CHECK( ec == posix::permission_denied );
|
||||
BOOST_CHECK( ec.default_error_condition().value() == posix::permission_denied );
|
||||
BOOST_CHECK( ec.default_error_condition().category() == posix_category );
|
||||
|
||||
// test the second entry in the decoder table:
|
||||
ec = error_code( ERROR_ALREADY_EXISTS, system_category() );
|
||||
BOOST_TEST( ec.value() == ERROR_ALREADY_EXISTS );
|
||||
BOOST_TEST( ec == errc::file_exists );
|
||||
BOOST_TEST( ec.default_error_condition().value() == errc::file_exists );
|
||||
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
|
||||
ec = error_code( ERROR_ALREADY_EXISTS, system_category );
|
||||
BOOST_CHECK( ec.value() == ERROR_ALREADY_EXISTS );
|
||||
BOOST_CHECK( ec == posix::file_exists );
|
||||
BOOST_CHECK( ec.default_error_condition().value() == posix::file_exists );
|
||||
BOOST_CHECK( ec.default_error_condition().category() == posix_category );
|
||||
|
||||
// test the third entry in the decoder table:
|
||||
ec = error_code( ERROR_BAD_UNIT, system_category() );
|
||||
BOOST_TEST( ec.value() == ERROR_BAD_UNIT );
|
||||
BOOST_TEST( ec == errc::no_such_device );
|
||||
BOOST_TEST( ec.default_error_condition().value() == errc::no_such_device );
|
||||
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
|
||||
ec = error_code( ERROR_BAD_UNIT, system_category );
|
||||
BOOST_CHECK( ec.value() == ERROR_BAD_UNIT );
|
||||
BOOST_CHECK( ec == posix::no_such_device );
|
||||
BOOST_CHECK( ec.default_error_condition().value() == posix::no_such_device );
|
||||
BOOST_CHECK( ec.default_error_condition().category() == posix_category );
|
||||
|
||||
// test the last non-Winsock entry in the decoder table:
|
||||
ec = error_code( ERROR_WRITE_PROTECT, system_category() );
|
||||
BOOST_TEST( ec.value() == ERROR_WRITE_PROTECT );
|
||||
BOOST_TEST( ec == errc::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
|
||||
ec = error_code( ERROR_WRITE_PROTECT, system_category );
|
||||
BOOST_CHECK( ec.value() == ERROR_WRITE_PROTECT );
|
||||
BOOST_CHECK( ec == posix::permission_denied );
|
||||
BOOST_CHECK( ec.default_error_condition().value() == posix::permission_denied );
|
||||
BOOST_CHECK( ec.default_error_condition().category() == posix_category );
|
||||
|
||||
// test the last Winsock entry in the decoder table:
|
||||
ec = error_code( WSAEWOULDBLOCK, system_category() );
|
||||
BOOST_TEST( ec.value() == WSAEWOULDBLOCK );
|
||||
BOOST_TEST( ec == errc::operation_would_block );
|
||||
BOOST_TEST( ec.default_error_condition().value() == errc::operation_would_block );
|
||||
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
|
||||
ec = error_code( WSAEWOULDBLOCK, system_category );
|
||||
BOOST_CHECK( ec.value() == WSAEWOULDBLOCK );
|
||||
BOOST_CHECK( ec == posix::operation_would_block );
|
||||
BOOST_CHECK( ec.default_error_condition().value() == posix::operation_would_block );
|
||||
BOOST_CHECK( ec.default_error_condition().category() == posix_category );
|
||||
|
||||
// test not-in-table condition:
|
||||
ec = error_code( 1234567890, system_category() );
|
||||
BOOST_TEST( ec.value() == 1234567890 );
|
||||
BOOST_TEST( ec.default_error_condition().value() == 1234567890 );
|
||||
BOOST_TEST( ec.default_error_condition().category() == system_category() );
|
||||
ec = error_code( 1234567890, system_category );
|
||||
BOOST_CHECK( ec.value() == 1234567890 );
|
||||
BOOST_CHECK( ec.default_error_condition().value() == 1234567890 );
|
||||
BOOST_CHECK( ec.default_error_condition().category() == system_category );
|
||||
|
||||
#else // POSIX
|
||||
|
||||
std::cout << "POSIX tests...\n";
|
||||
ec = error_code( EACCES, system_category() );
|
||||
BOOST_TEST( ec == error_code( errc::permission_denied, system_category() ) );
|
||||
BOOST_TEST( error_code( errc::permission_denied, system_category() ) == ec );
|
||||
BOOST_TEST( ec == errc::permission_denied );
|
||||
BOOST_TEST( errc::permission_denied == ec );
|
||||
BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
|
||||
BOOST_TEST( ec.default_error_condition().category() == generic_category() );
|
||||
ec = error_code( EACCES, system_category );
|
||||
BOOST_CHECK( ec == error_code( posix::permission_denied, system_category ) );
|
||||
BOOST_CHECK( error_code( posix::permission_denied, system_category ) == ec );
|
||||
BOOST_CHECK( ec == posix::permission_denied );
|
||||
BOOST_CHECK( posix::permission_denied == ec );
|
||||
BOOST_CHECK( ec.default_error_condition().value() == posix::permission_denied );
|
||||
BOOST_CHECK( ec.default_error_condition().category() == posix_category );
|
||||
|
||||
# ifdef __CYGWIN__
|
||||
|
||||
std::cout << "Cygwin tests...\n";
|
||||
ec = cygwin_error::no_package;
|
||||
BOOST_TEST( ec == cygwin_error::no_package );
|
||||
BOOST_TEST( ec == error_code( ENOPKG, system_category() ) );
|
||||
BOOST_TEST( ec == error_code( cygwin_error::no_package, system_category() ) );
|
||||
BOOST_TEST( ec.default_error_condition().category() == system_category() );
|
||||
BOOST_CHECK( ec == cygwin_error::no_package );
|
||||
BOOST_CHECK( ec == error_code( ENOPKG, system_category ) );
|
||||
BOOST_CHECK( ec == error_code( cygwin_error::no_package, system_category ) );
|
||||
BOOST_CHECK( ec.default_error_condition().category() == system_category );
|
||||
|
||||
# elif defined(linux) || defined(__linux) || defined(__linux__)
|
||||
|
||||
std::cout << "Linux tests...\n";
|
||||
ec = linux_error::dot_dot_error;
|
||||
BOOST_TEST( ec == linux_error::dot_dot_error );
|
||||
BOOST_TEST( ec == error_code( EDOTDOT, system_category() ) );
|
||||
BOOST_TEST( ec == error_code( linux_error::dot_dot_error, system_category() ) );
|
||||
BOOST_TEST( ec.default_error_condition().category() == system_category() );
|
||||
BOOST_CHECK( ec == linux_error::dot_dot_error );
|
||||
BOOST_CHECK( ec == error_code( EDOTDOT, system_category ) );
|
||||
BOOST_CHECK( ec == error_code( linux_error::dot_dot_error, system_category ) );
|
||||
BOOST_CHECK( ec.default_error_condition().category() == system_category );
|
||||
|
||||
# endif
|
||||
|
||||
#endif
|
||||
|
||||
return ::boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -14,13 +14,11 @@
|
||||
|
||||
// Motivation was a Boost posting by Christopher Kohlhoff on June 28, 2006.
|
||||
|
||||
#define BOOST_SYSTEM_NO_DEPRECATED
|
||||
|
||||
#include <boost/system/error_code.hpp>
|
||||
#include <boost/cerrno.hpp>
|
||||
#include <string>
|
||||
#include <cstdio>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/test/minimal.hpp>
|
||||
|
||||
#ifdef BOOST_POSIX_API
|
||||
# include <sys/stat.h>
|
||||
@@ -42,7 +40,7 @@ boost::system::error_code my_mkdir( const std::string & path )
|
||||
# else
|
||||
::CreateDirectoryA( path.c_str(), 0 ) != 0 ? 0 : ::GetLastError(),
|
||||
# endif
|
||||
boost::system::system_category() );
|
||||
boost::system::system_category );
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------ //
|
||||
@@ -55,9 +53,9 @@ boost::system::error_code my_remove( const std::string & path )
|
||||
{
|
||||
return boost::system::error_code(
|
||||
std::remove( path.c_str() ) == 0 ? 0 : errno,
|
||||
boost::system::generic_category() ); // OK for both Windows and POSIX
|
||||
// Alternatively, could use generic_category()
|
||||
// on Windows and system_category() on
|
||||
boost::system::posix_category ); // OK for both Windows and POSIX
|
||||
// Alternatively, could use posix_category
|
||||
// on Windows and system_category on
|
||||
// POSIX-based systems.
|
||||
}
|
||||
|
||||
@@ -75,7 +73,7 @@ namespace boost
|
||||
namespace lib3
|
||||
{
|
||||
// lib3 has its own error_category:
|
||||
const boost::system::error_category & get_lib3_error_category() BOOST_SYSTEM_NOEXCEPT;
|
||||
const boost::system::error_category & get_lib3_error_category();
|
||||
const boost::system::error_category & lib3_error_category = get_lib3_error_category();
|
||||
|
||||
enum error
|
||||
@@ -110,18 +108,16 @@ namespace boost
|
||||
class lib3_error_category_imp : public boost::system::error_category
|
||||
{
|
||||
public:
|
||||
lib3_error_category_imp() : boost::system::error_category() { }
|
||||
|
||||
const char * name() const BOOST_SYSTEM_NOEXCEPT
|
||||
const char * name() const
|
||||
{
|
||||
return "lib3";
|
||||
}
|
||||
|
||||
boost::system::error_condition default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT
|
||||
boost::system::error_condition default_error_condition( int ev ) const
|
||||
{
|
||||
return ev == boo_boo
|
||||
? boost::system::error_condition( boost::system::errc::io_error,
|
||||
boost::system::generic_category() )
|
||||
? boost::system::error_condition( boost::system::posix::io_error,
|
||||
boost::system::posix_category )
|
||||
: boost::system::error_condition( ev,
|
||||
boost::lib3::lib3_error_category );
|
||||
}
|
||||
@@ -135,7 +131,7 @@ namespace boost
|
||||
|
||||
};
|
||||
|
||||
const boost::system::error_category & get_lib3_error_category() BOOST_SYSTEM_NOEXCEPT
|
||||
const boost::system::error_category & get_lib3_error_category()
|
||||
{
|
||||
static const lib3_error_category_imp l3ecat;
|
||||
return l3ecat;
|
||||
@@ -156,7 +152,7 @@ namespace boost
|
||||
namespace lib4
|
||||
{
|
||||
// lib4 has its own error_category:
|
||||
const boost::system::error_category & get_lib4_error_category() BOOST_SYSTEM_NOEXCEPT;
|
||||
const boost::system::error_category & get_lib4_error_category();
|
||||
const boost::system::error_category & lib4_error_category = get_lib4_error_category();
|
||||
|
||||
extern const boost::system::error_code boo_boo;
|
||||
@@ -172,18 +168,16 @@ namespace lib4
|
||||
class lib4_error_category_imp : public boost::system::error_category
|
||||
{
|
||||
public:
|
||||
lib4_error_category_imp() : boost::system::error_category() { }
|
||||
|
||||
const char * name() const BOOST_SYSTEM_NOEXCEPT
|
||||
const char * name() const
|
||||
{
|
||||
return "lib4";
|
||||
}
|
||||
|
||||
boost::system::error_condition default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT
|
||||
boost::system::error_condition default_error_condition( int ev ) const
|
||||
{
|
||||
return ev == boo_boo.value()
|
||||
? boost::system::error_condition( boost::system::errc::io_error,
|
||||
boost::system::generic_category() )
|
||||
? boost::system::error_condition( boost::system::posix::io_error,
|
||||
boost::system::posix_category )
|
||||
: boost::system::error_condition( ev, lib4::lib4_error_category );
|
||||
}
|
||||
|
||||
@@ -195,7 +189,7 @@ namespace lib4
|
||||
}
|
||||
};
|
||||
|
||||
const boost::system::error_category & get_lib4_error_category() BOOST_SYSTEM_NOEXCEPT
|
||||
const boost::system::error_category & get_lib4_error_category()
|
||||
{
|
||||
static const lib4_error_category_imp l4ecat;
|
||||
return l4ecat;
|
||||
@@ -239,15 +233,15 @@ namespace lib4
|
||||
// switch (ev)
|
||||
// {
|
||||
// case user_success:
|
||||
// return boost::system::error_code(boost::system::errc::success, boost::system::generic_category());
|
||||
// return boost::system::error_code(boost::system::posix::success, boost::system::posix_category);
|
||||
// case user_permission_denied:
|
||||
// return boost::system::error_code(boost::system::errc::permission_denied, boost::system::generic_category());
|
||||
// return boost::system::error_code(boost::system::posix::permission_denied, boost::system::posix_category);
|
||||
// case user_out_of_memory:
|
||||
// return boost::system::error_code(boost::system::errc::not_enough_memory, boost::system::generic_category());
|
||||
// return boost::system::error_code(boost::system::posix::not_enough_memory, boost::system::posix_category);
|
||||
// default:
|
||||
// break;
|
||||
// }
|
||||
// return boost::system::error_code(boost::system::errc::no_posix_equivalent, boost::system::generic_category());
|
||||
// return boost::system::error_code(boost::system::posix::no_posix_equivalent, boost::system::posix_category);
|
||||
// }
|
||||
//
|
||||
// };
|
||||
@@ -266,8 +260,8 @@ namespace lib4
|
||||
//
|
||||
// void check_success(const boost::system::error_code& ec, bool expect)
|
||||
// {
|
||||
// BOOST_TEST( (ec == boost::system::errc::success) == expect );
|
||||
// if (ec == boost::system::errc::success)
|
||||
// BOOST_CHECK( (ec == boost::system::posix::success) == expect );
|
||||
// if (ec == boost::system::posix::success)
|
||||
// std::cout << "yes... " << (expect ? "ok" : "fail") << '\n';
|
||||
// else
|
||||
// std::cout << "no... " << (expect ? "fail" : "ok") << '\n';
|
||||
@@ -275,8 +269,8 @@ namespace lib4
|
||||
//
|
||||
// void check_permission_denied(const boost::system::error_code& ec, bool expect)
|
||||
// {
|
||||
// BOOST_TEST( (ec == boost::system::errc::permission_denied) == expect );
|
||||
// if (ec == boost::system::errc::permission_denied)
|
||||
// BOOST_CHECK( (ec == boost::system::posix::permission_denied) == expect );
|
||||
// if (ec == boost::system::posix::permission_denied)
|
||||
// std::cout << "yes... " << (expect ? "ok" : "fail") << '\n';
|
||||
// else
|
||||
// std::cout << "no... " << (expect ? "fail" : "ok") << '\n';
|
||||
@@ -284,8 +278,8 @@ namespace lib4
|
||||
//
|
||||
// void check_out_of_memory(const boost::system::error_code& ec, bool expect)
|
||||
// {
|
||||
// BOOST_TEST( (ec == boost::system::errc::not_enough_memory) == expect );
|
||||
// if (ec == boost::system::errc::not_enough_memory)
|
||||
// BOOST_CHECK( (ec == boost::system::posix::not_enough_memory) == expect );
|
||||
// if (ec == boost::system::posix::not_enough_memory)
|
||||
// std::cout << "yes... " << (expect ? "ok" : "fail") << '\n';
|
||||
// else
|
||||
// std::cout << "no... " << (expect ? "fail" : "ok") << '\n';
|
||||
@@ -297,23 +291,23 @@ namespace lib4
|
||||
// printf("=====\n");
|
||||
// boost::system::error_code ec;
|
||||
// check_success(ec, true);
|
||||
// check_success(boost::system::errc::success, true);
|
||||
// check_success(boost::system::errc::permission_denied, false);
|
||||
// check_success(boost::system::errc::not_enough_memory, false);
|
||||
// check_success(boost::system::posix::success, true);
|
||||
// check_success(boost::system::posix::permission_denied, false);
|
||||
// check_success(boost::system::posix::not_enough_memory, false);
|
||||
// check_success(user_success, true);
|
||||
// check_success(user_permission_denied, false);
|
||||
// check_success(user_out_of_memory, false);
|
||||
// check_permission_denied(ec, false);
|
||||
// check_permission_denied(boost::system::errc::success, false);
|
||||
// check_permission_denied(boost::system::errc::permission_denied, true);
|
||||
// check_permission_denied(boost::system::errc::not_enough_memory, false);
|
||||
// check_permission_denied(boost::system::posix::success, false);
|
||||
// check_permission_denied(boost::system::posix::permission_denied, true);
|
||||
// check_permission_denied(boost::system::posix::not_enough_memory, false);
|
||||
// check_permission_denied(user_success, false);
|
||||
// check_permission_denied(user_permission_denied, true);
|
||||
// check_permission_denied(user_out_of_memory, false);
|
||||
// check_out_of_memory(ec, false);
|
||||
// check_out_of_memory(boost::system::errc::success, false);
|
||||
// check_out_of_memory(boost::system::errc::permission_denied, false);
|
||||
// check_out_of_memory(boost::system::errc::not_enough_memory, true);
|
||||
// check_out_of_memory(boost::system::posix::success, false);
|
||||
// check_out_of_memory(boost::system::posix::permission_denied, false);
|
||||
// check_out_of_memory(boost::system::posix::not_enough_memory, true);
|
||||
// check_out_of_memory(user_success, false);
|
||||
// check_out_of_memory(user_permission_denied, false);
|
||||
// check_out_of_memory(user_out_of_memory, true);
|
||||
@@ -339,7 +333,7 @@ namespace lib4
|
||||
|
||||
// ------------------------------------------------------------------------ //
|
||||
|
||||
int main( int, char *[] )
|
||||
int test_main( int, char *[] )
|
||||
{
|
||||
boost::system::error_code ec;
|
||||
|
||||
@@ -348,35 +342,35 @@ int main( int, char *[] )
|
||||
ec = my_mkdir( "/no-such-file-or-directory/will-not-succeed" );
|
||||
std::cout << "ec.value() is " << ec.value() << '\n';
|
||||
|
||||
BOOST_TEST( ec );
|
||||
BOOST_TEST( ec == boost::system::errc::no_such_file_or_directory );
|
||||
BOOST_TEST( ec.category() == boost::system::system_category() );
|
||||
BOOST_CHECK( ec );
|
||||
BOOST_CHECK( ec == boost::system::posix::no_such_file_or_directory );
|
||||
BOOST_CHECK( ec.category() == boost::system::system_category );
|
||||
|
||||
// Library 2 tests:
|
||||
|
||||
ec = my_remove( "/no-such-file-or-directory" );
|
||||
std::cout << "ec.value() is " << ec.value() << '\n';
|
||||
|
||||
BOOST_TEST( ec );
|
||||
BOOST_TEST( ec == boost::system::errc::no_such_file_or_directory );
|
||||
BOOST_TEST( ec.category() == boost::system::generic_category() );
|
||||
BOOST_CHECK( ec );
|
||||
BOOST_CHECK( ec == boost::system::posix::no_such_file_or_directory );
|
||||
BOOST_CHECK( ec.category() == boost::system::posix_category );
|
||||
|
||||
// Library 3 tests:
|
||||
|
||||
ec = boost::lib3::boo_boo;
|
||||
std::cout << "ec.value() is " << ec.value() << '\n';
|
||||
|
||||
BOOST_TEST( ec );
|
||||
BOOST_TEST( ec == boost::lib3::boo_boo );
|
||||
BOOST_TEST( ec.value() == boost::lib3::boo_boo );
|
||||
BOOST_TEST( ec.category() == boost::lib3::lib3_error_category );
|
||||
BOOST_CHECK( ec );
|
||||
BOOST_CHECK( ec == boost::lib3::boo_boo );
|
||||
BOOST_CHECK( ec.value() == boost::lib3::boo_boo );
|
||||
BOOST_CHECK( ec.category() == boost::lib3::lib3_error_category );
|
||||
|
||||
BOOST_TEST( ec == boost::system::errc::io_error );
|
||||
BOOST_CHECK( ec == boost::system::posix::io_error );
|
||||
|
||||
boost::system::error_code ec3( boost::lib3::boo_boo+100,
|
||||
boost::lib3::lib3_error_category );
|
||||
BOOST_TEST( ec3.category() == boost::lib3::lib3_error_category );
|
||||
BOOST_TEST( ec3.default_error_condition().category()
|
||||
BOOST_CHECK( ec3.category() == boost::lib3::lib3_error_category );
|
||||
BOOST_CHECK( ec3.default_error_condition().category()
|
||||
== boost::lib3::lib3_error_category );
|
||||
|
||||
// Library 4 tests:
|
||||
@@ -384,21 +378,21 @@ int main( int, char *[] )
|
||||
ec = lib4::boo_boo;
|
||||
std::cout << "ec.value() is " << ec.value() << '\n';
|
||||
|
||||
BOOST_TEST( ec );
|
||||
BOOST_TEST( ec == lib4::boo_boo );
|
||||
BOOST_TEST( ec.value() == lib4::boo_boo.value() );
|
||||
BOOST_TEST( ec.category() == lib4::lib4_error_category );
|
||||
BOOST_CHECK( ec );
|
||||
BOOST_CHECK( ec == lib4::boo_boo );
|
||||
BOOST_CHECK( ec.value() == lib4::boo_boo.value() );
|
||||
BOOST_CHECK( ec.category() == lib4::lib4_error_category );
|
||||
|
||||
BOOST_TEST( ec == boost::system::errc::io_error );
|
||||
BOOST_CHECK( ec == boost::system::posix::io_error );
|
||||
|
||||
boost::system::error_code ec4( lib4::boo_boo.value()+100,
|
||||
lib4::lib4_error_category );
|
||||
BOOST_TEST( ec4.default_error_condition().category()
|
||||
BOOST_CHECK( ec4.default_error_condition().category()
|
||||
== lib4::lib4_error_category );
|
||||
|
||||
// Test 3
|
||||
|
||||
//test3::run();
|
||||
|
||||
return ::boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -9,15 +9,23 @@
|
||||
|
||||
//----------------------------------------------------------------------------//
|
||||
|
||||
#include <boost/config/warning_disable.hpp>
|
||||
// VC++ 8.0 warns on usage of certain Standard Library and API functions that
|
||||
// can cause buffer overruns or other possible security issues if misused.
|
||||
// See http://msdn.microsoft.com/msdnmag/issues/05/05/SafeCandC/default.aspx
|
||||
// But the wording of the warning is misleading and unsettling, there are no
|
||||
// portable altersystem functions, and VC++ 8.0's own libraries use the
|
||||
// functions in question. So turn off the warnings.
|
||||
#define _CRT_SECURE_NO_DEPRECATE
|
||||
#define _SCL_SECURE_NO_DEPRECATE
|
||||
|
||||
#define BOOST_ERROR_CODE_HEADER_ONLY
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/test/minimal.hpp>
|
||||
|
||||
#include <boost/system/error_code.hpp>
|
||||
|
||||
int main( int, char*[] )
|
||||
int test_main( int, char*[] )
|
||||
{
|
||||
boost::system::error_code ec( 0, boost::system::system_category() );
|
||||
return ::boost::report_errors();
|
||||
boost::system::error_code ec( 0, boost::system::system_category );
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
// This test verifiies that the error_category vtable does not suffer from
|
||||
// order-of-initialization problems.
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/system/error_code.hpp>
|
||||
|
||||
struct foo
|
||||
@@ -22,7 +22,7 @@ struct foo
|
||||
}
|
||||
} f;
|
||||
|
||||
int main( int, char ** )
|
||||
int test_main( int, char ** )
|
||||
{
|
||||
return ::boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,22 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ImportGroup Label="PropertySheets" />
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup />
|
||||
<ItemDefinitionGroup>
|
||||
<ClCompile>
|
||||
<AdditionalIncludeDirectories>../../../../..</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup>
|
||||
<ClCompile>
|
||||
<WarningLevel>Level4</WarningLevel>
|
||||
<PreprocessorDefinitions>BOOST_ALL_NO_LIB;BOOST_ALL_DYN_LINK;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<ExceptionHandling>Async</ExceptionHandling>
|
||||
</ClCompile>
|
||||
<PostBuildEvent>
|
||||
<Command>"$(TargetDir)\$(TargetName).exe"</Command>
|
||||
</PostBuildEvent>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup />
|
||||
</Project>
|
||||
@@ -1,97 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|Win32">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|Win32">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>{E18C2B56-DCEC-438F-9C38-3C8B08B65247}</ProjectGuid>
|
||||
<Keyword>Win32Proj</Keyword>
|
||||
<RootNamespace>config_test</RootNamespace>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<SDLCheck>true</SDLCheck>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<SDLCheck>true</SDLCheck>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\config_test.cpp" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="..\..\..\include\boost\system\api_config.hpp" />
|
||||
<ClInclude Include="..\..\..\include\boost\system\config.hpp" />
|
||||
<ClInclude Include="..\..\..\include\boost\system\cygwin_error.hpp" />
|
||||
<ClInclude Include="..\..\..\include\boost\system\error_code.hpp" />
|
||||
<ClInclude Include="..\..\..\include\boost\system\linux_error.hpp" />
|
||||
<ClInclude Include="..\..\..\include\boost\system\system_error.hpp" />
|
||||
<ClInclude Include="..\..\..\include\boost\system\windows_error.hpp" />
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
@@ -1,91 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|Win32">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|Win32">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>{E50C14DC-547D-4C33-83EA-653C0D0D4E64}</ProjectGuid>
|
||||
<Keyword>Win32Proj</Keyword>
|
||||
<RootNamespace>error_code_test</RootNamespace>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\system-dll\system-dll.vcxproj">
|
||||
<Project>{419402d4-f990-4b05-a459-655e2dc33dc2}</Project>
|
||||
</ProjectReference>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\error_code_test.cpp" />
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
@@ -1,151 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|Win32">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|Win32">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Debug|x64">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|x64">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<VCProjectVersion>15.0</VCProjectVersion>
|
||||
<ProjectGuid>{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}</ProjectGuid>
|
||||
<Keyword>Win32Proj</Keyword>
|
||||
<RootNamespace>header_only_error_code_test</RootNamespace>
|
||||
<WindowsTargetPlatformVersion>10.0.14393.0</WindowsTargetPlatformVersion>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="Shared">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions);BOOST_ERROR_CODE_HEADER_ONLY</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<ClCompile>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions);BOOST_ERROR_CODE_HEADER_ONLY</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions);BOOST_ERROR_CODE_HEADER_ONLY</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions);BOOST_ERROR_CODE_HEADER_ONLY</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\error_code_test.cpp" />
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
@@ -1,86 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|Win32">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|Win32">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>{3773451B-A618-4A26-A7F2-85554F4BD21B}</ProjectGuid>
|
||||
<Keyword>Win32Proj</Keyword>
|
||||
<RootNamespace>header_only_test</RootNamespace>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\header_only_test.cpp" />
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
@@ -1,156 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|Win32">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|Win32">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Debug|x64">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|x64">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<VCProjectVersion>15.0</VCProjectVersion>
|
||||
<ProjectGuid>{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}</ProjectGuid>
|
||||
<Keyword>Win32Proj</Keyword>
|
||||
<RootNamespace>std_interop_test</RootNamespace>
|
||||
<WindowsTargetPlatformVersion>10.0.14393.0</WindowsTargetPlatformVersion>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="Shared">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
|
||||
<ClCompile>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\std_interop_test.cpp" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\system-dll\system-dll.vcxproj">
|
||||
<Project>{419402d4-f990-4b05-a459-655e2dc33dc2}</Project>
|
||||
</ProjectReference>
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
@@ -1,90 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|Win32">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|Win32">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>Win32</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>{419402D4-F990-4B05-A459-655E2DC33DC2}</ProjectGuid>
|
||||
<Keyword>Win32Proj</Keyword>
|
||||
<RootNamespace>systemdll</RootNamespace>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
||||
<ConfigurationType>DynamicLibrary</ConfigurationType>
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
||||
<ConfigurationType>DynamicLibrary</ConfigurationType>
|
||||
<UseDebugLibraries>false</UseDebugLibraries>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
<CharacterSet>Unicode</CharacterSet>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
||||
<Import Project="..\common.props" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<LinkIncremental>true</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<LinkIncremental>false</LinkIncremental>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
||||
<ClCompile>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;SYSTEMDLL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<LanguageStandard>stdcpplatest</LanguageStandard>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
</Link>
|
||||
<PostBuildEvent>
|
||||
<Command />
|
||||
</PostBuildEvent>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PrecompiledHeader>
|
||||
</PrecompiledHeader>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
||||
<PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;SYSTEMDLL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Windows</SubSystem>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
||||
<OptimizeReferences>true</OptimizeReferences>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="..\..\..\src\error_code.cpp" />
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
@@ -1,83 +0,0 @@
|
||||
|
||||
Microsoft Visual Studio Solution File, Format Version 12.00
|
||||
# Visual Studio 15
|
||||
VisualStudioVersion = 15.0.26430.6
|
||||
MinimumVisualStudioVersion = 10.0.40219.1
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "system-dll", "system-dll\system-dll.vcxproj", "{419402D4-F990-4B05-A459-655E2DC33DC2}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "error_code_test", "error_code_test\error_code_test.vcxproj", "{E50C14DC-547D-4C33-83EA-653C0D0D4E64}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "header_only_test", "header_only_test\header_only_test.vcxproj", "{3773451B-A618-4A26-A7F2-85554F4BD21B}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "config_test", "config_test\config_test.vcxproj", "{E18C2B56-DCEC-438F-9C38-3C8B08B65247}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "clang-system-dll", "clang-system-dll\clang-system-dll.vcxproj", "{30993F97-5E77-4B5A-B25F-B545C276077A}"
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "std_interop_test", "std_interop_test\std_interop_test.vcxproj", "{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}"
|
||||
ProjectSection(ProjectDependencies) = postProject
|
||||
{419402D4-F990-4B05-A459-655E2DC33DC2} = {419402D4-F990-4B05-A459-655E2DC33DC2}
|
||||
EndProjectSection
|
||||
EndProject
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "header_only_error_code_test", "header_only_error_code_test\header_only_error_code_test.vcxproj", "{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Win32 = Debug|Win32
|
||||
Debug|x64 = Debug|x64
|
||||
Release|Win32 = Release|Win32
|
||||
Release|x64 = Release|x64
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{419402D4-F990-4B05-A459-655E2DC33DC2}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{419402D4-F990-4B05-A459-655E2DC33DC2}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{419402D4-F990-4B05-A459-655E2DC33DC2}.Debug|x64.ActiveCfg = Debug|Win32
|
||||
{419402D4-F990-4B05-A459-655E2DC33DC2}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{419402D4-F990-4B05-A459-655E2DC33DC2}.Release|Win32.Build.0 = Release|Win32
|
||||
{419402D4-F990-4B05-A459-655E2DC33DC2}.Release|x64.ActiveCfg = Release|Win32
|
||||
{E50C14DC-547D-4C33-83EA-653C0D0D4E64}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{E50C14DC-547D-4C33-83EA-653C0D0D4E64}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{E50C14DC-547D-4C33-83EA-653C0D0D4E64}.Debug|x64.ActiveCfg = Debug|Win32
|
||||
{E50C14DC-547D-4C33-83EA-653C0D0D4E64}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{E50C14DC-547D-4C33-83EA-653C0D0D4E64}.Release|Win32.Build.0 = Release|Win32
|
||||
{E50C14DC-547D-4C33-83EA-653C0D0D4E64}.Release|x64.ActiveCfg = Release|Win32
|
||||
{3773451B-A618-4A26-A7F2-85554F4BD21B}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{3773451B-A618-4A26-A7F2-85554F4BD21B}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{3773451B-A618-4A26-A7F2-85554F4BD21B}.Debug|x64.ActiveCfg = Debug|Win32
|
||||
{3773451B-A618-4A26-A7F2-85554F4BD21B}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{3773451B-A618-4A26-A7F2-85554F4BD21B}.Release|Win32.Build.0 = Release|Win32
|
||||
{3773451B-A618-4A26-A7F2-85554F4BD21B}.Release|x64.ActiveCfg = Release|Win32
|
||||
{E18C2B56-DCEC-438F-9C38-3C8B08B65247}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{E18C2B56-DCEC-438F-9C38-3C8B08B65247}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{E18C2B56-DCEC-438F-9C38-3C8B08B65247}.Debug|x64.ActiveCfg = Debug|Win32
|
||||
{E18C2B56-DCEC-438F-9C38-3C8B08B65247}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{E18C2B56-DCEC-438F-9C38-3C8B08B65247}.Release|Win32.Build.0 = Release|Win32
|
||||
{E18C2B56-DCEC-438F-9C38-3C8B08B65247}.Release|x64.ActiveCfg = Release|Win32
|
||||
{30993F97-5E77-4B5A-B25F-B545C276077A}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{30993F97-5E77-4B5A-B25F-B545C276077A}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{30993F97-5E77-4B5A-B25F-B545C276077A}.Debug|x64.ActiveCfg = Debug|x64
|
||||
{30993F97-5E77-4B5A-B25F-B545C276077A}.Debug|x64.Build.0 = Debug|x64
|
||||
{30993F97-5E77-4B5A-B25F-B545C276077A}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{30993F97-5E77-4B5A-B25F-B545C276077A}.Release|Win32.Build.0 = Release|Win32
|
||||
{30993F97-5E77-4B5A-B25F-B545C276077A}.Release|x64.ActiveCfg = Release|x64
|
||||
{30993F97-5E77-4B5A-B25F-B545C276077A}.Release|x64.Build.0 = Release|x64
|
||||
{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Debug|x64.ActiveCfg = Debug|x64
|
||||
{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Debug|x64.Build.0 = Debug|x64
|
||||
{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Release|Win32.Build.0 = Release|Win32
|
||||
{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Release|x64.ActiveCfg = Release|x64
|
||||
{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Release|x64.Build.0 = Release|x64
|
||||
{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Debug|Win32.ActiveCfg = Debug|Win32
|
||||
{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Debug|Win32.Build.0 = Debug|Win32
|
||||
{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Debug|x64.ActiveCfg = Debug|x64
|
||||
{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Debug|x64.Build.0 = Debug|x64
|
||||
{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Release|Win32.ActiveCfg = Release|Win32
|
||||
{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Release|Win32.Build.0 = Release|Win32
|
||||
{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Release|x64.ActiveCfg = Release|x64
|
||||
{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Release|x64.Build.0 = Release|x64
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
@@ -1,370 +0,0 @@
|
||||
|
||||
// Copyright 2017 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
|
||||
|
||||
// Avoid spurious VC++ warnings
|
||||
# define _CRT_SECURE_NO_WARNINGS
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
|
||||
|
||||
int main()
|
||||
{
|
||||
std::cout
|
||||
<< "The version of the C++ standard library being used does not"
|
||||
" support header <system_error> so interoperation will not be tested.\n";
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
#include <boost/system/error_code.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <system_error>
|
||||
#include <cerrno>
|
||||
#include <string>
|
||||
#include <cstdio>
|
||||
|
||||
static void test_generic_category()
|
||||
{
|
||||
boost::system::error_category const & bt = boost::system::generic_category();
|
||||
std::error_category const & st = bt;
|
||||
|
||||
BOOST_TEST_CSTR_EQ( bt.name(), st.name() );
|
||||
|
||||
int ev = ENOENT;
|
||||
|
||||
BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
|
||||
|
||||
{
|
||||
boost::system::error_code bc( ev, bt );
|
||||
|
||||
BOOST_TEST_EQ( bc.value(), ev );
|
||||
BOOST_TEST_EQ( &bc.category(), &bt );
|
||||
|
||||
std::error_code sc( bc );
|
||||
|
||||
BOOST_TEST_EQ( sc.value(), ev );
|
||||
BOOST_TEST_EQ( &sc.category(), &st );
|
||||
}
|
||||
|
||||
{
|
||||
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 ) );
|
||||
|
||||
std::error_condition sn( bn );
|
||||
|
||||
BOOST_TEST_EQ( sn.value(), ev );
|
||||
BOOST_TEST_EQ( &sn.category(), &st );
|
||||
|
||||
BOOST_TEST( st.equivalent( ev, sn ) );
|
||||
}
|
||||
}
|
||||
|
||||
static void test_system_category()
|
||||
{
|
||||
boost::system::error_category const & bt = boost::system::system_category();
|
||||
std::error_category const & st = bt;
|
||||
|
||||
BOOST_TEST_CSTR_EQ( bt.name(), st.name() );
|
||||
|
||||
{
|
||||
int ev = 5;
|
||||
BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
|
||||
|
||||
{
|
||||
boost::system::error_code bc( ev, bt );
|
||||
|
||||
BOOST_TEST_EQ( bc.value(), ev );
|
||||
BOOST_TEST_EQ( &bc.category(), &bt );
|
||||
|
||||
std::error_code sc( bc );
|
||||
|
||||
BOOST_TEST_EQ( sc.value(), ev );
|
||||
BOOST_TEST_EQ( &sc.category(), &st );
|
||||
}
|
||||
|
||||
{
|
||||
boost::system::error_condition bn = bt.default_error_condition( ev );
|
||||
BOOST_TEST( bt.equivalent( ev, bn ) );
|
||||
|
||||
std::error_condition sn( bn );
|
||||
BOOST_TEST( st.equivalent( ev, sn ) );
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
int ev = 4;
|
||||
BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
|
||||
|
||||
{
|
||||
boost::system::error_code bc( ev, bt );
|
||||
|
||||
BOOST_TEST_EQ( bc.value(), ev );
|
||||
BOOST_TEST_EQ( &bc.category(), &bt );
|
||||
|
||||
std::error_code sc( bc );
|
||||
|
||||
BOOST_TEST_EQ( sc.value(), ev );
|
||||
BOOST_TEST_EQ( &sc.category(), &st );
|
||||
}
|
||||
|
||||
{
|
||||
boost::system::error_condition bn = bt.default_error_condition( ev );
|
||||
BOOST_TEST( bt.equivalent( ev, bn ) );
|
||||
|
||||
std::error_condition sn( bn );
|
||||
BOOST_TEST( st.equivalent( ev, sn ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// test_user_category
|
||||
|
||||
class user_category_impl: public boost::system::error_category
|
||||
{
|
||||
public:
|
||||
|
||||
virtual const char * name() const BOOST_NOEXCEPT
|
||||
{
|
||||
return "user";
|
||||
}
|
||||
|
||||
virtual std::string message( int ev ) const
|
||||
{
|
||||
char buffer[ 256 ];
|
||||
std::sprintf( buffer, "user message %d", ev );
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
virtual boost::system::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT
|
||||
{
|
||||
if( ev == 4 )
|
||||
{
|
||||
return boost::system::error_condition( EMFILE, boost::system::generic_category() );
|
||||
}
|
||||
else if( ev == 5 )
|
||||
{
|
||||
return boost::system::error_condition( EACCES, boost::system::generic_category() );
|
||||
}
|
||||
else
|
||||
{
|
||||
return boost::system::error_condition( ev, *this );
|
||||
}
|
||||
}
|
||||
|
||||
virtual bool equivalent( int code, const boost::system::error_condition & condition ) const BOOST_NOEXCEPT
|
||||
{
|
||||
if( code == 4 && condition == make_error_condition( boost::system::errc::too_many_files_open_in_system ) )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
if( code == 4 && condition == make_error_condition( boost::system::errc::too_many_files_open ) )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
return default_error_condition( code ) == condition;
|
||||
}
|
||||
|
||||
// virtual bool equivalent( const error_code & code, int condition ) const BOOST_NOEXCEPT;
|
||||
};
|
||||
|
||||
boost::system::error_category const & user_category()
|
||||
{
|
||||
static user_category_impl cat_;
|
||||
return cat_;
|
||||
}
|
||||
|
||||
static void test_user_category()
|
||||
{
|
||||
boost::system::error_category const & bt = user_category();
|
||||
std::error_category const & st = bt;
|
||||
|
||||
BOOST_TEST_CSTR_EQ( bt.name(), st.name() );
|
||||
|
||||
{
|
||||
int ev = 5;
|
||||
BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
|
||||
|
||||
{
|
||||
boost::system::error_code bc( ev, bt );
|
||||
|
||||
BOOST_TEST_EQ( bc.value(), ev );
|
||||
BOOST_TEST_EQ( &bc.category(), &bt );
|
||||
|
||||
std::error_code sc( bc );
|
||||
|
||||
BOOST_TEST_EQ( sc.value(), ev );
|
||||
BOOST_TEST_EQ( &sc.category(), &st );
|
||||
}
|
||||
|
||||
{
|
||||
boost::system::error_condition bn = bt.default_error_condition( ev );
|
||||
BOOST_TEST( bt.equivalent( ev, bn ) );
|
||||
|
||||
std::error_condition sn( bn );
|
||||
BOOST_TEST( st.equivalent( ev, sn ) );
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
int ev = 4;
|
||||
BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
|
||||
|
||||
{
|
||||
boost::system::error_code bc( ev, bt );
|
||||
|
||||
BOOST_TEST_EQ( bc.value(), ev );
|
||||
BOOST_TEST_EQ( &bc.category(), &bt );
|
||||
|
||||
std::error_code sc( bc );
|
||||
|
||||
BOOST_TEST_EQ( sc.value(), ev );
|
||||
BOOST_TEST_EQ( &sc.category(), &st );
|
||||
}
|
||||
|
||||
{
|
||||
boost::system::error_condition bn = bt.default_error_condition( ev );
|
||||
BOOST_TEST( bt.equivalent( ev, bn ) );
|
||||
|
||||
std::error_condition sn( bn );
|
||||
BOOST_TEST( st.equivalent( ev, sn ) );
|
||||
}
|
||||
|
||||
{
|
||||
boost::system::error_condition bn = make_error_condition( boost::system::errc::too_many_files_open_in_system );
|
||||
BOOST_TEST( bt.equivalent( ev, bn ) );
|
||||
|
||||
std::error_condition sn( bn );
|
||||
BOOST_TEST( st.equivalent( ev, sn ) );
|
||||
}
|
||||
|
||||
{
|
||||
boost::system::error_condition bn = make_error_condition( boost::system::errc::too_many_files_open );
|
||||
BOOST_TEST( bt.equivalent( ev, bn ) );
|
||||
|
||||
std::error_condition sn( bn );
|
||||
BOOST_TEST( st.equivalent( ev, sn ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// test_user2_category
|
||||
|
||||
enum user2_errc
|
||||
{
|
||||
my_enoent = 1,
|
||||
my_einval,
|
||||
my_other
|
||||
};
|
||||
|
||||
class user2_category_impl: public boost::system::error_category
|
||||
{
|
||||
public:
|
||||
|
||||
virtual const char * name() const BOOST_NOEXCEPT
|
||||
{
|
||||
return "user2";
|
||||
}
|
||||
|
||||
virtual std::string message( int ev ) const
|
||||
{
|
||||
char buffer[ 256 ];
|
||||
std::sprintf( buffer, "user2 message %d", ev );
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
virtual boost::system::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT
|
||||
{
|
||||
return boost::system::error_condition( ev, *this );
|
||||
}
|
||||
|
||||
virtual bool equivalent( int code, const boost::system::error_condition & condition ) const BOOST_NOEXCEPT
|
||||
{
|
||||
return default_error_condition( code ) == condition;
|
||||
}
|
||||
|
||||
virtual bool equivalent( const boost::system::error_code & code, int condition ) const BOOST_NOEXCEPT
|
||||
{
|
||||
if( code.category() == *this )
|
||||
{
|
||||
return condition == code.value();
|
||||
}
|
||||
else if( condition == my_enoent )
|
||||
{
|
||||
return code == boost::system::errc::no_such_file_or_directory;
|
||||
}
|
||||
else if( condition == my_einval )
|
||||
{
|
||||
return code == boost::system::errc::invalid_argument;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
boost::system::error_category const & user2_category()
|
||||
{
|
||||
static user2_category_impl cat_;
|
||||
return cat_;
|
||||
}
|
||||
|
||||
static void test_user2_category()
|
||||
{
|
||||
boost::system::error_category const & bt = user2_category();
|
||||
std::error_category const & st = bt;
|
||||
|
||||
int ev = my_enoent;
|
||||
|
||||
boost::system::error_condition bn( ev, bt );
|
||||
|
||||
BOOST_TEST_EQ( bn.value(), ev );
|
||||
BOOST_TEST_EQ( &bn.category(), &bt );
|
||||
|
||||
boost::system::error_code bc = make_error_code( boost::system::errc::no_such_file_or_directory );
|
||||
|
||||
BOOST_TEST( bc == bn );
|
||||
|
||||
std::error_condition sn( bn );
|
||||
|
||||
BOOST_TEST_EQ( sn.value(), ev );
|
||||
BOOST_TEST_EQ( &sn.category(), &st );
|
||||
|
||||
std::error_code sc( bc );
|
||||
|
||||
BOOST_TEST( sc == sn );
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
int main()
|
||||
{
|
||||
std::cout
|
||||
<< "The version of the C++ standard library being used"
|
||||
" supports header <system_error> so interoperation will be tested.\n";
|
||||
test_generic_category();
|
||||
test_system_category();
|
||||
test_user_category();
|
||||
test_user2_category();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -1,65 +0,0 @@
|
||||
|
||||
// Copyright 2017 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
|
||||
|
||||
// Avoid spurious VC++ warnings
|
||||
# define _CRT_SECURE_NO_WARNINGS
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
|
||||
|
||||
int main()
|
||||
{
|
||||
std::cout
|
||||
<< "The version of the C++ standard library being used does not"
|
||||
" support header <system_error> so interoperation will not be tested.\n";
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
#include <boost/system/error_code.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <system_error>
|
||||
#include <cerrno>
|
||||
#include <string>
|
||||
#include <cstdio>
|
||||
|
||||
static void test_generic_category()
|
||||
{
|
||||
boost::system::error_category const & bt = boost::system::generic_category();
|
||||
std::error_category const & st = bt;
|
||||
|
||||
BOOST_TEST_CSTR_EQ( bt.name(), st.name() );
|
||||
BOOST_TEST_EQ( bt.name(), st.name() );
|
||||
}
|
||||
|
||||
static void test_system_category()
|
||||
{
|
||||
boost::system::error_category const & bt = boost::system::system_category();
|
||||
std::error_category const & st = bt;
|
||||
|
||||
BOOST_TEST_CSTR_EQ( bt.name(), st.name() );
|
||||
BOOST_TEST_EQ( bt.name(), st.name() );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
std::cout
|
||||
<< "The version of the C++ standard library being used"
|
||||
" supports header <system_error> so interoperation will be tested.\n";
|
||||
|
||||
test_generic_category();
|
||||
test_system_category();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
#endif
|
||||
+32
-53
@@ -1,7 +1,7 @@
|
||||
// system_error_test.cpp ---------------------------------------------------//
|
||||
|
||||
// Copyright Beman Dawes 2006
|
||||
// Copyright (c) Microsoft Corporation 2014
|
||||
|
||||
// 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)
|
||||
|
||||
@@ -9,15 +9,18 @@
|
||||
|
||||
//----------------------------------------------------------------------------//
|
||||
|
||||
// test without deprecated features
|
||||
#define BOOST_SYSTEM_NO_DEPRECATED
|
||||
// VC++ 8.0 warns on usage of certain Standard Library and API functions that
|
||||
// can cause buffer overruns or other possible security issues if misused.
|
||||
// See http://msdn.microsoft.com/msdnmag/issues/05/05/SafeCandC/default.aspx
|
||||
// But the wording of the warning is misleading and unsettling, there are no
|
||||
// portable alternative functions, and VC++ 8.0's own libraries use the
|
||||
// functions in question. So turn off the warnings.
|
||||
#define _CRT_SECURE_NO_DEPRECATE
|
||||
#define _SCL_SECURE_NO_DEPRECATE
|
||||
|
||||
#include <boost/config/warning_disable.hpp>
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <boost/system/system_error.hpp>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#ifdef BOOST_WINDOWS_API
|
||||
#include <windows.h>
|
||||
@@ -26,7 +29,6 @@
|
||||
using boost::system::system_error;
|
||||
using boost::system::error_code;
|
||||
using boost::system::system_category;
|
||||
using std::string;
|
||||
|
||||
#define TEST(x,v,w) test(#x,x,v,w)
|
||||
|
||||
@@ -36,11 +38,11 @@ namespace
|
||||
int v, const char * str )
|
||||
{
|
||||
std::cout << "test " << desc << "\n what() returns \"" << ex.what() << "\"\n";
|
||||
BOOST_TEST( ex.code().value() == v );
|
||||
BOOST_TEST( ex.code().category() == system_category() );
|
||||
BOOST_CHECK( ex.code().value() == v );
|
||||
BOOST_CHECK( ex.code().category() == system_category );
|
||||
# ifdef BOOST_WINDOWS_API
|
||||
LANGID language_id;
|
||||
# if !defined(__MINGW32__) && !defined(__CYGWIN__) && !BOOST_PLAT_WINDOWS_RUNTIME
|
||||
# if !defined(__MINGW32__) && !defined(__CYGWIN__)
|
||||
language_id = ::GetUserDefaultUILanguage();
|
||||
# else
|
||||
language_id = 0x0409; // Assume US English
|
||||
@@ -48,7 +50,7 @@ namespace
|
||||
// std::cout << "GetUserDefaultUILanguage() returns " << language_id << '\n';
|
||||
if ( language_id == 0x0409 ) // English (United States)
|
||||
{
|
||||
BOOST_TEST( std::string( ex.what() ) == str );
|
||||
BOOST_CHECK( std::string( ex.what() ) == str );
|
||||
if ( std::string( ex.what() ) != str )
|
||||
std::cout << "expected \"" << str << "\", but what() returned \""
|
||||
<< ex.what() << "\"\n";
|
||||
@@ -56,54 +58,31 @@ namespace
|
||||
# endif
|
||||
}
|
||||
|
||||
const boost::uint_least32_t uvalue = 2u;
|
||||
const boost::uint_least32_t uvalue = 1u;
|
||||
}
|
||||
|
||||
int main( int, char *[] )
|
||||
int test_main( int, char *[] )
|
||||
{
|
||||
// all constructors, in the same order as they appear in the header:
|
||||
// all combinations of constructors:
|
||||
|
||||
system_error c1_0( error_code(0, system_category()) );
|
||||
system_error c1_1( error_code(1, system_category()) );
|
||||
system_error c1_2u( error_code(uvalue, system_category()) );
|
||||
system_error se_0_m( error_code(0, system_category), "se_0_m" );
|
||||
system_error se_1_m( 1, system_category, "se_1_m" );
|
||||
system_error se_0_nm( error_code(0, system_category), "" );
|
||||
system_error se_1_nm( 1, system_category, "" );
|
||||
system_error se_0_nmx( error_code(0, system_category), "" );
|
||||
system_error se_1_nmx( 1, system_category, "" );
|
||||
system_error se_1u_m( uvalue, system_category, "se_1u_m" );
|
||||
|
||||
system_error c2_0( error_code(0, system_category()), string("c2_0") );
|
||||
system_error c2_1( error_code(1, system_category()), string("c2_1") );
|
||||
TEST( se_0_m, 0, "se_0_m" );
|
||||
TEST( se_1_m, 1, "se_1_m: Incorrect function" );
|
||||
TEST( se_0_nm, 0, "" );
|
||||
TEST( se_1_nm, 1, "Incorrect function" );
|
||||
TEST( se_0_nmx, 0, "" );
|
||||
TEST( se_1_nmx, 1, "Incorrect function" );
|
||||
TEST( se_1u_m, 1, "se_1u_m: Incorrect function" );
|
||||
|
||||
system_error c3_0( error_code(0, system_category()), "c3_0" );
|
||||
system_error c3_1( error_code(1, system_category()), "c3_1" );
|
||||
|
||||
system_error c4_0( 0, system_category() );
|
||||
system_error c4_1( 1, system_category() );
|
||||
system_error c4_2u( uvalue, system_category() );
|
||||
|
||||
system_error c5_0( 0, system_category(), string("c5_0") );
|
||||
system_error c5_1( 1, system_category(), string("c5_1") );
|
||||
|
||||
system_error c6_0( 0, system_category(), "c6_0" );
|
||||
system_error c6_1( 1, system_category(), "c6_1" );
|
||||
|
||||
TEST( c1_0, 0, "The operation completed successfully" );
|
||||
TEST( c1_1, 1, "Incorrect function" );
|
||||
TEST( c1_2u, 2, "The system cannot find the file specified" );
|
||||
|
||||
TEST( c2_0, 0, "c2_0: The operation completed successfully" );
|
||||
TEST( c2_1, 1, "c2_1: Incorrect function" );
|
||||
|
||||
TEST( c3_0, 0, "c3_0: The operation completed successfully" );
|
||||
TEST( c3_1, 1, "c3_1: Incorrect function" );
|
||||
|
||||
TEST( c4_0, 0, "The operation completed successfully" );
|
||||
TEST( c4_1, 1, "Incorrect function" );
|
||||
TEST( c4_2u, 2, "The system cannot find the file specified" );
|
||||
|
||||
TEST( c5_0, 0, "c5_0: The operation completed successfully" );
|
||||
TEST( c5_1, 1, "c5_1: Incorrect function" );
|
||||
|
||||
TEST( c6_0, 0, "c6_0: The operation completed successfully" );
|
||||
TEST( c6_1, 1, "c6_1: Incorrect function" );
|
||||
|
||||
return ::boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -1,31 +0,0 @@
|
||||
// throw_test.cpp --------------------------------------------------------===========-//
|
||||
|
||||
// Copyright Beman Dawes 2010
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
// Library home page is www.boost.org/libs/system
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
// See dynamic_link_test.cpp comments for use case.
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
// define BOOST_SYSTEM_SOURCE so that <boost/system/config.hpp> knows
|
||||
// the library is being built (possibly exporting rather than importing code)
|
||||
#define BOOST_SYSTEM_SOURCE
|
||||
|
||||
#include <boost/system/system_error.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace system
|
||||
{
|
||||
BOOST_SYSTEM_DECL void throw_test()
|
||||
{
|
||||
throw system_error(9999, system_category(), "boo boo");
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user