mirror of
https://github.com/boostorg/logic.git
synced 2025-12-22 23:02:42 +01:00
Compare commits
2 Commits
boost-1.71
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
|
593f56713e | ||
|
e953e068e0 |
235
.travis.yml
235
.travis.yml
@@ -1,235 +0,0 @@
|
||||
# Copyright 2016 Peter Dimov
|
||||
# Copyright 2017 - 2019 James E. King III
|
||||
# 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)
|
||||
|
||||
#
|
||||
# Generic Travis CI build script for boostorg repositories
|
||||
# See: https://github.com/boostorg/boost-ci
|
||||
#
|
||||
# Instructions for customizing this script for your library:
|
||||
#
|
||||
# 1. Customize the compilers and language levels you want in the 'jobs'.
|
||||
# 2. If you have more than include/, src/, test/, example/, examples/, or
|
||||
# tools/ directories, modify your Travis CI project and add the environment
|
||||
# variable DEPINST. For example if your build uses code in "bench/" and
|
||||
# "fog/" directories, then set DEPINST to the following:
|
||||
# --include bench --include fog
|
||||
# 3. If you want to enable Coverity Scan, you need to provide the environment
|
||||
# variables COVERITY_SCAN_TOKEN and COVERITY_SCAN_NOTIFICATION_EMAIL in
|
||||
# your github settings.
|
||||
# 4. If you want to enable a big-endian build, you need to uncomment the
|
||||
# big-endian build job.
|
||||
# 5. Enable pull request builds in your boostorg/<library> account.
|
||||
#
|
||||
# That's it - the scripts will do everything else for you.
|
||||
|
||||
dist: xenial
|
||||
language: cpp
|
||||
|
||||
env:
|
||||
global:
|
||||
# see: http://www.boost.org/build/doc/html/bbv2/overview/invocation.html#bbv2.overview.invocation.properties
|
||||
# - B2_ADDRESS_MODEL=address-model=64,32
|
||||
# - B2_LINK=link=shared,static
|
||||
# - B2_THREADING=threading=multi,single
|
||||
- B2_VARIANT=variant=release
|
||||
|
||||
install:
|
||||
- git clone https://github.com/boostorg/boost-ci.git boost-ci
|
||||
- cp -pr boost-ci/ci boost-ci/.codecov.yml .
|
||||
- source ci/travis/install.sh
|
||||
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- binutils-gold
|
||||
- gdb
|
||||
- libc6-dbg
|
||||
- qemu-user-static
|
||||
|
||||
services:
|
||||
- docker
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- develop
|
||||
- /bugfix\/.*/
|
||||
- /feature\/.*/
|
||||
- /fix\/.*/
|
||||
- /pr\/.*/
|
||||
|
||||
script:
|
||||
- cd $BOOST_ROOT/libs/$SELF
|
||||
- ci/travis/build.sh
|
||||
|
||||
#
|
||||
# Default toolsets in Ubuntu
|
||||
#
|
||||
# trusty xenial bionic
|
||||
# 14.04 16.04 18.04
|
||||
# ------ ------ ------
|
||||
# clang 3.4 3.8 6.0
|
||||
# gcc 4.8.2 5.3.1 7.3.0
|
||||
#
|
||||
|
||||
anchors:
|
||||
clang-38: &clang-38 { apt: { packages: [ "clang-3.8",
|
||||
"libstdc++-6-dev" ], sources: [ "llvm-toolchain-xenial-3.8",
|
||||
"ubuntu-toolchain-r-test" ] } }
|
||||
clang-4: &clang-4 { apt: { packages: [ "clang-4.0",
|
||||
"libstdc++-6-dev" ], sources: [ "llvm-toolchain-xenial-4.0",
|
||||
"ubuntu-toolchain-r-test" ] } }
|
||||
clang-5: &clang-5 { apt: { packages: [ "clang-5.0",
|
||||
"libstdc++-7-dev" ], sources: [ "llvm-toolchain-xenial-5.0",
|
||||
"ubuntu-toolchain-r-test" ] } }
|
||||
clang-6: &clang-6 { apt: { packages: [ "clang-6.0",
|
||||
"libc6-dbg",
|
||||
"libc++-dev",
|
||||
"libstdc++-8-dev" ], sources: [ "llvm-toolchain-xenial-6.0",
|
||||
"ubuntu-toolchain-r-test" ] } }
|
||||
clang-7: &clang-7 { apt: { packages: [ "clang-7",
|
||||
"libc6-dbg",
|
||||
"libc++-dev",
|
||||
"libstdc++-8-dev" ], sources: [ "llvm-toolchain-xenial-7",
|
||||
"ubuntu-toolchain-r-test" ] } }
|
||||
clang-8: &clang-8 { apt: { packages: [ "clang-8",
|
||||
"libc6-dbg",
|
||||
"libc++-dev",
|
||||
"libstdc++-8-dev" ], sources: [ "llvm-toolchain-xenial-8",
|
||||
"ubuntu-toolchain-r-test" ] } }
|
||||
gcc-48: &gcc-48 { apt: { packages: [ "g++-4.8" ] } }
|
||||
gcc-49: &gcc-49 { apt: { packages: [ "g++-4.9" ], sources: [ "ubuntu-toolchain-r-test" ] } }
|
||||
gcc-5: &gcc-5 { apt: { packages: [ "g++-5" ] } }
|
||||
gcc-6: &gcc-6 { apt: { packages: [ "g++-6" ], sources: [ "ubuntu-toolchain-r-test" ] } }
|
||||
gcc-7: &gcc-7 { apt: { packages: [ "g++-7" ], sources: [ "ubuntu-toolchain-r-test" ] } }
|
||||
gcc-8: &gcc-8 { apt: { packages: [ "g++-8" ], sources: [ "ubuntu-toolchain-r-test" ] } }
|
||||
gcc-9: &gcc-9 { apt: { packages: [ "g++-9" ], sources: [ "ubuntu-toolchain-r-test" ] } }
|
||||
|
||||
jobs:
|
||||
allow_failures:
|
||||
- env:
|
||||
- COPY="all the environment settings from your job"
|
||||
|
||||
include:
|
||||
# libstdc++
|
||||
- { os: "linux", dist: "trusty", # xenial has libstdc++ from gcc 5.4.0 with newer ABI
|
||||
env: [ "B2_TOOLSET=gcc-4.8", "B2_CXXSTD=03,11" ], addons: *gcc-48 }
|
||||
- { os: "linux", dist: "trusty", # xenial has libstdc++ from gcc 5.4.0 with newer ABI
|
||||
env: [ "B2_TOOLSET=gcc-4.9", "B2_CXXSTD=03,11" ], addons: *gcc-49 }
|
||||
- { os: "linux", env: [ "B2_TOOLSET=gcc-5", "B2_CXXSTD=03,11" ], addons: *gcc-5 }
|
||||
- { os: "linux", env: [ "B2_TOOLSET=gcc-6", "B2_CXXSTD=11,14" ], addons: *gcc-6 }
|
||||
- { os: "linux", env: [ "B2_TOOLSET=gcc-7", "B2_CXXSTD=14,17" ], addons: *gcc-7 }
|
||||
- { os: "linux", env: [ "B2_TOOLSET=gcc-8", "B2_CXXSTD=17,2a" ], addons: *gcc-8 }
|
||||
- { os: "linux", env: [ "B2_TOOLSET=gcc-9", "B2_CXXSTD=17,2a" ], addons: *gcc-9 }
|
||||
- { os: "linux", dist: "trusty", # xenial has libstdc++ from gcc 5.4.0 with newer ABI
|
||||
env: [ "B2_TOOLSET=clang-3.8", "B2_CXXSTD=03,11" ], addons: *clang-38 }
|
||||
- { os: "linux", env: [ "B2_TOOLSET=clang-4.0", "B2_CXXSTD=11,14" ], addons: *clang-4 }
|
||||
- { os: "linux", env: [ "B2_TOOLSET=clang-5.0", "B2_CXXSTD=11,14" ], addons: *clang-5 }
|
||||
- { os: "linux", env: [ "B2_TOOLSET=clang-6.0", "B2_CXXSTD=14,17" ], addons: *clang-6 }
|
||||
- { os: "linux", env: [ "B2_TOOLSET=clang-7", "B2_CXXSTD=17,2a" ], addons: *clang-7 }
|
||||
- { os: "linux", env: [ "B2_TOOLSET=clang-8", "B2_CXXSTD=17,2a" ], addons: *clang-8 }
|
||||
|
||||
# libc++
|
||||
- { os: "linux", env: [ "B2_TOOLSET=clang-6.0", "B2_CXXSTD=03,11,14",
|
||||
"B2_CXXFLAGS=-stdlib=libc++" ], addons: *clang-6 }
|
||||
- { os: "osx" , env: [ "B2_TOOLSET=clang", "B2_CXXSTD=03,11,17" ] }
|
||||
|
||||
# to enable Intel ICC define INTEL_ICC_SERIAL_NUMBER and the following (under development):
|
||||
# - { os: "linux", env: [ "B2_TOOLSET=intel-linux", "B2_CXXSTD=11,14,17" ], addons: *gcc-7,
|
||||
# script: cd $BOOST_ROOT/libs/$SELF && ci/travis/intelicc.sh }
|
||||
|
||||
# uncomment to enable a big-endian build job, just note that it is 5-10 times slower
|
||||
# than a regular build and travis has a 50 minute time limit per job
|
||||
# - os: linux
|
||||
# env:
|
||||
# - COMMENT=big-endian
|
||||
# - B2_CXXSTD=03
|
||||
# - B2_TOOLSET=gcc
|
||||
# - B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
|
||||
# - BDDE_OS=red
|
||||
# - BDDE_ARCH=ppc64
|
||||
# script:
|
||||
# - cd $BOOST_ROOT/libs/$SELF
|
||||
# - ci/travis/bdde.sh
|
||||
|
||||
- os: linux
|
||||
env:
|
||||
- COMMENT=codecov.io
|
||||
- B2_CXXSTD=03,11
|
||||
- B2_TOOLSET=gcc-8
|
||||
- B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
|
||||
addons: *gcc-8
|
||||
script:
|
||||
- cd $BOOST_ROOT/libs/$SELF
|
||||
- ci/travis/codecov.sh
|
||||
|
||||
- os: linux
|
||||
env:
|
||||
- COMMENT=asan
|
||||
- B2_VARIANT=variant=debug
|
||||
- B2_TOOLSET=gcc-8
|
||||
- B2_CXXSTD=03,11,14
|
||||
- B2_CXXFLAGS="address-sanitizer=norecover"
|
||||
- B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
|
||||
addons: *gcc-8
|
||||
|
||||
- os: linux
|
||||
env:
|
||||
- COMMENT=tsan
|
||||
- B2_VARIANT=variant=debug
|
||||
- B2_TOOLSET=gcc-8
|
||||
- B2_CXXSTD=03,11,14
|
||||
- B2_CXXFLAGS="thread-sanitizer=norecover"
|
||||
- B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
|
||||
addons: *gcc-8
|
||||
|
||||
- os: linux
|
||||
env:
|
||||
- COMMENT=ubsan
|
||||
- B2_VARIANT=variant=debug
|
||||
- B2_TOOLSET=gcc-8
|
||||
- B2_CXXSTD=03,11,14
|
||||
- B2_CXXFLAGS="undefined-sanitizer=norecover"
|
||||
- B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
|
||||
- B2_LINKFLAGS="linkflags=-fuse-ld=gold"
|
||||
- UBSAN_OPTIONS=print_stacktrace=1
|
||||
addons: *gcc-8
|
||||
|
||||
- os: linux
|
||||
env:
|
||||
- COMMENT=valgrind
|
||||
- B2_TOOLSET=clang-6.0
|
||||
- B2_CXXSTD=03,11,14
|
||||
- B2_DEFINES="define=BOOST_NO_STRESS_TEST=1"
|
||||
- B2_VARIANT=variant=debug
|
||||
- B2_TESTFLAGS=testing.launcher=valgrind
|
||||
- VALGRIND_OPTS=--error-exitcode=1
|
||||
addons: *clang-6
|
||||
script:
|
||||
- cd $BOOST_ROOT/libs/$SELF
|
||||
- ci/travis/valgrind.sh
|
||||
|
||||
# - os: linux
|
||||
# env:
|
||||
# - COMMENT=cppcheck
|
||||
# script:
|
||||
# - cd $BOOST_ROOT/libs/$SELF
|
||||
# - ci/travis/cppcheck.sh
|
||||
|
||||
#################### Jobs to run on pushes to master, develop ###################
|
||||
|
||||
# Coverity Scan
|
||||
- os: linux
|
||||
if: (env(COVERITY_SCAN_NOTIFICATION_EMAIL) IS present) AND (branch IN (develop, master)) AND (type IN (cron, push))
|
||||
env:
|
||||
- COMMENT="Coverity Scan"
|
||||
- B2_TOOLSET=clang
|
||||
script:
|
||||
- cd $BOOST_ROOT/libs/$SELF
|
||||
- ci/travis/coverity.sh
|
||||
|
||||
notifications:
|
||||
email:
|
||||
false
|
||||
@@ -1,20 +0,0 @@
|
||||
# Copyright 2018 Mike Dev
|
||||
# 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
|
||||
#
|
||||
# NOTE: CMake support for Boost.Logic is currently experimental at best
|
||||
# and the interface is likely to change in the future
|
||||
|
||||
cmake_minimum_required( VERSION 3.5 )
|
||||
project( BoostLogic LANGUAGES CXX )
|
||||
|
||||
add_library( boost_logic INTERFACE )
|
||||
add_library( Boost::logic ALIAS boost_logic )
|
||||
|
||||
target_include_directories( boost_logic INTERFACE include )
|
||||
|
||||
target_link_libraries( boost_logic
|
||||
INTERFACE
|
||||
Boost::config
|
||||
Boost::core
|
||||
)
|
||||
10
Jamfile
10
Jamfile
@@ -1,10 +0,0 @@
|
||||
# Boost.Logic Library Jamfile
|
||||
#
|
||||
# Copyright (c) 2018 James E. King III
|
||||
#
|
||||
# Use, modification, and distribution are subject to 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)
|
||||
|
||||
# please order by name to ease maintenance
|
||||
build-project test ;
|
||||
23
LICENSE
23
LICENSE
@@ -1,23 +0,0 @@
|
||||
Boost Software License - Version 1.0 - August 17th, 2003
|
||||
|
||||
Permission is hereby granted, free of charge, to any person or organization
|
||||
obtaining a copy of the software and accompanying documentation covered by
|
||||
this license (the "Software") to use, reproduce, display, distribute,
|
||||
execute, and transmit the Software, and to prepare derivative works of the
|
||||
Software, and to permit third-parties to whom the Software is furnished to
|
||||
do so, all subject to the following:
|
||||
|
||||
The copyright notices in the Software and this entire statement, including
|
||||
the above license grant, this restriction and the following disclaimer,
|
||||
must be included in all copies of the Software, in whole or in part, and
|
||||
all derivative works of the Software, unless such copies or derivative
|
||||
works are solely in the form of machine-executable object code generated by
|
||||
a source language processor.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
|
||||
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
|
||||
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
|
||||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
DEALINGS IN THE SOFTWARE.
|
||||
34
README.md
34
README.md
@@ -1,34 +0,0 @@
|
||||
Logic, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), provides `boost::logic::tribool` for 3-state boolean logic.
|
||||
|
||||
### License
|
||||
|
||||
Distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
|
||||
|
||||
### Properties
|
||||
|
||||
* C++03
|
||||
* Header Only
|
||||
|
||||
### Build Status
|
||||
|
||||
Branch | Travis | Appveyor | Coverity Scan | codecov.io | Deps | Docs | Tests |
|
||||
:-------------: | ------ | -------- | ------------- | ---------- | ---- | ---- | ----- |
|
||||
[`master`](https://github.com/boostorg/logic/tree/master) | [](https://travis-ci.org/boostorg/logic) | [](https://ci.appveyor.com/project/jeking3/logic-vv3ct/branch/master) | [](https://scan.coverity.com/projects/boostorg-logic) | [](https://codecov.io/gh/boostorg/logic/branch/master)| [](https://pdimov.github.io/boostdep-report/master/logic.html) | [](http://www.boost.org/doc/libs/master/doc/html/logic.html) | [](http://www.boost.org/development/tests/master/developer/logic.html)
|
||||
[`develop`](https://github.com/boostorg/logic/tree/develop) | [](https://travis-ci.org/boostorg/logic) | [](https://ci.appveyor.com/project/jeking3/logic-vv3ct/branch/develop) | [](https://scan.coverity.com/projects/boostorg-logic) | [](https://codecov.io/gh/boostorg/logic/branch/develop) | [](https://pdimov.github.io/boostdep-report/develop/logic.html) | [](http://www.boost.org/doc/libs/develop/doc/html/logic.html) | [](http://www.boost.org/development/tests/develop/developer/logic.html)
|
||||
|
||||
### Directories
|
||||
|
||||
| Name | Purpose |
|
||||
| ----------- | ------------------------------ |
|
||||
| `doc` | documentation |
|
||||
| `example` | examples |
|
||||
| `include` | headers |
|
||||
| `test` | unit tests |
|
||||
|
||||
### More information
|
||||
|
||||
* [Ask questions](http://stackoverflow.com/questions/ask?tags=c%2B%2B,boost,boost-logic)
|
||||
* [Report bugs](https://github.com/boostorg/logic/issues): Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
|
||||
* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
|
||||
* Discussions about the library are held on the [Boost developers mailing list](http://www.boost.org/community/groups.html#main). Be sure to read the [discussion policy](http://www.boost.org/community/policy.html) before posting and add the `[logic]` tag at the beginning of the subject line.
|
||||
|
||||
149
appveyor.yml
149
appveyor.yml
@@ -1,149 +0,0 @@
|
||||
# Copyright 2016, 2017 Peter Dimov
|
||||
# Copyright (C) 2017 - 2019 James E. King III
|
||||
# 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)
|
||||
|
||||
#
|
||||
# Generic Appveyor build script for boostorg repositories
|
||||
# See: https://github.com/boostorg/boost-ci/
|
||||
#
|
||||
# Instructions for customizing this script for your library:
|
||||
#
|
||||
# 1. Customize the compilers and language levels you want.
|
||||
# 2. If you have more than include/, src/, test/, example/, examples/,
|
||||
# benchmark/ or tools/ directories, set the environment variable DEPINST.
|
||||
# For example if your build uses code in "bench/" and "fog/" directories:
|
||||
# - DEPINST: --include bench --include fog
|
||||
# 3. Enable pull request builds in your boostorg/<library> account.
|
||||
#
|
||||
# That's it - the script will do everything else for you.
|
||||
#
|
||||
|
||||
version: 1.0.{build}-{branch}
|
||||
|
||||
shallow_clone: true
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- develop
|
||||
- /bugfix\/.*/
|
||||
- /feature\/.*/
|
||||
- /fix\/.*/
|
||||
- /pr\/.*/
|
||||
|
||||
matrix:
|
||||
# Adding MAYFAIL to any matrix job allows it to fail but the build stays green:
|
||||
allow_failures:
|
||||
- MAYFAIL: true
|
||||
|
||||
environment:
|
||||
global:
|
||||
# see: http://www.boost.org/build/doc/html/bbv2/overview/invocation.html#bbv2.overview.invocation.properties
|
||||
# to use the default for a given environment, comment it out; recommend you build debug and release however:
|
||||
# on Windows it is important to exercise all the possibilities, especially shared vs static, however most
|
||||
# libraries that care about this exercise it in their Jamfiles...
|
||||
# B2_ADDRESS_MODEL: address-model=64,32
|
||||
# B2_LINK: link=shared,static
|
||||
# B2_THREADING: threading=multi,single
|
||||
B2_VARIANT: variant=release
|
||||
|
||||
matrix:
|
||||
- FLAVOR: Visual Studio 2019
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
B2_CXXFLAGS: cxxflags=-permissive-
|
||||
B2_CXXSTD: latest # 2a
|
||||
B2_TOOLSET: msvc-14.2
|
||||
|
||||
- FLAVOR: Visual Studio 2017 C++2a Strict
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
B2_CXXFLAGS: cxxflags=-permissive-
|
||||
B2_CXXSTD: latest # 2a
|
||||
B2_TOOLSET: msvc-14.1
|
||||
|
||||
- FLAVOR: Visual Studio 2017 C++17
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
B2_CXXSTD: 17
|
||||
B2_TOOLSET: msvc-14.1
|
||||
B2_VARIANT: variant=debug
|
||||
|
||||
- FLAVOR: Visual Studio 2017 C++14 (Default)
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
B2_ADDRESS_MODEL: address-model=64,32
|
||||
B2_TOOLSET: msvc-14.1
|
||||
|
||||
- FLAVOR: clang-cl
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
B2_CXXSTD: 11
|
||||
B2_TOOLSET: clang-win
|
||||
|
||||
- FLAVOR: Visual Studio 2015 C++14 (Default)
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
B2_ADDRESS_MODEL: address-model=64,32
|
||||
B2_TOOLSET: msvc-14.0
|
||||
B2_VARIANT: variant=debug
|
||||
|
||||
- FLAVOR: Visual Studio 2010, 2012, 2013
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
B2_TOOLSET: msvc-10.0,msvc-11.0,msvc-12.0
|
||||
MAYFAIL: true
|
||||
REASON: https://github.com/boostorg/logic/issues/8
|
||||
|
||||
- FLAVOR: cygwin (32-bit)
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
ADDPATH: C:\cygwin\bin;
|
||||
B2_ADDRESS_MODEL: address-model=32
|
||||
B2_CXXSTD: 03,11
|
||||
# https://github.com/boostorg/test/issues/144
|
||||
B2_DEFINES: define=_POSIX_C_SOURCE=200112L
|
||||
B2_THREADING: threadapi=pthread
|
||||
B2_TOOLSET: gcc
|
||||
B2_VARIANT: variant=debug
|
||||
|
||||
- FLAVOR: cygwin (64-bit)
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
ADDPATH: C:\cygwin64\bin;
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
B2_CXXSTD: 11,17
|
||||
# https://github.com/boostorg/test/issues/144
|
||||
B2_DEFINES: define=_POSIX_C_SOURCE=200112L define=__USE_ISOC99
|
||||
B2_THREADING: threadapi=pthread
|
||||
B2_TOOLSET: gcc
|
||||
|
||||
- FLAVOR: mingw32
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
ARCH: i686
|
||||
B2_ADDRESS_MODEL: address-model=32
|
||||
B2_CXXSTD: 03,11
|
||||
SCRIPT: ci\appveyor\mingw.bat
|
||||
B2_VARIANT: variant=debug
|
||||
|
||||
- FLAVOR: mingw64
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
ARCH: x86_64
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
B2_CXXSTD: 11,17
|
||||
B2_DEFINES: define=__USE_ISOC99
|
||||
SCRIPT: ci\appveyor\mingw.bat
|
||||
|
||||
install:
|
||||
- set SELF=%APPVEYOR_PROJECT_NAME:-=_%
|
||||
- git clone https://github.com/boostorg/boost-ci.git C:\boost-ci
|
||||
- xcopy /s /e /q /i C:\boost-ci\ci .\ci
|
||||
- ci\appveyor\install.bat
|
||||
|
||||
build: off
|
||||
|
||||
test_script:
|
||||
- set SELF=%APPVEYOR_PROJECT_NAME:-=_%
|
||||
- PATH=%ADDPATH%%PATH%
|
||||
# The definition of B2_TOOLCXX omits B2_CXXSTD= if it was not defined above
|
||||
- IF NOT DEFINED B2_CXXSTD (SET B2_TOOLCXX=toolset=%B2_TOOLSET%) ELSE (SET B2_TOOLCXX=toolset=%B2_TOOLSET% cxxstd=%B2_CXXSTD%)
|
||||
# Echo the complete build command to the build log
|
||||
- IF NOT DEFINED SCRIPT (ECHO b2 libs/%SELF:\=/% %B2_TOOLCXX% %B2_CXXFLAGS% %B2_DEFINES% %B2_THREADING% %B2_ADDRESS_MODEL% %B2_LINK% %B2_THREADING% %B2_VARIANT% -j3)
|
||||
# Now go build...
|
||||
- IF DEFINED SCRIPT (call libs\%SELF%\%SCRIPT%) ELSE (b2 libs/%SELF:\=/% %B2_TOOLCXX% %B2_CXXFLAGS% %B2_DEFINES% %B2_THREADING% %B2_ADDRESS_MODEL% %B2_LINK% %B2_THREADING% %B2_VARIANT% -j3)
|
||||
@@ -1,13 +1,3 @@
|
||||
# Tribool library
|
||||
|
||||
# Copyright (C) 2002-2003 Douglas Gregor
|
||||
|
||||
# Use, modification and distribution is subject to 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)
|
||||
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
project boost-sandbox/utility/doc ;
|
||||
import boostbook ;
|
||||
import doxygen ;
|
||||
@@ -16,21 +6,4 @@ doxygen reference : [ glob ../../../boost/logic/tribool.hpp ]
|
||||
[ glob ../../../boost/logic/tribool_fwd.hpp ]
|
||||
[ glob ../../../boost/logic/tribool_io.hpp ]
|
||||
;
|
||||
boostbook tribool
|
||||
:
|
||||
tribool.boostbook
|
||||
:
|
||||
<xsl:param>boost.root=../../../..
|
||||
<format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
|
||||
<dependency>reference
|
||||
;
|
||||
|
||||
###############################################################################
|
||||
alias boostdoc
|
||||
: tribool/<format>docbook
|
||||
:
|
||||
:
|
||||
: ;
|
||||
explicit boostdoc ;
|
||||
alias boostrelease ;
|
||||
explicit boostrelease ;
|
||||
boostbook tribool : tribool.boostbook ;
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<library name="Tribool" dirname="logic" id="tribool"
|
||||
last-revision="$Date: 2007/05/03 03:28:53 $" xmlns:xi="http://www.w3.org/2001/XInclude">
|
||||
last-revision="$Date: 2004/07/25 03:01:38 $" xmlns:xi="http://www.w3.org/2001/XInclude">
|
||||
<libraryinfo>
|
||||
<author>
|
||||
<firstname>Douglas</firstname>
|
||||
@@ -138,18 +138,6 @@ if (<functionname>indeterminate</functionname>(x)) {
|
||||
else {
|
||||
// report success or failure of x
|
||||
}</programlisting>
|
||||
|
||||
<para> All the logical operators and methods of <code><classname>tribool</classname></code> are marked
|
||||
as <code>constexpr</code> in C++11. It means that <code><classname>tribool</classname></code> can
|
||||
be used in compile time expressions:</para>
|
||||
|
||||
<programlisting>constexpr <classname>tribool</classname> x = (tribool(true) || tribool(indeterminate));
|
||||
<functionname>static_assert</functionname>(x, "Must be true!");
|
||||
</programlisting>
|
||||
|
||||
<note>Some compilers may have troubles with evaluating <code>tribool::operator safe_bool()</code> at compile time.</note>
|
||||
|
||||
|
||||
</section>
|
||||
|
||||
<section>
|
||||
@@ -209,7 +197,7 @@ cout << boolalpha << x << endl; // Prints "maybe"</programlist
|
||||
|
||||
</section>
|
||||
|
||||
<xi:include href="reference.xml"/>
|
||||
<xi:include href="reference.boostbook"/>
|
||||
|
||||
<testsuite id="tribool.tests">
|
||||
<run-test filename="tribool_test.cpp">
|
||||
|
||||
@@ -1,469 +0,0 @@
|
||||
// Three-state boolean logic library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2004. Use, modification and
|
||||
// distribution is subject to 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)
|
||||
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
#ifndef BOOST_LOGIC_TRIBOOL_HPP
|
||||
#define BOOST_LOGIC_TRIBOOL_HPP
|
||||
|
||||
#include <boost/logic/tribool_fwd.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
namespace boost { namespace logic {
|
||||
|
||||
/// INTERNAL ONLY
|
||||
namespace detail {
|
||||
/**
|
||||
* INTERNAL ONLY
|
||||
*
|
||||
* \brief A type used only to uniquely identify the 'indeterminate'
|
||||
* function/keyword.
|
||||
*/
|
||||
struct indeterminate_t
|
||||
{
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, < 0x0600)
|
||||
char dummy_; // BCB would use 8 bytes by default
|
||||
#endif
|
||||
};
|
||||
|
||||
} // end namespace detail
|
||||
|
||||
/**
|
||||
* INTERNAL ONLY
|
||||
* The type of the 'indeterminate' keyword. This has the same type as the
|
||||
* function 'indeterminate' so that we can recognize when the keyword is
|
||||
* used.
|
||||
*/
|
||||
typedef bool (*indeterminate_keyword_t)(tribool, detail::indeterminate_t);
|
||||
|
||||
/**
|
||||
* \brief Keyword and test function for the indeterminate tribool value
|
||||
*
|
||||
* The \c indeterminate function has a dual role. It's first role is
|
||||
* as a unary function that tells whether the tribool value is in the
|
||||
* "indeterminate" state. It's second role is as a keyword
|
||||
* representing the indeterminate (just like "true" and "false"
|
||||
* represent the true and false states). If you do not like the name
|
||||
* "indeterminate", and would prefer to use a different name, see the
|
||||
* macro \c BOOST_TRIBOOL_THIRD_STATE.
|
||||
*
|
||||
* \returns <tt>x.value == tribool::indeterminate_value</tt>
|
||||
* \throws nothrow
|
||||
*/
|
||||
BOOST_CONSTEXPR inline bool
|
||||
indeterminate(tribool x,
|
||||
detail::indeterminate_t dummy = detail::indeterminate_t()) BOOST_NOEXCEPT;
|
||||
|
||||
/**
|
||||
* \brief A 3-state boolean type.
|
||||
*
|
||||
* 3-state boolean values are either true, false, or
|
||||
* indeterminate.
|
||||
*/
|
||||
class tribool
|
||||
{
|
||||
#if defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS )
|
||||
private:
|
||||
/// INTERNAL ONLY
|
||||
struct dummy {
|
||||
void nonnull() {};
|
||||
};
|
||||
|
||||
typedef void (dummy::*safe_bool)();
|
||||
#endif
|
||||
|
||||
public:
|
||||
/**
|
||||
* Construct a new 3-state boolean value with the value 'false'.
|
||||
*
|
||||
* \throws nothrow
|
||||
*/
|
||||
BOOST_CONSTEXPR tribool() BOOST_NOEXCEPT : value(false_value) {}
|
||||
|
||||
/**
|
||||
* Construct a new 3-state boolean value with the given boolean
|
||||
* value, which may be \c true or \c false.
|
||||
*
|
||||
* \throws nothrow
|
||||
*/
|
||||
BOOST_CONSTEXPR tribool(bool initial_value) BOOST_NOEXCEPT : value(initial_value? true_value : false_value) {}
|
||||
|
||||
/**
|
||||
* Construct a new 3-state boolean value with an indeterminate value.
|
||||
*
|
||||
* \throws nothrow
|
||||
*/
|
||||
BOOST_CONSTEXPR tribool(indeterminate_keyword_t) BOOST_NOEXCEPT : value(indeterminate_value) {}
|
||||
|
||||
/**
|
||||
* Use a 3-state boolean in a boolean context. Will evaluate true in a
|
||||
* boolean context only when the 3-state boolean is definitely true.
|
||||
*
|
||||
* \returns true if the 3-state boolean is true, false otherwise
|
||||
* \throws nothrow
|
||||
*/
|
||||
#if !defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS )
|
||||
|
||||
BOOST_CONSTEXPR explicit operator bool () const BOOST_NOEXCEPT
|
||||
{
|
||||
return value == true_value;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
BOOST_CONSTEXPR operator safe_bool() const BOOST_NOEXCEPT
|
||||
{
|
||||
return value == true_value? &dummy::nonnull : 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/**
|
||||
* The actual stored value in this 3-state boolean, which may be false, true,
|
||||
* or indeterminate.
|
||||
*/
|
||||
enum value_t { false_value, true_value, indeterminate_value } value;
|
||||
};
|
||||
|
||||
// Check if the given tribool has an indeterminate value. Also doubles as a
|
||||
// keyword for the 'indeterminate' value
|
||||
BOOST_CONSTEXPR inline bool indeterminate(tribool x, detail::indeterminate_t) BOOST_NOEXCEPT
|
||||
{
|
||||
return x.value == tribool::indeterminate_value;
|
||||
}
|
||||
|
||||
/** @defgroup logical Logical operations
|
||||
*/
|
||||
//@{
|
||||
/**
|
||||
* \brief Computes the logical negation of a tribool
|
||||
*
|
||||
* \returns the logical negation of the tribool, according to the
|
||||
* table:
|
||||
* <table border=1>
|
||||
* <tr>
|
||||
* <th><center><code>!</code></center></th>
|
||||
* <th/>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>false</center></th>
|
||||
* <td><center>true</center></td>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>true</center></th>
|
||||
* <td><center>false</center></td>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>indeterminate</center></th>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* </tr>
|
||||
* </table>
|
||||
* \throws nothrow
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator!(tribool x) BOOST_NOEXCEPT
|
||||
{
|
||||
return x.value == tribool::false_value? tribool(true)
|
||||
:x.value == tribool::true_value? tribool(false)
|
||||
:tribool(indeterminate);
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Computes the logical conjunction of two tribools
|
||||
*
|
||||
* \returns the result of logically ANDing the two tribool values,
|
||||
* according to the following table:
|
||||
* <table border=1>
|
||||
* <tr>
|
||||
* <th><center><code>&&</code></center></th>
|
||||
* <th><center>false</center></th>
|
||||
* <th><center>true</center></th>
|
||||
* <th><center>indeterminate</center></th>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>false</center></th>
|
||||
* <td><center>false</center></td>
|
||||
* <td><center>false</center></td>
|
||||
* <td><center>false</center></td>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>true</center></th>
|
||||
* <td><center>false</center></td>
|
||||
* <td><center>true</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>indeterminate</center></th>
|
||||
* <td><center>false</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* </tr>
|
||||
* </table>
|
||||
* \throws nothrow
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator&&(tribool x, tribool y) BOOST_NOEXCEPT
|
||||
{
|
||||
return (static_cast<bool>(!x) || static_cast<bool>(!y))
|
||||
? tribool(false)
|
||||
: ((static_cast<bool>(x) && static_cast<bool>(y)) ? tribool(true) : indeterminate)
|
||||
;
|
||||
}
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator&&(tribool x, bool y) BOOST_NOEXCEPT
|
||||
{ return y? x : tribool(false); }
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator&&(bool x, tribool y) BOOST_NOEXCEPT
|
||||
{ return x? y : tribool(false); }
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator&&(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
|
||||
{ return !x? tribool(false) : tribool(indeterminate); }
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator&&(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
|
||||
{ return !x? tribool(false) : tribool(indeterminate); }
|
||||
|
||||
/**
|
||||
* \brief Computes the logical disjunction of two tribools
|
||||
*
|
||||
* \returns the result of logically ORing the two tribool values,
|
||||
* according to the following table:
|
||||
* <table border=1>
|
||||
* <tr>
|
||||
* <th><center><code>||</code></center></th>
|
||||
* <th><center>false</center></th>
|
||||
* <th><center>true</center></th>
|
||||
* <th><center>indeterminate</center></th>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>false</center></th>
|
||||
* <td><center>false</center></td>
|
||||
* <td><center>true</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>true</center></th>
|
||||
* <td><center>true</center></td>
|
||||
* <td><center>true</center></td>
|
||||
* <td><center>true</center></td>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>indeterminate</center></th>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* <td><center>true</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* </tr>
|
||||
* </table>
|
||||
* \throws nothrow
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator||(tribool x, tribool y) BOOST_NOEXCEPT
|
||||
{
|
||||
return (static_cast<bool>(!x) && static_cast<bool>(!y))
|
||||
? tribool(false)
|
||||
: ((static_cast<bool>(x) || static_cast<bool>(y)) ? tribool(true) : tribool(indeterminate))
|
||||
;
|
||||
}
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator||(tribool x, bool y) BOOST_NOEXCEPT
|
||||
{ return y? tribool(true) : x; }
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator||(bool x, tribool y) BOOST_NOEXCEPT
|
||||
{ return x? tribool(true) : y; }
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator||(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
|
||||
{ return x? tribool(true) : tribool(indeterminate); }
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator||(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
|
||||
{ return x? tribool(true) : tribool(indeterminate); }
|
||||
//@}
|
||||
|
||||
/**
|
||||
* \brief Compare tribools for equality
|
||||
*
|
||||
* \returns the result of comparing two tribool values, according to
|
||||
* the following table:
|
||||
* <table border=1>
|
||||
* <tr>
|
||||
* <th><center><code>==</code></center></th>
|
||||
* <th><center>false</center></th>
|
||||
* <th><center>true</center></th>
|
||||
* <th><center>indeterminate</center></th>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>false</center></th>
|
||||
* <td><center>true</center></td>
|
||||
* <td><center>false</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>true</center></th>
|
||||
* <td><center>false</center></td>
|
||||
* <td><center>true</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>indeterminate</center></th>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* </tr>
|
||||
* </table>
|
||||
* \throws nothrow
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator==(tribool x, tribool y) BOOST_NOEXCEPT
|
||||
{
|
||||
return (indeterminate(x) || indeterminate(y))
|
||||
? indeterminate
|
||||
: ((x && y) || (!x && !y))
|
||||
;
|
||||
}
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator==(tribool x, bool y) BOOST_NOEXCEPT { return x == tribool(y); }
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator==(bool x, tribool y) BOOST_NOEXCEPT { return tribool(x) == y; }
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator==(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
|
||||
{ return tribool(indeterminate) == x; }
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator==(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
|
||||
{ return tribool(indeterminate) == x; }
|
||||
|
||||
/**
|
||||
* \brief Compare tribools for inequality
|
||||
*
|
||||
* \returns the result of comparing two tribool values for inequality,
|
||||
* according to the following table:
|
||||
* <table border=1>
|
||||
* <tr>
|
||||
* <th><center><code>!=</code></center></th>
|
||||
* <th><center>false</center></th>
|
||||
* <th><center>true</center></th>
|
||||
* <th><center>indeterminate</center></th>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>false</center></th>
|
||||
* <td><center>false</center></td>
|
||||
* <td><center>true</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>true</center></th>
|
||||
* <td><center>true</center></td>
|
||||
* <td><center>false</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* </tr>
|
||||
* <tr>
|
||||
* <th><center>indeterminate</center></th>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* <td><center>indeterminate</center></td>
|
||||
* </tr>
|
||||
* </table>
|
||||
* \throws nothrow
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator!=(tribool x, tribool y) BOOST_NOEXCEPT
|
||||
{
|
||||
return (indeterminate(x) || indeterminate(y))
|
||||
? indeterminate
|
||||
: !((x && y) || (!x && !y))
|
||||
;
|
||||
}
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator!=(tribool x, bool y) BOOST_NOEXCEPT { return x != tribool(y); }
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator!=(bool x, tribool y) BOOST_NOEXCEPT { return tribool(x) != y; }
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator!=(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
|
||||
{ return tribool(indeterminate) != x; }
|
||||
|
||||
/**
|
||||
* \overload
|
||||
*/
|
||||
BOOST_CONSTEXPR inline tribool operator!=(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
|
||||
{ return x != tribool(indeterminate); }
|
||||
|
||||
} } // end namespace boost::logic
|
||||
|
||||
// Pull tribool and indeterminate into namespace "boost"
|
||||
namespace boost {
|
||||
using logic::tribool;
|
||||
using logic::indeterminate;
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Declare a new name for the third state of a tribool
|
||||
*
|
||||
* Use this macro to declare a new name for the third state of a
|
||||
* tribool. This state can have any number of new names (in addition
|
||||
* to \c indeterminate), all of which will be equivalent. The new name will be
|
||||
* placed in the namespace in which the macro is expanded.
|
||||
*
|
||||
* Example:
|
||||
* BOOST_TRIBOOL_THIRD_STATE(true_or_false)
|
||||
*
|
||||
* tribool x(true_or_false);
|
||||
* // potentially set x
|
||||
* if (true_or_false(x)) {
|
||||
* // don't know what x is
|
||||
* }
|
||||
*/
|
||||
#define BOOST_TRIBOOL_THIRD_STATE(Name) \
|
||||
inline bool \
|
||||
Name(boost::logic::tribool x, \
|
||||
boost::logic::detail::indeterminate_t = \
|
||||
boost::logic::detail::indeterminate_t()) \
|
||||
{ return x.value == boost::logic::tribool::indeterminate_value; }
|
||||
|
||||
#endif // BOOST_LOGIC_TRIBOOL_HPP
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
// Three-state boolean logic library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2004. Use, modification and
|
||||
// distribution is subject to 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)
|
||||
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
#ifndef BOOST_LOGIC_TRIBOOL_FWD_HPP
|
||||
#define BOOST_LOGIC_TRIBOOL_FWD_HPP
|
||||
|
||||
namespace boost { namespace logic { class tribool; } }
|
||||
|
||||
#endif // BOOST_LOGIC_TRIBOOL_FWD_HPP
|
||||
@@ -1,343 +0,0 @@
|
||||
// Three-state boolean logic library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2004. Use, modification and
|
||||
// distribution is subject to 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_LOGIC_TRIBOOL_IO_HPP
|
||||
#define BOOST_LOGIC_TRIBOOL_IO_HPP
|
||||
|
||||
#include <boost/logic/tribool.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
# include <locale>
|
||||
#endif
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
|
||||
namespace boost { namespace logic {
|
||||
|
||||
#ifdef BOOST_NO_STD_LOCALE
|
||||
|
||||
/**
|
||||
* \brief Returns a string containing the default name for the \c
|
||||
* false value of a tribool with the given character type T.
|
||||
*
|
||||
* This function only exists when the C++ standard library
|
||||
* implementation does not support locales.
|
||||
*/
|
||||
template<typename T> std::basic_string<T> default_false_name();
|
||||
|
||||
/**
|
||||
* \brief Returns the character string "false".
|
||||
*
|
||||
* This function only exists when the C++ standard library
|
||||
* implementation does not support locales.
|
||||
*/
|
||||
template<>
|
||||
inline std::basic_string<char> default_false_name<char>()
|
||||
{ return "false"; }
|
||||
|
||||
# if !defined(BOOST_NO_CWCHAR)
|
||||
/**
|
||||
* \brief Returns the wide character string L"false".
|
||||
*
|
||||
* This function only exists when the C++ standard library
|
||||
* implementation does not support locales.
|
||||
*/
|
||||
template<>
|
||||
inline std::basic_string<wchar_t> default_false_name<wchar_t>()
|
||||
{ return L"false"; }
|
||||
# endif
|
||||
|
||||
/**
|
||||
* \brief Returns a string containing the default name for the \c true
|
||||
* value of a tribool with the given character type T.
|
||||
*
|
||||
* This function only exists when the C++ standard library
|
||||
* implementation does not support locales.
|
||||
*/
|
||||
template<typename T> std::basic_string<T> default_true_name();
|
||||
|
||||
/**
|
||||
* \brief Returns the character string "true".
|
||||
*
|
||||
* This function only exists when the C++ standard library
|
||||
* implementation does not support locales.
|
||||
*/
|
||||
template<>
|
||||
inline std::basic_string<char> default_true_name<char>()
|
||||
{ return "true"; }
|
||||
|
||||
# if !defined(BOOST_NO_CWCHAR)
|
||||
/**
|
||||
* \brief Returns the wide character string L"true".
|
||||
*
|
||||
* This function only exists * when the C++ standard library
|
||||
* implementation does not support * locales.
|
||||
*/
|
||||
template<>
|
||||
inline std::basic_string<wchar_t> default_true_name<wchar_t>()
|
||||
{ return L"true"; }
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \brief Returns a string containing the default name for the indeterminate
|
||||
* value of a tribool with the given character type T.
|
||||
*
|
||||
* This routine is used by the input and output streaming operators
|
||||
* for tribool when there is no locale support or the stream's locale
|
||||
* does not contain the indeterminate_name facet.
|
||||
*/
|
||||
template<typename T> std::basic_string<T> get_default_indeterminate_name();
|
||||
|
||||
/// Returns the character string "indeterminate".
|
||||
template<>
|
||||
inline std::basic_string<char> get_default_indeterminate_name<char>()
|
||||
{ return "indeterminate"; }
|
||||
|
||||
#if !defined(BOOST_NO_CWCHAR)
|
||||
/// Returns the wide character string L"indeterminate".
|
||||
template<>
|
||||
inline std::basic_string<wchar_t> get_default_indeterminate_name<wchar_t>()
|
||||
{ return L"indeterminate"; }
|
||||
#endif
|
||||
|
||||
// http://www.cantrip.org/locale.html
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
/**
|
||||
* \brief A locale facet specifying the name of the indeterminate
|
||||
* value of a tribool.
|
||||
*
|
||||
* The facet is used to perform I/O on tribool values when \c
|
||||
* std::boolalpha has been specified. This class template is only
|
||||
* available if the C++ standard library implementation supports
|
||||
* locales.
|
||||
*/
|
||||
template<typename CharT>
|
||||
class indeterminate_name : public std::locale::facet, private boost::noncopyable
|
||||
{
|
||||
public:
|
||||
typedef CharT char_type;
|
||||
typedef std::basic_string<CharT> string_type;
|
||||
|
||||
/// Construct the facet with the default name
|
||||
indeterminate_name() : name_(get_default_indeterminate_name<CharT>()) {}
|
||||
|
||||
/// Construct the facet with the given name for the indeterminate value
|
||||
explicit indeterminate_name(const string_type& initial_name)
|
||||
: name_(initial_name) {}
|
||||
|
||||
/// Returns the name for the indeterminate value
|
||||
string_type name() const { return name_; }
|
||||
|
||||
/// Uniquily identifies this facet with the locale.
|
||||
static std::locale::id id;
|
||||
|
||||
private:
|
||||
string_type name_;
|
||||
};
|
||||
|
||||
template<typename CharT> std::locale::id indeterminate_name<CharT>::id;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \brief Writes the value of a tribool to a stream.
|
||||
*
|
||||
* When the value of @p x is either \c true or \c false, this routine
|
||||
* is semantically equivalent to:
|
||||
* \code out << static_cast<bool>(x); \endcode
|
||||
*
|
||||
* When @p x has an indeterminate value, it outputs either the integer
|
||||
* value 2 (if <tt>(out.flags() & std::ios_base::boolalpha) == 0</tt>)
|
||||
* or the name of the indeterminate value. The name of the
|
||||
* indeterminate value comes from the indeterminate_name facet (if it
|
||||
* is defined in the output stream's locale), or from the
|
||||
* get_default_indeterminate_name function (if it is not defined in the
|
||||
* locale or if the C++ standard library implementation does not
|
||||
* support locales).
|
||||
*
|
||||
* \returns @p out
|
||||
*/
|
||||
template<typename CharT, typename Traits>
|
||||
inline std::basic_ostream<CharT, Traits>&
|
||||
operator<<(std::basic_ostream<CharT, Traits>& out, tribool x)
|
||||
{
|
||||
if (!indeterminate(x)) {
|
||||
out << static_cast<bool>(x);
|
||||
} else {
|
||||
typename std::basic_ostream<CharT, Traits>::sentry cerberus(out);
|
||||
if (cerberus) {
|
||||
if (out.flags() & std::ios_base::boolalpha) {
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
if (BOOST_HAS_FACET(indeterminate_name<CharT>, out.getloc())) {
|
||||
const indeterminate_name<CharT>& facet =
|
||||
BOOST_USE_FACET(indeterminate_name<CharT>, out.getloc());
|
||||
out << facet.name();
|
||||
} else {
|
||||
out << get_default_indeterminate_name<CharT>();
|
||||
}
|
||||
#else
|
||||
out << get_default_indeterminate_name<CharT>();
|
||||
#endif
|
||||
}
|
||||
else
|
||||
out << 2;
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Writes the indeterminate tribool value to a stream.
|
||||
*
|
||||
* This routine outputs either the integer
|
||||
* value 2 (if <tt>(out.flags() & std::ios_base::boolalpha) == 0</tt>)
|
||||
* or the name of the indeterminate value. The name of the
|
||||
* indeterminate value comes from the indeterminate_name facet (if it
|
||||
* is defined in the output stream's locale), or from the
|
||||
* get_default_indeterminate_name function (if it is not defined in the
|
||||
* locale or if the C++ standard library implementation does not
|
||||
* support locales).
|
||||
*
|
||||
* \returns @p out
|
||||
*/
|
||||
template<typename CharT, typename Traits>
|
||||
inline std::basic_ostream<CharT, Traits>&
|
||||
operator<<(std::basic_ostream<CharT, Traits>& out,
|
||||
bool (*)(tribool, detail::indeterminate_t))
|
||||
{ return out << tribool(indeterminate); }
|
||||
|
||||
/**
|
||||
* \brief Reads a tribool value from a stream.
|
||||
*
|
||||
* When <tt>(out.flags() & std::ios_base::boolalpha) == 0</tt>, this
|
||||
* function reads a \c long value from the input stream @p in and
|
||||
* converts that value to a tribool. If that value is 0, @p x becomes
|
||||
* \c false; if it is 1, @p x becomes \c true; if it is 2, @p becomes
|
||||
* \c indetermine; otherwise, the operation fails (and the fail bit is
|
||||
* set on the input stream @p in).
|
||||
*
|
||||
* When <tt>(out.flags() & std::ios_base::boolalpha) != 0</tt>, this
|
||||
* function first determines the names of the false, true, and
|
||||
* indeterminate values. The false and true names are extracted from
|
||||
* the \c std::numpunct facet of the input stream's locale (if the C++
|
||||
* standard library implementation supports locales), or from the \c
|
||||
* default_false_name and \c default_true_name functions (if there is
|
||||
* no locale support). The indeterminate name is extracted from the
|
||||
* appropriate \c indeterminate_name facet (if it is available in the
|
||||
* input stream's locale), or from the \c get_default_indeterminate_name
|
||||
* function (if the C++ standard library implementation does not
|
||||
* support locales, or the \c indeterminate_name facet is not
|
||||
* specified for this locale object). The input is then matched to
|
||||
* each of these names, and the tribool @p x is assigned the value
|
||||
* corresponding to the longest name that matched. If no name is
|
||||
* matched or all names are empty, the operation fails (and the fail
|
||||
* bit is set on the input stream @p in).
|
||||
*
|
||||
* \returns @p in
|
||||
*/
|
||||
template<typename CharT, typename Traits>
|
||||
inline std::basic_istream<CharT, Traits>&
|
||||
operator>>(std::basic_istream<CharT, Traits>& in, tribool& x)
|
||||
{
|
||||
if (in.flags() & std::ios_base::boolalpha) {
|
||||
typename std::basic_istream<CharT, Traits>::sentry cerberus(in);
|
||||
if (cerberus) {
|
||||
typedef std::basic_string<CharT> string_type;
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
const std::numpunct<CharT>& numpunct_facet =
|
||||
BOOST_USE_FACET(std::numpunct<CharT>, in.getloc());
|
||||
|
||||
string_type falsename = numpunct_facet.falsename();
|
||||
string_type truename = numpunct_facet.truename();
|
||||
|
||||
string_type othername;
|
||||
if (BOOST_HAS_FACET(indeterminate_name<CharT>, in.getloc())) {
|
||||
othername =
|
||||
BOOST_USE_FACET(indeterminate_name<CharT>, in.getloc()).name();
|
||||
} else {
|
||||
othername = get_default_indeterminate_name<CharT>();
|
||||
}
|
||||
#else
|
||||
string_type falsename = default_false_name<CharT>();
|
||||
string_type truename = default_true_name<CharT>();
|
||||
string_type othername = get_default_indeterminate_name<CharT>();
|
||||
#endif
|
||||
|
||||
typename string_type::size_type pos = 0;
|
||||
bool falsename_ok = true, truename_ok = true, othername_ok = true;
|
||||
|
||||
// Modeled after the code from Library DR 17
|
||||
while ((falsename_ok && pos < falsename.size())
|
||||
|| (truename_ok && pos < truename.size())
|
||||
|| (othername_ok && pos < othername.size())) {
|
||||
typename Traits::int_type c = in.get();
|
||||
if (c == Traits::eof())
|
||||
return in;
|
||||
|
||||
bool matched = false;
|
||||
if (falsename_ok && pos < falsename.size()) {
|
||||
if (Traits::eq(Traits::to_char_type(c), falsename[pos]))
|
||||
matched = true;
|
||||
else
|
||||
falsename_ok = false;
|
||||
}
|
||||
|
||||
if (truename_ok && pos < truename.size()) {
|
||||
if (Traits::eq(Traits::to_char_type(c), truename[pos]))
|
||||
matched = true;
|
||||
else
|
||||
truename_ok = false;
|
||||
}
|
||||
|
||||
if (othername_ok && pos < othername.size()) {
|
||||
if (Traits::eq(Traits::to_char_type(c), othername[pos]))
|
||||
matched = true;
|
||||
else
|
||||
othername_ok = false;
|
||||
}
|
||||
|
||||
if (matched) { ++pos; }
|
||||
if (pos > falsename.size()) falsename_ok = false;
|
||||
if (pos > truename.size()) truename_ok = false;
|
||||
if (pos > othername.size()) othername_ok = false;
|
||||
}
|
||||
|
||||
if (pos == 0)
|
||||
in.setstate(std::ios_base::failbit);
|
||||
else {
|
||||
if (falsename_ok) x = false;
|
||||
else if (truename_ok) x = true;
|
||||
else if (othername_ok) x = indeterminate;
|
||||
else in.setstate(std::ios_base::failbit);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
long value;
|
||||
if (in >> value) {
|
||||
switch (value) {
|
||||
case 0: x = false; break;
|
||||
case 1: x = true; break;
|
||||
case 2: x = indeterminate; break;
|
||||
default: in.setstate(std::ios_base::failbit); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return in;
|
||||
}
|
||||
|
||||
} } // end namespace boost::logic
|
||||
|
||||
#endif // BOOST_LOGIC_TRIBOOL_IO_HPP
|
||||
16
index.html
16
index.html
@@ -1,16 +0,0 @@
|
||||
|
||||
<!--
|
||||
Copyright 2011 Daniel James.
|
||||
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)
|
||||
-->
|
||||
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=../../doc/html/tribool.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="../../doc/html/tribool.html">../../doc/html/tribool.html</a>
|
||||
</body>
|
||||
</html>
|
||||
@@ -1,15 +0,0 @@
|
||||
{
|
||||
"key": "logic/tribool",
|
||||
"name": "Tribool",
|
||||
"authors": [
|
||||
"Doug Gregor"
|
||||
],
|
||||
"description": "3-state boolean type library.",
|
||||
"documentation": "/doc/html/tribool.html",
|
||||
"category": [
|
||||
"Miscellaneous"
|
||||
],
|
||||
"maintainers": [
|
||||
"Douglas Gregor <dgregor -at- cs.indiana.edu>"
|
||||
]
|
||||
}
|
||||
35
test/Jamfile
Normal file
35
test/Jamfile
Normal file
@@ -0,0 +1,35 @@
|
||||
# Tribool library
|
||||
|
||||
# Copyright (C) 2002-2003 Douglas Gregor
|
||||
|
||||
# Use, modification and distribution is subject to 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)
|
||||
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
|
||||
# Testing Jamfile autogenerated from XML source
|
||||
subproject libs/logic/test ;
|
||||
|
||||
# bring in rules for testing
|
||||
SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
|
||||
include testing.jam ;
|
||||
|
||||
# Make tests run by default.
|
||||
DEPENDS all : test ;
|
||||
|
||||
{
|
||||
# look in BOOST_ROOT for sources first, just in this Jamfile
|
||||
local SEARCH_SOURCE = $(BOOST_ROOT) $(SEARCH_SOURCE) ;
|
||||
|
||||
test-suite logic
|
||||
:
|
||||
[ run libs/logic/test/tribool_test.cpp : : : : ]
|
||||
|
||||
[ run libs/logic/test/tribool_rename_test.cpp : : : : ]
|
||||
|
||||
[ run libs/logic/test/tribool_io_test.cpp : : : : ]
|
||||
;
|
||||
}
|
||||
|
||||
@@ -1,62 +0,0 @@
|
||||
# Tribool library
|
||||
|
||||
# Copyright (C) 2002-2003 Douglas Gregor
|
||||
|
||||
# Use, modification and distribution is subject to 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)
|
||||
|
||||
# For more information, see http://www.boost.org/
|
||||
|
||||
import path ;
|
||||
import os ;
|
||||
import regex ;
|
||||
import testing ;
|
||||
|
||||
local self = logic ;
|
||||
|
||||
rule test-expected-failures
|
||||
{
|
||||
local all_rules = ;
|
||||
local file ;
|
||||
local tests_path = [ path.make $(BOOST_ROOT)/libs/$(self)/test/compile-fail ] ;
|
||||
for file in [ path.glob-tree $(tests_path) : *.cpp ]
|
||||
{
|
||||
local rel_file = [ path.relative-to $(tests_path) $(file) ] ;
|
||||
local test_name = [ regex.replace [ regex.replace $(rel_file) "/" "-" ] ".cpp" "" ] ;
|
||||
local decl_test_name = cf-$(test_name) ;
|
||||
# ECHO $(rel_file) ;
|
||||
all_rules += [ compile-fail $(file) : : $(decl_test_name) ] ;
|
||||
}
|
||||
|
||||
# ECHO All rules: $(all_rules) ;
|
||||
return $(all_rules) ;
|
||||
}
|
||||
|
||||
rule test-header-isolation
|
||||
{
|
||||
local all_rules = ;
|
||||
local file ;
|
||||
local headers_path = [ path.make $(BOOST_ROOT)/libs/$(self)/include ] ;
|
||||
for file in [ path.glob-tree $(headers_path) : *.hpp ]
|
||||
{
|
||||
local rel_file = [ path.relative-to $(headers_path) $(file) ] ;
|
||||
# Note: The test name starts with '~' in order to group these tests in the test report table, preferably at the end.
|
||||
# All '/' are replaced with '-' because apparently test scripts have a problem with test names containing slashes.
|
||||
local test_name = [ regex.replace $(rel_file) "/" "-" ] ;
|
||||
local decl_test_name = ~hdr-decl-$(test_name) ;
|
||||
# ECHO $(rel_file) ;
|
||||
all_rules += [ compile compile/decl_header.cpp : <define>"BOOST_TEST_HEADER=$(rel_file)" <dependency>$(file) : $(decl_test_name) ] ;
|
||||
}
|
||||
|
||||
# ECHO All rules: $(all_rules) ;
|
||||
return $(all_rules) ;
|
||||
}
|
||||
|
||||
test-suite logic :
|
||||
[ test-expected-failures ]
|
||||
[ test-header-isolation ]
|
||||
[ run tribool_test.cpp ]
|
||||
[ run tribool_rename_test.cpp ]
|
||||
[ run tribool_io_test.cpp ]
|
||||
;
|
||||
@@ -1,23 +0,0 @@
|
||||
// Copyright 2018 James E. King III. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/logic/tribool.hpp>
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
using boost::logic::indeterminate;
|
||||
using boost::logic::tribool;
|
||||
|
||||
tribool i(indeterminate);
|
||||
|
||||
#if !defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS )
|
||||
bool b = i; // expect to see: no viable conversion from 'boost::logic::tribool' to 'bool'
|
||||
return (int)b;
|
||||
#else
|
||||
#error in c++03 explicit conversions are allowed
|
||||
#endif
|
||||
// NOTREACHED
|
||||
return 0;
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
// Copyright 2018 James E. King III. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/logic/tribool.hpp>
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
using boost::logic::indeterminate;
|
||||
using boost::logic::tribool;
|
||||
|
||||
tribool i(indeterminate);
|
||||
|
||||
return i; // expect to see: error: no viable conversion from returned value of type 'boost::logic::tribool' to function return type 'int'
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
// Copyright 2018 James E. King III. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/logic/tribool.hpp>
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
using boost::logic::indeterminate;
|
||||
using boost::logic::tribool;
|
||||
|
||||
tribool i(indeterminate);
|
||||
|
||||
return i + 1; // expect to see: error: invalid operands to binary expression ('boost::logic::tribool' and 'int')
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
// Copyright 2018 James E. King III. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/logic/tribool.hpp>
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
using boost::logic::indeterminate;
|
||||
using boost::logic::tribool;
|
||||
|
||||
tribool i(indeterminate);
|
||||
|
||||
return i << 1; // expect to see: error: invalid operands to binary expression ('boost::logic::tribool' and 'int')
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
// Copyright 2018 James E. King III. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/logic/tribool.hpp>
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
using boost::logic::tribool;
|
||||
|
||||
tribool f; // false
|
||||
tribool t(true); // true
|
||||
|
||||
return f < t; // expect to see: error: invalid operands to binary expression ('boost::logic::tribool' and 'boost::logic::tribool')
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
// Copyright 2018 James E. King III. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/logic/tribool.hpp>
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
using boost::logic::tribool;
|
||||
|
||||
tribool t(true);
|
||||
|
||||
return t < 1; // expect to see: error: invalid operands to binary expression ('boost::logic::tribool' and 'int')
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
/*
|
||||
* Copyright Andrey Semashev 2015.
|
||||
* 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)
|
||||
*/
|
||||
/*!
|
||||
* \file decl_header.cpp
|
||||
* \author Andrey Semashev
|
||||
* \date 21.06.2015
|
||||
*
|
||||
* \brief This file contains a test boilerplate for checking that every
|
||||
* public header is self-contained and does not have any missing
|
||||
* #includes.
|
||||
*/
|
||||
|
||||
#define BOOST_TEST_INCLUDE_HEADER() <BOOST_TEST_HEADER>
|
||||
|
||||
#include BOOST_TEST_INCLUDE_HEADER()
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@@ -8,7 +8,6 @@
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <ios> // for std::boolalpha
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
# include <locale>
|
||||
@@ -20,18 +19,6 @@ int test_main(int, char*[])
|
||||
|
||||
tribool x;
|
||||
|
||||
#if !defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_STD_WSTRING)
|
||||
std::wostringstream wout;
|
||||
wout << std::boolalpha << tribool(false);
|
||||
BOOST_CHECK(wout.str() == L"false");
|
||||
wout.str(std::wstring());
|
||||
wout << std::boolalpha << tribool(true);
|
||||
BOOST_CHECK(wout.str() == L"true");
|
||||
wout.str(std::wstring());
|
||||
wout << std::boolalpha << tribool(indeterminate);
|
||||
BOOST_CHECK(wout.str() == L"indeterminate");
|
||||
#endif
|
||||
|
||||
// Check tribool output
|
||||
std::ostringstream out;
|
||||
|
||||
@@ -40,14 +27,14 @@ int test_main(int, char*[])
|
||||
x = false;
|
||||
out << x;
|
||||
std::cout << "Output false (noboolalpha): " << out.str() << std::endl;
|
||||
BOOST_CHECK(out.str() == "0");
|
||||
BOOST_TEST(out.str() == "0");
|
||||
|
||||
// Output true (noboolalpha)
|
||||
out.str(std::string());
|
||||
x = true;
|
||||
out << x;
|
||||
std::cout << "Output true (noboolalpha): " << out.str() << std::endl;
|
||||
BOOST_CHECK(out.str() == "1");
|
||||
BOOST_TEST(out.str() == "1");
|
||||
|
||||
// Output indeterminate (noboolalpha)
|
||||
out.str(std::string());
|
||||
@@ -55,14 +42,7 @@ int test_main(int, char*[])
|
||||
out << x;
|
||||
std::cout << "Output indeterminate (noboolalpha): " << out.str()
|
||||
<< std::endl;
|
||||
BOOST_CHECK(out.str() == "2");
|
||||
|
||||
// Output indeterminate (noboolalpha)
|
||||
out.str(std::string());
|
||||
out << indeterminate;
|
||||
std::cout << "Output indeterminate (noboolalpha): " << out.str()
|
||||
<< std::endl;
|
||||
BOOST_CHECK(out.str() == "2");
|
||||
BOOST_TEST(out.str() == "2");
|
||||
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
const std::numpunct<char>& punct =
|
||||
@@ -73,7 +53,7 @@ int test_main(int, char*[])
|
||||
x = false;
|
||||
out << std::boolalpha << x;
|
||||
std::cout << "Output false (boolalpha): " << out.str() << std::endl;
|
||||
BOOST_CHECK(out.str() == punct.falsename());
|
||||
BOOST_TEST(out.str() == punct.falsename());
|
||||
|
||||
// Output true (boolalpha)
|
||||
out.str(std::string());
|
||||
@@ -81,7 +61,7 @@ int test_main(int, char*[])
|
||||
out << std::boolalpha << x;
|
||||
std::cout << "Output true (boolalpha): " << out.str() << std::endl;
|
||||
|
||||
BOOST_CHECK(out.str() == punct.truename());
|
||||
BOOST_TEST(out.str() == punct.truename());
|
||||
|
||||
// Output indeterminate (boolalpha - default name)
|
||||
out.str(std::string());
|
||||
@@ -89,14 +69,7 @@ int test_main(int, char*[])
|
||||
out << std::boolalpha << x;
|
||||
std::cout << "Output indeterminate (boolalpha - default name): " << out.str()
|
||||
<< std::endl;
|
||||
BOOST_CHECK(out.str() == "indeterminate");
|
||||
|
||||
// Output indeterminate (boolalpha - default name)
|
||||
out.str(std::string());
|
||||
out << std::boolalpha << indeterminate;
|
||||
std::cout << "Output indeterminate (boolalpha - default name): " << out.str()
|
||||
<< std::endl;
|
||||
BOOST_CHECK(out.str() == "indeterminate");
|
||||
BOOST_TEST(out.str() == "indeterminate");
|
||||
|
||||
# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
|
||||
// No template constructors, so we can't build the test locale
|
||||
@@ -109,7 +82,7 @@ int test_main(int, char*[])
|
||||
out << std::boolalpha << x;
|
||||
std::cout << "Output indeterminate (boolalpha - \"maybe\"): " << out.str()
|
||||
<< std::endl;
|
||||
BOOST_CHECK(out.str() == "maybe");
|
||||
BOOST_TEST(out.str() == "maybe");
|
||||
# endif
|
||||
#endif // ! BOOST_NO_STD_LOCALE
|
||||
|
||||
@@ -120,7 +93,7 @@ int test_main(int, char*[])
|
||||
std::istringstream in("0");
|
||||
std::cout << "Input \"0\" (checks for false)" << std::endl;
|
||||
in >> x;
|
||||
BOOST_CHECK(x == false);
|
||||
BOOST_TEST(x == false);
|
||||
}
|
||||
|
||||
// Input true (noboolalpha)
|
||||
@@ -128,7 +101,7 @@ int test_main(int, char*[])
|
||||
std::istringstream in("1");
|
||||
std::cout << "Input \"1\" (checks for true)" << std::endl;
|
||||
in >> x;
|
||||
BOOST_CHECK(x == true);
|
||||
BOOST_TEST(x == true);
|
||||
}
|
||||
|
||||
// Input false (noboolalpha)
|
||||
@@ -136,14 +109,14 @@ int test_main(int, char*[])
|
||||
std::istringstream in("2");
|
||||
std::cout << "Input \"2\" (checks for indeterminate)" << std::endl;
|
||||
in >> x;
|
||||
BOOST_CHECK(indeterminate(x));
|
||||
BOOST_TEST(indeterminate(x));
|
||||
}
|
||||
|
||||
// Input bad number (noboolalpha)
|
||||
{
|
||||
std::istringstream in("3");
|
||||
std::cout << "Input \"3\" (checks for failure)" << std::endl;
|
||||
BOOST_CHECK(!(in >> x));
|
||||
BOOST_TEST(!(in >> x));
|
||||
}
|
||||
|
||||
// Input false (boolalpha)
|
||||
@@ -151,7 +124,7 @@ int test_main(int, char*[])
|
||||
std::istringstream in("false");
|
||||
std::cout << "Input \"false\" (checks for false)" << std::endl;
|
||||
in >> std::boolalpha >> x;
|
||||
BOOST_CHECK(x == false);
|
||||
BOOST_TEST(x == false);
|
||||
}
|
||||
|
||||
// Input true (boolalpha)
|
||||
@@ -159,7 +132,7 @@ int test_main(int, char*[])
|
||||
std::istringstream in("true");
|
||||
std::cout << "Input \"true\" (checks for true)" << std::endl;
|
||||
in >> std::boolalpha >> x;
|
||||
BOOST_CHECK(x == true);
|
||||
BOOST_TEST(x == true);
|
||||
}
|
||||
|
||||
// Input indeterminate (boolalpha)
|
||||
@@ -168,7 +141,7 @@ int test_main(int, char*[])
|
||||
std::cout << "Input \"indeterminate\" (checks for indeterminate)"
|
||||
<< std::endl;
|
||||
in >> std::boolalpha >> x;
|
||||
BOOST_CHECK(indeterminate(x));
|
||||
BOOST_TEST(indeterminate(x));
|
||||
}
|
||||
|
||||
// Input bad string (boolalpha)
|
||||
@@ -176,7 +149,7 @@ int test_main(int, char*[])
|
||||
std::istringstream in("bad");
|
||||
std::cout << "Input \"bad\" (checks for failure)"
|
||||
<< std::endl;
|
||||
BOOST_CHECK(!(in >> std::boolalpha >> x));
|
||||
BOOST_TEST(!(in >> std::boolalpha >> x));
|
||||
}
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
|
||||
@@ -190,7 +163,7 @@ int test_main(int, char*[])
|
||||
std::cout << "Input \"maybe\" (checks for indeterminate, uses locales)"
|
||||
<< std::endl;
|
||||
in >> std::boolalpha >> x;
|
||||
BOOST_CHECK(indeterminate(x));
|
||||
BOOST_TEST(indeterminate(x));
|
||||
}
|
||||
|
||||
// Input indeterminate named "true_or_false" (boolalpha)
|
||||
@@ -202,7 +175,7 @@ int test_main(int, char*[])
|
||||
std::cout << "Input \"true_or_false\" (checks for indeterminate)"
|
||||
<< std::endl;
|
||||
in >> std::boolalpha >> x;
|
||||
BOOST_CHECK(indeterminate(x));
|
||||
BOOST_TEST(indeterminate(x));
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
@@ -19,103 +19,103 @@ int test_main(int,char*[])
|
||||
tribool y(true); // true
|
||||
tribool z(maybe); // maybe
|
||||
|
||||
BOOST_CHECK(!x);
|
||||
BOOST_CHECK(x == false);
|
||||
BOOST_CHECK(false == x);
|
||||
BOOST_CHECK(x != true);
|
||||
BOOST_CHECK(true != x);
|
||||
BOOST_CHECK(maybe(x == maybe));
|
||||
BOOST_CHECK(maybe(maybe == x));
|
||||
BOOST_CHECK(maybe(x != maybe));
|
||||
BOOST_CHECK(maybe(maybe != x));
|
||||
BOOST_CHECK(x == x);
|
||||
BOOST_CHECK(!(x != x));
|
||||
BOOST_CHECK(!(x && true));
|
||||
BOOST_CHECK(!(true && x));
|
||||
BOOST_CHECK(x || true);
|
||||
BOOST_CHECK(true || x);
|
||||
BOOST_TEST(!x);
|
||||
BOOST_TEST(x == false);
|
||||
BOOST_TEST(false == x);
|
||||
BOOST_TEST(x != true);
|
||||
BOOST_TEST(true != x);
|
||||
BOOST_TEST(maybe(x == maybe));
|
||||
BOOST_TEST(maybe(maybe == x));
|
||||
BOOST_TEST(maybe(x != maybe));
|
||||
BOOST_TEST(maybe(maybe != x));
|
||||
BOOST_TEST(x == x);
|
||||
BOOST_TEST(!(x != x));
|
||||
BOOST_TEST(!(x && true));
|
||||
BOOST_TEST(!(true && x));
|
||||
BOOST_TEST(x || true);
|
||||
BOOST_TEST(true || x);
|
||||
|
||||
BOOST_CHECK(y);
|
||||
BOOST_CHECK(y == true);
|
||||
BOOST_CHECK(true == y);
|
||||
BOOST_CHECK(y != false);
|
||||
BOOST_CHECK(false != y);
|
||||
BOOST_CHECK(maybe(y == maybe));
|
||||
BOOST_CHECK(maybe(maybe == y));
|
||||
BOOST_CHECK(maybe(y != maybe));
|
||||
BOOST_CHECK(maybe(maybe != y));
|
||||
BOOST_CHECK(y == y);
|
||||
BOOST_CHECK(!(y != y));
|
||||
BOOST_TEST(y);
|
||||
BOOST_TEST(y == true);
|
||||
BOOST_TEST(true == y);
|
||||
BOOST_TEST(y != false);
|
||||
BOOST_TEST(false != y);
|
||||
BOOST_TEST(maybe(y == maybe));
|
||||
BOOST_TEST(maybe(maybe == y));
|
||||
BOOST_TEST(maybe(y != maybe));
|
||||
BOOST_TEST(maybe(maybe != y));
|
||||
BOOST_TEST(y == y);
|
||||
BOOST_TEST(!(y != y));
|
||||
|
||||
BOOST_CHECK(maybe(z || !z));
|
||||
BOOST_CHECK(maybe(z == true));
|
||||
BOOST_CHECK(maybe(true == z));
|
||||
BOOST_CHECK(maybe(z == false));
|
||||
BOOST_CHECK(maybe(false == z));
|
||||
BOOST_CHECK(maybe(z == maybe));
|
||||
BOOST_CHECK(maybe(maybe == z));
|
||||
BOOST_CHECK(maybe(z != maybe));
|
||||
BOOST_CHECK(maybe(maybe != z));
|
||||
BOOST_CHECK(maybe(z == z));
|
||||
BOOST_CHECK(maybe(z != z));
|
||||
BOOST_TEST(maybe(z || !z));
|
||||
BOOST_TEST(maybe(z == true));
|
||||
BOOST_TEST(maybe(true == z));
|
||||
BOOST_TEST(maybe(z == false));
|
||||
BOOST_TEST(maybe(false == z));
|
||||
BOOST_TEST(maybe(z == maybe));
|
||||
BOOST_TEST(maybe(maybe == z));
|
||||
BOOST_TEST(maybe(z != maybe));
|
||||
BOOST_TEST(maybe(maybe != z));
|
||||
BOOST_TEST(maybe(z == z));
|
||||
BOOST_TEST(maybe(z != z));
|
||||
|
||||
BOOST_CHECK(!(x == y));
|
||||
BOOST_CHECK(x != y);
|
||||
BOOST_CHECK(maybe(x == z));
|
||||
BOOST_CHECK(maybe(x != z));
|
||||
BOOST_CHECK(maybe(y == z));
|
||||
BOOST_CHECK(maybe(y != z));
|
||||
BOOST_TEST(!(x == y));
|
||||
BOOST_TEST(x != y);
|
||||
BOOST_TEST(maybe(x == z));
|
||||
BOOST_TEST(maybe(x != z));
|
||||
BOOST_TEST(maybe(y == z));
|
||||
BOOST_TEST(maybe(y != z));
|
||||
|
||||
BOOST_CHECK(!(x && y));
|
||||
BOOST_CHECK(x || y);
|
||||
BOOST_CHECK(!(x && z));
|
||||
BOOST_CHECK(maybe(y && z));
|
||||
BOOST_CHECK(maybe(z && z));
|
||||
BOOST_CHECK(maybe(z || z));
|
||||
BOOST_CHECK(maybe(x || z));
|
||||
BOOST_CHECK(y || z);
|
||||
BOOST_TEST(!(x && y));
|
||||
BOOST_TEST(x || y);
|
||||
BOOST_TEST(!(x && z));
|
||||
BOOST_TEST(maybe(y && z));
|
||||
BOOST_TEST(maybe(z && z));
|
||||
BOOST_TEST(maybe(z || z));
|
||||
BOOST_TEST(maybe(x || z));
|
||||
BOOST_TEST(y || z);
|
||||
|
||||
BOOST_CHECK(maybe(y && maybe));
|
||||
BOOST_CHECK(maybe(maybe && y));
|
||||
BOOST_CHECK(!(x && maybe));
|
||||
BOOST_CHECK(!(maybe && x));
|
||||
BOOST_TEST(maybe(y && maybe));
|
||||
BOOST_TEST(maybe(maybe && y));
|
||||
BOOST_TEST(!(x && maybe));
|
||||
BOOST_TEST(!(maybe && x));
|
||||
|
||||
BOOST_CHECK(maybe || y);
|
||||
BOOST_CHECK(y || maybe);
|
||||
BOOST_CHECK(maybe(x || maybe));
|
||||
BOOST_CHECK(maybe(maybe || x));
|
||||
BOOST_TEST(maybe || y);
|
||||
BOOST_TEST(y || maybe);
|
||||
BOOST_TEST(maybe(x || maybe));
|
||||
BOOST_TEST(maybe(maybe || x));
|
||||
|
||||
// Test the if (z) ... else (!z) ... else ... idiom
|
||||
if (z) {
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
else if (!z) {
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
else {
|
||||
BOOST_CHECK(true);
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
z = true;
|
||||
if (z) {
|
||||
BOOST_CHECK(true);
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
else if (!z) {
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
else {
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
|
||||
z = false;
|
||||
if (z) {
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
else if (!z) {
|
||||
BOOST_CHECK(true);
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
else {
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
|
||||
std::cout << "no errors detected\n";
|
||||
|
||||
@@ -3,7 +3,6 @@
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/logic/tribool.hpp>
|
||||
#include <boost/test/minimal.hpp>
|
||||
#include <iostream>
|
||||
@@ -16,139 +15,105 @@ int test_main(int, char*[])
|
||||
tribool y(true); // true
|
||||
tribool z(indeterminate); // indeterminate
|
||||
|
||||
#if defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS )
|
||||
// c++03 allows for implicit conversion to bool
|
||||
// c++11 uses an explicit conversion operator so this would not compile
|
||||
// and that is tested in the compile-fail/implicit.cpp file
|
||||
// so we check the conversion to ensure it is sane
|
||||
bool bx = x;
|
||||
BOOST_CHECK(bx == false);
|
||||
bool by = y;
|
||||
BOOST_CHECK(by == true);
|
||||
bool bz = z;
|
||||
BOOST_CHECK(bz == false);
|
||||
#endif
|
||||
BOOST_TEST(!x);
|
||||
BOOST_TEST(x == false);
|
||||
BOOST_TEST(false == x);
|
||||
BOOST_TEST(x != true);
|
||||
BOOST_TEST(true != x);
|
||||
BOOST_TEST(indeterminate(x == indeterminate));
|
||||
BOOST_TEST(indeterminate(indeterminate == x));
|
||||
BOOST_TEST(indeterminate(x != indeterminate));
|
||||
BOOST_TEST(indeterminate(indeterminate != x));
|
||||
BOOST_TEST(x == x);
|
||||
BOOST_TEST(!(x != x));
|
||||
BOOST_TEST(!(x && true));
|
||||
BOOST_TEST(!(true && x));
|
||||
BOOST_TEST(x || true);
|
||||
BOOST_TEST(true || x);
|
||||
|
||||
BOOST_CHECK(!x);
|
||||
BOOST_CHECK(x == false);
|
||||
BOOST_CHECK(false == x);
|
||||
BOOST_CHECK(x != true);
|
||||
BOOST_CHECK(true != x);
|
||||
BOOST_CHECK(indeterminate(x == indeterminate));
|
||||
BOOST_CHECK(indeterminate(indeterminate == x));
|
||||
BOOST_CHECK(indeterminate(x != indeterminate));
|
||||
BOOST_CHECK(indeterminate(indeterminate != x));
|
||||
BOOST_CHECK(x == x);
|
||||
BOOST_CHECK(!(x != x));
|
||||
BOOST_CHECK(!(x && true));
|
||||
BOOST_CHECK(!(true && x));
|
||||
BOOST_CHECK(x || true);
|
||||
BOOST_CHECK(true || x);
|
||||
BOOST_TEST(y);
|
||||
BOOST_TEST(y == true);
|
||||
BOOST_TEST(true == y);
|
||||
BOOST_TEST(y != false);
|
||||
BOOST_TEST(false != y);
|
||||
BOOST_TEST(indeterminate(y == indeterminate));
|
||||
BOOST_TEST(indeterminate(indeterminate == y));
|
||||
BOOST_TEST(indeterminate(y != indeterminate));
|
||||
BOOST_TEST(indeterminate(indeterminate != y));
|
||||
BOOST_TEST(y == y);
|
||||
BOOST_TEST(!(y != y));
|
||||
|
||||
BOOST_CHECK(y);
|
||||
BOOST_CHECK(y == true);
|
||||
BOOST_CHECK(true == y);
|
||||
BOOST_CHECK(y != false);
|
||||
BOOST_CHECK(false != y);
|
||||
BOOST_CHECK(indeterminate(y == indeterminate));
|
||||
BOOST_CHECK(indeterminate(indeterminate == y));
|
||||
BOOST_CHECK(indeterminate(y != indeterminate));
|
||||
BOOST_CHECK(indeterminate(indeterminate != y));
|
||||
BOOST_CHECK(y == y);
|
||||
BOOST_CHECK(!(y != y));
|
||||
BOOST_TEST(indeterminate(z || !z));
|
||||
BOOST_TEST(indeterminate(z == true));
|
||||
BOOST_TEST(indeterminate(true == z));
|
||||
BOOST_TEST(indeterminate(z == false));
|
||||
BOOST_TEST(indeterminate(false == z));
|
||||
BOOST_TEST(indeterminate(z == indeterminate));
|
||||
BOOST_TEST(indeterminate(indeterminate == z));
|
||||
BOOST_TEST(indeterminate(z != indeterminate));
|
||||
BOOST_TEST(indeterminate(indeterminate != z));
|
||||
BOOST_TEST(indeterminate(z == z));
|
||||
BOOST_TEST(indeterminate(z != z));
|
||||
|
||||
BOOST_CHECK(indeterminate(z || !z));
|
||||
BOOST_CHECK(indeterminate(z == true));
|
||||
BOOST_CHECK(indeterminate(true == z));
|
||||
BOOST_CHECK(indeterminate(z == false));
|
||||
BOOST_CHECK(indeterminate(false == z));
|
||||
BOOST_CHECK(indeterminate(z == indeterminate));
|
||||
BOOST_CHECK(indeterminate(indeterminate == z));
|
||||
BOOST_CHECK(indeterminate(z != indeterminate));
|
||||
BOOST_CHECK(indeterminate(indeterminate != z));
|
||||
BOOST_CHECK(indeterminate(z == z));
|
||||
BOOST_CHECK(indeterminate(z != z));
|
||||
BOOST_TEST(!(x == y));
|
||||
BOOST_TEST(x != y);
|
||||
BOOST_TEST(indeterminate(x == z));
|
||||
BOOST_TEST(indeterminate(x != z));
|
||||
BOOST_TEST(indeterminate(y == z));
|
||||
BOOST_TEST(indeterminate(y != z));
|
||||
|
||||
BOOST_CHECK(!(x == y));
|
||||
BOOST_CHECK(x != y);
|
||||
BOOST_CHECK(indeterminate(x == z));
|
||||
BOOST_CHECK(indeterminate(x != z));
|
||||
BOOST_CHECK(indeterminate(y == z));
|
||||
BOOST_CHECK(indeterminate(y != z));
|
||||
BOOST_TEST(!(x && y));
|
||||
BOOST_TEST(x || y);
|
||||
BOOST_TEST(!(x && z));
|
||||
BOOST_TEST(indeterminate(y && z));
|
||||
BOOST_TEST(indeterminate(z && z));
|
||||
BOOST_TEST(indeterminate(z || z));
|
||||
BOOST_TEST(indeterminate(x || z));
|
||||
BOOST_TEST(y || z);
|
||||
|
||||
BOOST_CHECK(!(x && y));
|
||||
BOOST_CHECK(x || y);
|
||||
BOOST_CHECK(!(x && z));
|
||||
BOOST_CHECK(indeterminate(y && z));
|
||||
BOOST_CHECK(indeterminate(z && z));
|
||||
BOOST_CHECK(indeterminate(z || z));
|
||||
BOOST_CHECK(indeterminate(x || z));
|
||||
BOOST_CHECK(y || z);
|
||||
BOOST_TEST(indeterminate(y && indeterminate));
|
||||
BOOST_TEST(indeterminate(indeterminate && y));
|
||||
BOOST_TEST(!(x && indeterminate));
|
||||
BOOST_TEST(!(indeterminate && x));
|
||||
|
||||
BOOST_CHECK(indeterminate(y && indeterminate));
|
||||
BOOST_CHECK(indeterminate(indeterminate && y));
|
||||
BOOST_CHECK(!(x && indeterminate));
|
||||
BOOST_CHECK(!(indeterminate && x));
|
||||
|
||||
BOOST_CHECK(indeterminate || y);
|
||||
BOOST_CHECK(y || indeterminate);
|
||||
BOOST_CHECK(indeterminate(x || indeterminate));
|
||||
BOOST_CHECK(indeterminate(indeterminate || x));
|
||||
BOOST_TEST(indeterminate || y);
|
||||
BOOST_TEST(y || indeterminate);
|
||||
BOOST_TEST(indeterminate(x || indeterminate));
|
||||
BOOST_TEST(indeterminate(indeterminate || x));
|
||||
|
||||
// Test the if (z) ... else (!z) ... else ... idiom
|
||||
if (z) {
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
else if (!z) {
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
else {
|
||||
BOOST_CHECK(true);
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
|
||||
z = true;
|
||||
if (z) {
|
||||
BOOST_CHECK(true);
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
else if (!z) {
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
else {
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
|
||||
z = false;
|
||||
if (z) {
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
else if (!z) {
|
||||
BOOST_CHECK(true);
|
||||
BOOST_TEST(true);
|
||||
}
|
||||
else {
|
||||
BOOST_CHECK(false);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_CONSTEXPR)
|
||||
constexpr bool res_ors = indeterminate(false || tribool(false) || false || indeterminate); // true
|
||||
BOOST_CHECK(res_ors);
|
||||
char array_ors[res_ors ? 2 : 3];
|
||||
BOOST_CHECK(sizeof(array_ors) / sizeof(char) == 2);
|
||||
|
||||
constexpr bool res_ands = !indeterminate(!(true && tribool(true) && true && indeterminate)); // false
|
||||
BOOST_CHECK(!res_ands);
|
||||
char array_ands[res_ands ? 2 : 3];
|
||||
BOOST_CHECK(sizeof(array_ands) / sizeof(char) == 3);
|
||||
|
||||
constexpr bool res_safe_bool = static_cast<bool>( tribool(true) );
|
||||
BOOST_STATIC_ASSERT(res_safe_bool);
|
||||
|
||||
// gcc 4.6 chokes on the xxx assignment
|
||||
# if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
|
||||
constexpr tribool xxx = (tribool(true) || tribool(indeterminate));
|
||||
BOOST_STATIC_ASSERT(xxx);
|
||||
# endif
|
||||
#endif
|
||||
|
||||
std::cout << "no errors detected\n";
|
||||
return 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user