mirror of
https://github.com/boostorg/dynamic_bitset.git
synced 2026-01-24 18:02:09 +00:00
Compare commits
1 Commits
boost-1.69
...
boost-1.34
| Author | SHA1 | Date | |
|---|---|---|---|
|
884ece62d1 |
175
.travis.yml
175
.travis.yml
@@ -1,175 +0,0 @@
|
||||
# Copyright 2016 Peter Dimov
|
||||
# Copyright 2017, 2018 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/jeking3/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. Enable pull request builds in your boostorg/<library> account.
|
||||
#
|
||||
# That's it - the scripts will do everything else for you.
|
||||
|
||||
sudo: false
|
||||
dist: trusty
|
||||
language: cpp
|
||||
|
||||
env:
|
||||
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..
|
||||
# - B2_ADDRESS_MODEL=address-model=64,32
|
||||
# - B2_LINK=link=shared,static
|
||||
# - B2_THREADING=threading=multi,single
|
||||
- B2_VARIANT=variant=release,debug
|
||||
|
||||
install:
|
||||
- git clone https://github.com/jeking3/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
|
||||
|
||||
branches:
|
||||
only:
|
||||
- develop
|
||||
- master
|
||||
|
||||
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-34: &clang-34 { apt: { packages: [ "clang-3.4" ], sources: [ "llvm-toolchain-trusty-3.4" ] } }
|
||||
clang-38: &clang-38 { apt: { packages: [ "clang-3.8",
|
||||
"libstdc++-6-dev" ], sources: [ "llvm-toolchain-trusty-3.8",
|
||||
"ubuntu-toolchain-r-test" ] } }
|
||||
clang-4: &clang-4 { apt: { packages: [ "clang-4.0",
|
||||
"libstdc++-6-dev" ], sources: [ "llvm-toolchain-trusty-4.0",
|
||||
"ubuntu-toolchain-r-test" ] } }
|
||||
clang-5: &clang-5 { apt: { packages: [ "clang-5.0",
|
||||
"libstdc++-7-dev" ], sources: [ "llvm-toolchain-trusty-5.0",
|
||||
"ubuntu-toolchain-r-test" ] } }
|
||||
clang-6: &clang-6 { apt: { packages: [ "clang-6.0",
|
||||
"libc++-dev",
|
||||
"libstdc++-8-dev",
|
||||
"valgrind" ], sources: [ "llvm-toolchain-trusty-6.0",
|
||||
"ubuntu-toolchain-r-test" ] } }
|
||||
gcc-44: &gcc-44 { apt: { packages: [ "g++-4.4" ], sources: [ "ubuntu-toolchain-r-test" ] } }
|
||||
gcc-46: &gcc-46 { apt: { packages: [ "g++-4.6" ], sources: [ "ubuntu-toolchain-r-test" ] } }
|
||||
gcc-48: &gcc-48 { apt: { packages: [ "g++-4.8" ], sources: [ "ubuntu-toolchain-r-test" ] } }
|
||||
gcc-5: &gcc-5 { apt: { packages: [ "g++-5" ], sources: [ "ubuntu-toolchain-r-test" ] } }
|
||||
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" ] } }
|
||||
|
||||
jobs:
|
||||
allow_failures:
|
||||
- env:
|
||||
- COPY="all the environment settings from your job"
|
||||
|
||||
include:
|
||||
# libstdc++
|
||||
- { os: "linux", env: [ "TOOLSET=gcc-4.4", "CXXSTD=98,0x" ], addons: *gcc-44 }
|
||||
- { os: "linux", env: [ "TOOLSET=gcc-4.6", "CXXSTD=03,0x" ], addons: *gcc-46 }
|
||||
- { os: "linux", env: [ "TOOLSET=gcc-4.8", "CXXSTD=03,11" ], addons: *gcc-48 }
|
||||
- { os: "linux", env: [ "TOOLSET=gcc-5", "CXXSTD=03,11" ], addons: *gcc-5 }
|
||||
- { os: "linux", env: [ "TOOLSET=gcc-6", "CXXSTD=03,11,14" ], addons: *gcc-6 }
|
||||
- { os: "linux", env: [ "TOOLSET=gcc-7", "CXXSTD=03,11,14,17" ], addons: *gcc-7 }
|
||||
- { os: "linux", env: [ "TOOLSET=gcc-8", "CXXSTD=03,11,14,17,2a" ], addons: *gcc-8 }
|
||||
- { os: "linux", env: [ "TOOLSET=clang-3.4", "CXXSTD=03,11" ], addons: *clang-34 }
|
||||
- { os: "linux", env: [ "TOOLSET=clang-3.8", "CXXSTD=03,11,14" ], addons: *clang-38 }
|
||||
- { os: "linux", env: [ "TOOLSET=clang-4.0", "CXXSTD=03,11,14" ], addons: *clang-4 }
|
||||
- { os: "linux", env: [ "TOOLSET=clang-5.0", "CXXSTD=03,11,14,17" ], addons: *clang-5 }
|
||||
- { os: "linux", env: [ "TOOLSET=clang-6.0", "CXXSTD=03,11,14,17,2a" ], addons: *clang-6 }
|
||||
# libc++
|
||||
- { os: "linux", env: [ "TOOLSET=clang-6.0", "CXXSTD=03,11,14,17,2a",
|
||||
"CXXFLAGS=-stdlib=libc++" ], addons: *clang-6 }
|
||||
# the rvm environment on osx is taking over basic commands like "cd" and breaking things!
|
||||
# - { os: "osx" , env: [ "COMMENT=libc++",
|
||||
# "TOOLSET=clang", "CXXSTD=03,11,14" ] }
|
||||
|
||||
- os: linux
|
||||
env:
|
||||
- COMMENT=codecov.io
|
||||
- TOOLSET=gcc-7
|
||||
- DEFINES="define=BOOST_NO_STRESS_TEST=1"
|
||||
addons: *gcc-7
|
||||
script:
|
||||
- pushd /tmp && git clone https://github.com/linux-test-project/lcov.git && export PATH=/tmp/lcov/bin:$PATH && which lcov && lcov --version && popd
|
||||
- cd $BOOST_ROOT/libs/$SELF
|
||||
- ci/travis/codecov.sh
|
||||
|
||||
- os: linux
|
||||
env:
|
||||
- COMMENT=cppcheck
|
||||
script:
|
||||
- cd $BOOST_ROOT/libs/$SELF
|
||||
- ci/travis/cppcheck.sh
|
||||
|
||||
- os: linux
|
||||
env:
|
||||
- COMMENT=ubsan
|
||||
- B2_VARIANT=variant=debug
|
||||
- TOOLSET=gcc-8
|
||||
- CXXSTD=03,11,14,17,2a
|
||||
- DEFINES="define=BOOST_NO_STRESS_TEST=1"
|
||||
- CXXFLAGS="cxxflags=-fno-omit-frame-pointer cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined"
|
||||
- LINKFLAGS="linkflags=-fsanitize=undefined linkflags=-fno-sanitize-recover=undefined linkflags=-fuse-ld=gold"
|
||||
- UBSAN_OPTIONS=print_stacktrace=1
|
||||
addons: *gcc-8
|
||||
|
||||
- os: linux
|
||||
env:
|
||||
- COMMENT=valgrind
|
||||
- TOOLSET=clang-6.0
|
||||
- CXXSTD=03,11,14,17,2a
|
||||
- DEFINES="define=BOOST_NO_STRESS_TEST=1"
|
||||
- B2_VARIANT=variant=debug
|
||||
- TESTFLAGS=testing.launcher=valgrind
|
||||
- VALGRIND_OPTS=--error-exitcode=1
|
||||
addons: *clang-6
|
||||
|
||||
#################### 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"
|
||||
- TOOLSET=gcc-7
|
||||
addons: *gcc-7
|
||||
script:
|
||||
- cd $BOOST_ROOT/libs/$SELF
|
||||
- ci/travis/coverity.sh
|
||||
|
||||
notifications:
|
||||
email:
|
||||
false
|
||||
11
Jamfile
11
Jamfile
@@ -1,11 +0,0 @@
|
||||
# Boost.DynamicBitset 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 example ;
|
||||
build-project test ;
|
||||
15
Jamfile.v2
Normal file
15
Jamfile.v2
Normal file
@@ -0,0 +1,15 @@
|
||||
#
|
||||
# Copyright Vladimir Prus 2004
|
||||
#
|
||||
# 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)
|
||||
|
||||
|
||||
test-suite dynamic_bitset :
|
||||
|
||||
[ run dyn_bitset_unit_tests1.cpp ]
|
||||
[ run dyn_bitset_unit_tests2.cpp ]
|
||||
[ run dyn_bitset_unit_tests3.cpp ]
|
||||
[ run dyn_bitset_unit_tests4.cpp ]
|
||||
;
|
||||
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 @@
|
||||
DynamicBitset, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), is similar to std::bitset however the size is specified at run-time instead of at compile-time.
|
||||
|
||||
### 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/dynamic_bitset/tree/master) | [](https://travis-ci.org/boostorg/dynamic_bitset) | [](https://ci.appveyor.com/project/jeking3/dynamic_bitset-jv17p/branch/master) | [](https://scan.coverity.com/projects/boostorg-dynamic_bitset) | [](https://codecov.io/gh/boostorg/dynamic_bitset/branch/master)| [](https://pdimov.github.io/boostdep-report/master/dynamic_bitset.html) | [](http://www.boost.org/doc/libs/master/doc/html/dynamic_bitset.html) | [](http://www.boost.org/development/tests/master/developer/dynamic_bitset.html)
|
||||
[`develop`](https://github.com/boostorg/dynamic_bitset/tree/develop) | [](https://travis-ci.org/boostorg/dynamic_bitset) | [](https://ci.appveyor.com/project/jeking3/dynamic_bitset-jv17p/branch/develop) | [](https://scan.coverity.com/projects/boostorg-dynamic_bitset) | [](https://codecov.io/gh/boostorg/dynamic_bitset/branch/develop) | [](https://pdimov.github.io/boostdep-report/develop/dynamic_bitset.html) | [](http://www.boost.org/doc/libs/develop/doc/html/dynamic_bitset.html) | [](http://www.boost.org/development/tests/develop/developer/dynamic_bitset.html)
|
||||
|
||||
### Directories
|
||||
|
||||
| Name | Purpose |
|
||||
| ----------- | ------------------------------ |
|
||||
| `example` | examples |
|
||||
| `doc` | documentation |
|
||||
| `include` | headers |
|
||||
| `test` | unit tests |
|
||||
|
||||
### More information
|
||||
|
||||
* [Ask questions](http://stackoverflow.com/questions/ask?tags=c%2B%2B,boost,boost-dynamic_bitset)
|
||||
* [Report bugs](https://github.com/boostorg/dynamic_bitset/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 `[dynamic_bitset]` tag at the beginning of the subject line.
|
||||
|
||||
126
appveyor.yml
126
appveyor.yml
@@ -1,126 +0,0 @@
|
||||
# Copyright 2016, 2017 Peter Dimov
|
||||
# Copyright (C) 2017, 2018 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/jeking3/boost-ci/
|
||||
#
|
||||
# Instructions for customizing this script for your library:
|
||||
#
|
||||
# 1. Customize the compilers and language levels you want.
|
||||
# 2. If you have move 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:
|
||||
- develop
|
||||
- master
|
||||
|
||||
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,debug
|
||||
|
||||
matrix:
|
||||
- FLAVOR: Visual Studio 2017 C++2a Strict
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
TOOLSET: msvc-14.1
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
CXXFLAGS: cxxflags=-permissive-
|
||||
CXXSTD: latest # 2a
|
||||
|
||||
- FLAVOR: Visual Studio 2017 C++17
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
TOOLSET: msvc-14.1
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
CXXSTD: 17
|
||||
|
||||
- FLAVOR: Visual Studio 2017 C++14 (Default)
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
TOOLSET: msvc-14.1
|
||||
B2_ADDRESS_MODEL: address-model=64,32
|
||||
|
||||
- FLAVOR: Visual Studio 2015 C++14 (Default)
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
TOOLSET: msvc-14.0
|
||||
B2_ADDRESS_MODEL: address-model=64,32
|
||||
|
||||
- FLAVOR: Visual Studio 2010, 2012, 2013
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
|
||||
TOOLSET: msvc-10.0,msvc-11.0,msvc-12.0
|
||||
|
||||
- FLAVOR: cygwin (32-bit)
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
ADDPATH: C:\cygwin\bin;
|
||||
B2_ADDRESS_MODEL: address-model=32
|
||||
CXXSTD: 03,11
|
||||
# https://github.com/boostorg/test/issues/144
|
||||
DEFINES: define=_POSIX_C_SOURCE=200112L
|
||||
THREADING: threadapi=pthread
|
||||
TOOLSET: gcc
|
||||
|
||||
- FLAVOR: cygwin (64-bit)
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
ADDPATH: C:\cygwin64\bin;
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
CXXSTD: 11,17
|
||||
# https://github.com/boostorg/test/issues/144
|
||||
DEFINES: define=_POSIX_C_SOURCE=200112L define=__USE_ISOC99
|
||||
THREADING: threadapi=pthread
|
||||
TOOLSET: gcc
|
||||
|
||||
- FLAVOR: mingw32
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
ARCH: i686
|
||||
B2_ADDRESS_MODEL: address-model=32
|
||||
CXXSTD: 03,11
|
||||
SCRIPT: ci\appveyor\mingw.bat
|
||||
|
||||
- FLAVOR: mingw64
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
ARCH: x86_64
|
||||
B2_ADDRESS_MODEL: address-model=64
|
||||
CXXSTD: 11,17
|
||||
DEFINES: define=__USE_ISOC99
|
||||
SCRIPT: ci\appveyor\mingw.bat
|
||||
|
||||
install:
|
||||
- set SELF=%APPVEYOR_PROJECT_NAME:-=_%
|
||||
- git clone https://github.com/jeking3/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 TOOLCXX omits CXXSTD= if it was not defined above
|
||||
- IF NOT DEFINED CXXSTD (SET TOOLCXX=toolset=%TOOLSET%) ELSE (SET TOOLCXX=toolset=%TOOLSET% cxxstd=%CXXSTD%)
|
||||
# Echo the complete build command to the build log
|
||||
- IF NOT DEFINED SCRIPT (ECHO b2 libs/%SELF:\=/% %TOOLCXX% %CXXFLAGS% %DEFINES% %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:\=/% %TOOLCXX% %CXXFLAGS% %DEFINES% %THREADING% %B2_ADDRESS_MODEL% %B2_LINK% %B2_THREADING% %B2_VARIANT% -j3)
|
||||
@@ -1,9 +1,6 @@
|
||||
// -----------------------------------------------------------
|
||||
// Copyright (c) 2001 Jeremy Siek
|
||||
// Copyright (c) 2003-2006, 2008 Gennaro Prota
|
||||
// Copyright (c) 2014 Ahmed Charles
|
||||
// Copyright (c) 2014 Riccardo Marcangelo
|
||||
// Copyright (c) 2018 Evgeny Shulgin
|
||||
// --------------------------------------------------
|
||||
// (C) Copyright Jeremy Siek 2001.
|
||||
// (C) Copyright Gennaro Prota 2003 - 2004.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
@@ -11,6 +8,7 @@
|
||||
//
|
||||
// -----------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef BOOST_BITSET_TEST_HPP_GP_20040319
|
||||
#define BOOST_BITSET_TEST_HPP_GP_20040319
|
||||
|
||||
@@ -20,32 +18,28 @@
|
||||
#endif
|
||||
|
||||
#include <vector>
|
||||
#include <fstream> // used for operator<<
|
||||
#include <fstream> // used for operator<< :( - gps
|
||||
#include <string> // for (basic_string and) getline()
|
||||
#include <algorithm> // for std::min
|
||||
#include <assert.h> // <cassert> is sometimes macro-guarded :-(
|
||||
#include <cassert>
|
||||
|
||||
#include "boost/limits.hpp"
|
||||
#include "boost/dynamic_bitset/dynamic_bitset.hpp"
|
||||
#include "boost/dynamic_bitset.hpp"
|
||||
#include "boost/test/minimal.hpp"
|
||||
#include "boost/filesystem.hpp"
|
||||
|
||||
|
||||
template <typename Block>
|
||||
inline bool nth_bit(Block num, std::size_t n)
|
||||
{
|
||||
#ifndef NDEBUG
|
||||
#ifdef __BORLANDC__
|
||||
// Borland deduces Block as a const qualified type,
|
||||
// and thus finds numeric_limits<Block> to be zero :(
|
||||
// (though not directly relevant here, see also
|
||||
// lib issue 559)
|
||||
// and finds numeric_limits<Block> to be zero :(
|
||||
int block_width = sizeof(Block) * CHAR_BIT;
|
||||
#else
|
||||
int block_width = std::numeric_limits<Block>::digits;
|
||||
#endif
|
||||
assert(n < (std::size_t) block_width);
|
||||
#endif
|
||||
|
||||
assert(n < (std::size_t) block_width);
|
||||
return (num >> n) & 1;
|
||||
}
|
||||
|
||||
@@ -65,27 +59,10 @@ std::string get_long_string()
|
||||
return std::string(p);
|
||||
}
|
||||
|
||||
class scoped_temp_file
|
||||
const char * test_file_name()
|
||||
{
|
||||
public:
|
||||
scoped_temp_file()
|
||||
: m_path(boost::filesystem::unique_path())
|
||||
{
|
||||
}
|
||||
|
||||
~scoped_temp_file()
|
||||
{
|
||||
boost::filesystem::remove(m_path);
|
||||
}
|
||||
|
||||
const boost::filesystem::path& path() const
|
||||
{
|
||||
return m_path;
|
||||
}
|
||||
|
||||
private:
|
||||
boost::filesystem::path m_path;
|
||||
};
|
||||
return "boost_dynamic_bitset_tests";
|
||||
}
|
||||
|
||||
#if defined BOOST_OLD_IOSTREAMS || defined BOOST_NO_STD_LOCALE
|
||||
template <typename Stream>
|
||||
@@ -100,20 +77,20 @@ bool is_white_space(const Stream & /*s*/, char c)
|
||||
}
|
||||
#else
|
||||
template <typename Stream, typename Ch>
|
||||
bool is_one_or_zero(const Stream& s, Ch c)
|
||||
bool is_one_or_zero(const Stream& s, Ch c) // gps
|
||||
{
|
||||
typedef typename Stream::traits_type Tr;
|
||||
const Ch zero = s.widen('0');
|
||||
const Ch one = s.widen('1');
|
||||
|
||||
return Tr::eq(c, one) || Tr::eq(c, zero);
|
||||
return Tr::eq(c, one) || Tr::eq(c, zero) ;
|
||||
}
|
||||
template <typename Stream, typename Ch>
|
||||
bool is_white_space(const Stream & s, Ch c)
|
||||
{
|
||||
// NOTE: the using directive is to satisfy Borland 5.6.4
|
||||
// with its own library (STLport), which doesn't
|
||||
// like std::isspace(c, loc)
|
||||
// with its own library (STLport), which chokes
|
||||
// on std::isspace(c, loc) - gps
|
||||
using namespace std;
|
||||
return isspace(c, s.getloc());
|
||||
}
|
||||
@@ -130,45 +107,30 @@ bool has_flags(const Stream& s, std::ios::iostate flags)
|
||||
// constructors
|
||||
// default (can't do this generically)
|
||||
|
||||
// from unsigned long
|
||||
|
||||
template <typename Bitset>
|
||||
struct bitset_test {
|
||||
|
||||
typedef typename Bitset::block_type Block;
|
||||
BOOST_STATIC_CONSTANT(int, bits_per_block = Bitset::bits_per_block);
|
||||
|
||||
// from unsigned long
|
||||
//
|
||||
// Note: this is templatized so that we check that the do-the-right-thing
|
||||
// constructor dispatch is working correctly.
|
||||
//
|
||||
template <typename NumBits, typename Value>
|
||||
static void from_unsigned_long(NumBits num_bits, Value num)
|
||||
static void from_unsigned_long(std::size_t N, unsigned long num)
|
||||
{
|
||||
// An object of size sz = num_bits is constructed:
|
||||
// - the first m bit positions are initialized to the corresponding
|
||||
// bit values in num (m being the smaller of sz and ulong_width)
|
||||
//
|
||||
// - any remaining bit positions are initialized to zero
|
||||
//
|
||||
// initializes the first M bit position to the cooresponding bit
|
||||
// values in val. M is the smaller of N and the width of unsigned
|
||||
// long
|
||||
|
||||
Bitset b(static_cast<typename Bitset::size_type>(num_bits), static_cast<unsigned long>(num));
|
||||
// missing from the std?
|
||||
// if M < N then the remaining bit positions are initialized to zero
|
||||
|
||||
// OK, we can now cast to size_type
|
||||
typedef typename Bitset::size_type size_type;
|
||||
const size_type sz = static_cast<size_type>(num_bits);
|
||||
|
||||
BOOST_CHECK(b.size() == sz);
|
||||
Bitset b(N, num);
|
||||
BOOST_CHECK(b.size() == N);
|
||||
|
||||
const std::size_t ulong_width = std::numeric_limits<unsigned long>::digits;
|
||||
size_type m = sz;
|
||||
if (ulong_width < sz)
|
||||
m = ulong_width;
|
||||
|
||||
size_type i = 0;
|
||||
for ( ; i < m; ++i)
|
||||
BOOST_CHECK(b.test(i) == nth_bit(static_cast<unsigned long>(num), i));
|
||||
for ( ; i < sz; ++i)
|
||||
BOOST_CHECK(b.test(i) == 0);
|
||||
std::size_t M = (std::min)(N, ulong_width);
|
||||
std::size_t I;
|
||||
for (I = 0; I < M; ++I)
|
||||
BOOST_CHECK(b[I] == nth_bit(num, I));
|
||||
for (; I < N; ++I)
|
||||
BOOST_CHECK(b[I] == 0);
|
||||
}
|
||||
|
||||
// from string
|
||||
@@ -188,7 +150,7 @@ struct bitset_test {
|
||||
std::size_t num_bits = (std::size_t)(-1))
|
||||
{
|
||||
|
||||
std::size_t rlen = (std::min)(max_char, str.size() - pos);
|
||||
std::size_t rlen = (std::min)(max_char, str.size() - pos); // [gps]
|
||||
|
||||
// The resulting size N of the bitset is num_bits, if
|
||||
// that is different from the default arg, rlen otherwise.
|
||||
@@ -207,7 +169,7 @@ struct bitset_test {
|
||||
std::size_t m = (std::min)(num_bits, rlen);
|
||||
std::size_t j;
|
||||
for (j = 0; j < m; ++j)
|
||||
BOOST_CHECK(b[j] == (str[pos + m - 1 - j] == '1'));
|
||||
BOOST_CHECK(b[j] == (str[pos + m - 1 - j] == '1')); // [gps]
|
||||
// If M < N, remaining bit positions are zero
|
||||
for (; j < actual_size; ++j)
|
||||
BOOST_CHECK(b[j] == 0);
|
||||
@@ -215,6 +177,9 @@ struct bitset_test {
|
||||
|
||||
}
|
||||
|
||||
typedef typename Bitset::block_type Block;
|
||||
BOOST_STATIC_CONSTANT(int, bits_per_block = Bitset::bits_per_block);
|
||||
|
||||
static void to_block_range(const Bitset & b /*, BlockOutputIterator result*/)
|
||||
{
|
||||
typedef typename Bitset::size_type size_type;
|
||||
@@ -243,7 +208,7 @@ struct bitset_test {
|
||||
}
|
||||
}
|
||||
|
||||
// TODO from_block_range (below) should be splitted
|
||||
// gps - TODO from_block_range (below) should be splitted
|
||||
|
||||
// PRE: std::equal(first1, last1, first2) == true
|
||||
static void from_block_range(const std::vector<Block>& blocks)
|
||||
@@ -271,7 +236,7 @@ struct bitset_test {
|
||||
BOOST_CHECK(bset[bit] == nth_bit(blocks[b], i));
|
||||
}
|
||||
}
|
||||
BOOST_CHECK(n <= bset.num_blocks());
|
||||
BOOST_CHECK(n <= bset.num_blocks()); // gps - ok? ask on the list
|
||||
}
|
||||
}
|
||||
|
||||
@@ -289,12 +254,11 @@ struct bitset_test {
|
||||
}
|
||||
}
|
||||
|
||||
// copy assignment operator (absent from std::bitset)
|
||||
static void copy_assignment_operator(const Bitset& lhs, const Bitset& rhs)
|
||||
// assignment operator (absent from std::bitset)
|
||||
static void assignment_operator(const Bitset& lhs, const Bitset& rhs)
|
||||
{
|
||||
Bitset b(lhs);
|
||||
b = rhs;
|
||||
b = b; // self assignment check
|
||||
BOOST_CHECK(b == rhs);
|
||||
|
||||
// Changes to the copy do not affect the original
|
||||
@@ -305,46 +269,18 @@ struct bitset_test {
|
||||
}
|
||||
}
|
||||
|
||||
static void max_size(const Bitset& b)
|
||||
{
|
||||
BOOST_CHECK(b.max_size() > 0);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
|
||||
// move constructor (absent from std::bitset)
|
||||
static void move_constructor(const Bitset& b)
|
||||
{
|
||||
Bitset copy(boost::move(b));
|
||||
BOOST_CHECK(b == copy);
|
||||
}
|
||||
|
||||
// move assignment operator (absent from std::bitset)
|
||||
static void move_assignment_operator(const Bitset& lhs, const Bitset& rhs)
|
||||
{
|
||||
Bitset b(lhs);
|
||||
Bitset c(rhs);
|
||||
b = boost::move(c);
|
||||
b = boost::move(b); // self assignment check
|
||||
BOOST_CHECK(b == rhs);
|
||||
}
|
||||
|
||||
#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
|
||||
static void swap(const Bitset& lhs, const Bitset& rhs)
|
||||
{
|
||||
// bitsets must be swapped
|
||||
Bitset copy1(lhs);
|
||||
Bitset copy2(rhs);
|
||||
copy1.swap(copy2);
|
||||
Bitset b1(lhs);
|
||||
Bitset b2(rhs);
|
||||
b1.swap(b2);
|
||||
|
||||
BOOST_CHECK(copy1 == rhs);
|
||||
BOOST_CHECK(copy2 == lhs);
|
||||
BOOST_CHECK(b1 == rhs);
|
||||
BOOST_CHECK(b2 == lhs);
|
||||
|
||||
// references must be stable under a swap
|
||||
for(typename Bitset::size_type i = 0; i < lhs.size(); ++i) {
|
||||
Bitset b1(lhs);
|
||||
Bitset b2(rhs);
|
||||
for(typename Bitset::size_type i = 0; i < b1.size(); ++i) {
|
||||
typename Bitset::reference ref = b1[i];
|
||||
bool x = ref;
|
||||
if (i < b2.size())
|
||||
@@ -352,8 +288,7 @@ struct bitset_test {
|
||||
b1.swap(b2);
|
||||
BOOST_CHECK(b2[i] == x); // now it must be equal..
|
||||
b2.flip(i);
|
||||
BOOST_CHECK(ref == b2[i]); // .. and ref must be into b2
|
||||
BOOST_CHECK(ref == !x);
|
||||
BOOST_CHECK(ref == !x); // .. and ref must be into b2
|
||||
}
|
||||
|
||||
}
|
||||
@@ -388,20 +323,6 @@ struct bitset_test {
|
||||
BOOST_CHECK(b.size() == 0);
|
||||
}
|
||||
|
||||
static void pop_back(const Bitset& lhs)
|
||||
{
|
||||
Bitset b(lhs);
|
||||
b.pop_back();
|
||||
BOOST_CHECK(b.size() == lhs.size() - 1);
|
||||
for (std::size_t i = 0; i < b.size(); ++i)
|
||||
BOOST_CHECK(b[i] == lhs[i]);
|
||||
|
||||
b.pop_back();
|
||||
BOOST_CHECK(b.size() == lhs.size() - 2);
|
||||
for (std::size_t j = 0; j < b.size(); ++j)
|
||||
BOOST_CHECK(b[j] == lhs[j]);
|
||||
}
|
||||
|
||||
static void append_bit(const Bitset& lhs)
|
||||
{
|
||||
Bitset b(lhs);
|
||||
@@ -422,7 +343,7 @@ struct bitset_test {
|
||||
static void append_block(const Bitset& lhs)
|
||||
{
|
||||
Bitset b(lhs);
|
||||
Block value(128);
|
||||
Block value(128); // gps
|
||||
b.append(value);
|
||||
BOOST_CHECK(b.size() == lhs.size() + bits_per_block);
|
||||
for (typename Bitset::block_width_type i = 0; i < bits_per_block; ++i)
|
||||
@@ -620,22 +541,6 @@ struct bitset_test {
|
||||
}
|
||||
}
|
||||
|
||||
static void set_segment(const Bitset& b, std::size_t pos,
|
||||
std::size_t len, bool value)
|
||||
{
|
||||
Bitset lhs(b);
|
||||
std::size_t N = lhs.size();
|
||||
Bitset prev(lhs);
|
||||
lhs.set(pos, len, value);
|
||||
for (std::size_t I = 0; I < N; ++I)
|
||||
{
|
||||
if (I < pos || I >= pos + len)
|
||||
BOOST_CHECK(lhs[I] == prev[I]);
|
||||
else
|
||||
BOOST_CHECK(lhs[I] == value);
|
||||
}
|
||||
}
|
||||
|
||||
static void reset_all(const Bitset& b)
|
||||
{
|
||||
Bitset lhs(b);
|
||||
@@ -664,22 +569,6 @@ struct bitset_test {
|
||||
}
|
||||
}
|
||||
|
||||
static void reset_segment(const Bitset& b, std::size_t pos,
|
||||
std::size_t len)
|
||||
{
|
||||
Bitset lhs(b);
|
||||
std::size_t N = lhs.size();
|
||||
Bitset prev(lhs);
|
||||
lhs.reset(pos, len);
|
||||
for (std::size_t I = 0; I < N; ++I)
|
||||
{
|
||||
if (I < pos || I >= pos + len)
|
||||
BOOST_CHECK(lhs[I] == prev[I]);
|
||||
else
|
||||
BOOST_CHECK(!lhs[I]);
|
||||
}
|
||||
}
|
||||
|
||||
static void operator_flip(const Bitset& b)
|
||||
{
|
||||
Bitset lhs(b);
|
||||
@@ -717,22 +606,6 @@ struct bitset_test {
|
||||
}
|
||||
}
|
||||
|
||||
static void flip_segment(const Bitset& b, std::size_t pos,
|
||||
std::size_t len)
|
||||
{
|
||||
Bitset lhs(b);
|
||||
std::size_t N = lhs.size();
|
||||
Bitset prev(lhs);
|
||||
lhs.flip(pos, len);
|
||||
for (std::size_t I = 0; I < N; ++I)
|
||||
{
|
||||
if (I < pos || I >= pos + len)
|
||||
BOOST_CHECK(lhs[I] == prev[I]);
|
||||
else
|
||||
BOOST_CHECK(lhs[I] != prev[I]);
|
||||
}
|
||||
}
|
||||
|
||||
// empty
|
||||
static void empty(const Bitset& b)
|
||||
{
|
||||
@@ -742,35 +615,29 @@ struct bitset_test {
|
||||
// to_ulong()
|
||||
static void to_ulong(const Bitset& lhs)
|
||||
{
|
||||
typedef unsigned long result_type;
|
||||
std::size_t n = std::numeric_limits<result_type>::digits;
|
||||
std::size_t sz = lhs.size();
|
||||
|
||||
std::size_t N = lhs.size();
|
||||
std::size_t n = std::numeric_limits<unsigned long>::digits;
|
||||
bool will_overflow = false;
|
||||
for (std::size_t i = n; i < sz; ++i) {
|
||||
if (lhs.test(i) != 0) {
|
||||
for (std::size_t I = n; I < N; ++I)
|
||||
if (lhs[I] != 0)
|
||||
will_overflow = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (will_overflow) {
|
||||
try {
|
||||
(void)lhs.to_ulong();
|
||||
BOOST_CHECK(false); // It should have thrown an exception
|
||||
} catch (std::overflow_error & ex) {
|
||||
} catch (std::overflow_error) {
|
||||
// Good!
|
||||
BOOST_CHECK(!!ex.what());
|
||||
} catch (...) {
|
||||
BOOST_CHECK(false); // threw the wrong exception
|
||||
}
|
||||
} else {
|
||||
result_type num = lhs.to_ulong();
|
||||
// Be sure the number is right
|
||||
if (sz == 0)
|
||||
unsigned long num = lhs.to_ulong();
|
||||
// Make sure the number is right
|
||||
if (N == 0)
|
||||
BOOST_CHECK(num == 0);
|
||||
else {
|
||||
for (std::size_t i = 0; i < sz; ++i)
|
||||
BOOST_CHECK(lhs[i] == (i < n ? nth_bit(num, i) : 0));
|
||||
for (std::size_t I = 0; I < N; ++I)
|
||||
BOOST_CHECK(lhs[I] == (I < n ? nth_bit(num, I) : 0)); //G.P.S. bugfix
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -778,21 +645,29 @@ struct bitset_test {
|
||||
// to_string()
|
||||
static void to_string(const Bitset& b)
|
||||
{
|
||||
// Construct a string object of the appropriate type and initializes
|
||||
// it to a string of length N characters. Each character is determined
|
||||
// by the value of its corresponding bit position in b. Character
|
||||
// position N - 1 corresponds to bit position zero. Sebsequent
|
||||
// decreasing character positions correspond to increasing bit
|
||||
// positions. Bit value zero becomes the charactet 0, bit value one
|
||||
// becomes the character 1.
|
||||
std::string str;
|
||||
boost::to_string(b, str);
|
||||
std::size_t N = b.size();
|
||||
BOOST_CHECK(str.size() == b.size());
|
||||
for (std::size_t i = 0; i < b.size(); ++i)
|
||||
BOOST_CHECK(str[b.size() - 1 - i] ==(b.test(i)? '1':'0'));
|
||||
for (std::size_t I = 0; I < b.size(); ++I)
|
||||
BOOST_CHECK(b[I] == 0 ? (str[N - 1 - I] == '0') : (str[N - 1 - I] == '1'));
|
||||
}
|
||||
|
||||
static void count(const Bitset& b)
|
||||
{
|
||||
std::size_t c = b.count();
|
||||
std::size_t actual = 0;
|
||||
for (std::size_t i = 0; i < b.size(); ++i)
|
||||
if (b[i])
|
||||
++actual;
|
||||
BOOST_CHECK(c == actual);
|
||||
std::size_t c_real = 0;
|
||||
for (std::size_t I = 0; I < b.size(); ++I)
|
||||
if (b[I])
|
||||
++c_real;
|
||||
BOOST_CHECK(c == c_real);
|
||||
}
|
||||
|
||||
static void size(const Bitset& b)
|
||||
@@ -800,157 +675,49 @@ struct bitset_test {
|
||||
BOOST_CHECK(Bitset(b).set().count() == b.size());
|
||||
}
|
||||
|
||||
static void capacity_test_one(const Bitset& lhs)
|
||||
{
|
||||
//empty bitset
|
||||
Bitset b(lhs);
|
||||
BOOST_CHECK(b.capacity() == 0);
|
||||
}
|
||||
|
||||
static void capacity_test_two(const Bitset& lhs)
|
||||
{
|
||||
//bitset constructed with size "100"
|
||||
Bitset b(lhs);
|
||||
BOOST_CHECK(b.capacity() >= 100);
|
||||
b.resize(200);
|
||||
BOOST_CHECK(b.capacity() >= 200);
|
||||
}
|
||||
|
||||
static void reserve_test_one(const Bitset& lhs)
|
||||
{
|
||||
//empty bitset
|
||||
Bitset b(lhs);
|
||||
b.reserve(16);
|
||||
BOOST_CHECK(b.capacity() >= 16);
|
||||
}
|
||||
|
||||
static void reserve_test_two(const Bitset& lhs)
|
||||
{
|
||||
//bitset constructed with size "100"
|
||||
Bitset b(lhs);
|
||||
BOOST_CHECK(b.capacity() >= 100);
|
||||
b.reserve(60);
|
||||
BOOST_CHECK(b.size() == 100);
|
||||
BOOST_CHECK(b.capacity() >= 100);
|
||||
b.reserve(160);
|
||||
BOOST_CHECK(b.size() == 100);
|
||||
BOOST_CHECK(b.capacity() >= 160);
|
||||
}
|
||||
|
||||
static void shrink_to_fit_test_one(const Bitset& lhs)
|
||||
{
|
||||
//empty bitset
|
||||
Bitset b(lhs);
|
||||
b.shrink_to_fit();
|
||||
BOOST_CHECK(b.size() == 0);
|
||||
BOOST_CHECK(b.capacity() == 0);
|
||||
}
|
||||
|
||||
static void shrink_to_fit_test_two(const Bitset& lhs)
|
||||
{
|
||||
//bitset constructed with size "100"
|
||||
Bitset b(lhs);
|
||||
b.shrink_to_fit();
|
||||
BOOST_CHECK(b.capacity() >= 100);
|
||||
BOOST_CHECK(b.size() == 100);
|
||||
b.reserve(200);
|
||||
BOOST_CHECK(b.capacity() >= 200);
|
||||
BOOST_CHECK(b.size() == 100);
|
||||
b.shrink_to_fit();
|
||||
BOOST_CHECK(b.capacity() < 200);
|
||||
BOOST_CHECK(b.size() == 100);
|
||||
}
|
||||
|
||||
static void all(const Bitset& b)
|
||||
{
|
||||
BOOST_CHECK(b.all() == (b.count() == b.size()));
|
||||
bool result = true;
|
||||
for(std::size_t i = 0; i < b.size(); ++i)
|
||||
if(!b[i]) {
|
||||
result = false;
|
||||
break;
|
||||
}
|
||||
BOOST_CHECK(b.all() == result);
|
||||
}
|
||||
|
||||
static void any(const Bitset& b)
|
||||
{
|
||||
BOOST_CHECK(b.any() == (b.count() != 0));
|
||||
bool result = false;
|
||||
for(std::size_t i = 0; i < b.size(); ++i)
|
||||
if(b[i]) {
|
||||
result = true;
|
||||
break;
|
||||
}
|
||||
BOOST_CHECK(b.any() == result);
|
||||
BOOST_CHECK(b.any() == (b.count() > 0));
|
||||
}
|
||||
|
||||
static void none(const Bitset& b)
|
||||
{
|
||||
bool result = true;
|
||||
for(std::size_t i = 0; i < b.size(); ++i) {
|
||||
if(b[i]) {
|
||||
result = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
BOOST_CHECK(b.none() == result);
|
||||
|
||||
// sanity
|
||||
BOOST_CHECK(b.none() == !b.any());
|
||||
BOOST_CHECK(b.none() == (b.count() == 0));
|
||||
}
|
||||
|
||||
static void subset(const Bitset& a, const Bitset& b)
|
||||
{
|
||||
BOOST_CHECK(a.size() == b.size()); // PRE
|
||||
|
||||
bool is_subset = true;
|
||||
if (b.size()) { // could use b.any() but let's be safe
|
||||
for(std::size_t i = 0; i < a.size(); ++i) {
|
||||
if(a.test(i) && !b.test(i)) {
|
||||
if (a.is_subset_of(b)) {
|
||||
for (std::size_t I = 0; I < a.size(); ++I)
|
||||
if (a[I])
|
||||
BOOST_CHECK(b[I]);
|
||||
} else {
|
||||
bool is_subset = true;
|
||||
for (std::size_t I = 0; I < a.size(); ++I)
|
||||
if (a[I] && !b[I]) {
|
||||
is_subset = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
BOOST_CHECK(is_subset == false);
|
||||
}
|
||||
else {
|
||||
// sanity
|
||||
BOOST_CHECK(a.count() == 0);
|
||||
BOOST_CHECK(a.any() == false);
|
||||
|
||||
//is_subset = (a.any() == false);
|
||||
}
|
||||
|
||||
BOOST_CHECK(a.is_subset_of(b) == is_subset);
|
||||
}
|
||||
|
||||
static void proper_subset(const Bitset& a, const Bitset& b)
|
||||
{
|
||||
// PRE: a.size() == b.size()
|
||||
BOOST_CHECK(a.size() == b.size());
|
||||
|
||||
bool is_proper = false;
|
||||
|
||||
if (b.size() != 0) {
|
||||
|
||||
// check it's a subset
|
||||
subset(a, b);
|
||||
|
||||
// is it proper?
|
||||
for (std::size_t i = 0; i < a.size(); ++i) {
|
||||
if (!a.test(i) && b.test(i)) {
|
||||
is_proper = true;
|
||||
// sanity
|
||||
BOOST_CHECK(a.count() < b.count());
|
||||
BOOST_CHECK(b.any());
|
||||
if (a.is_proper_subset_of(b)) {
|
||||
for (std::size_t I = 0; I < a.size(); ++I)
|
||||
if (a[I])
|
||||
BOOST_CHECK(b[I]);
|
||||
BOOST_CHECK(a.count() < b.count());
|
||||
} else {
|
||||
bool is_subset = true;
|
||||
for (std::size_t I = 0; I < a.size(); ++I)
|
||||
if (a[I] && !b[I]) {
|
||||
is_subset = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
BOOST_CHECK(is_subset == false || a.count() >= b.count());
|
||||
}
|
||||
|
||||
BOOST_CHECK(a.is_proper_subset_of(b) == is_proper);
|
||||
if (is_proper)
|
||||
BOOST_CHECK(b.is_proper_subset_of(a) != is_proper);// antisymmetry
|
||||
}
|
||||
|
||||
static void intersects(const Bitset& a, const Bitset& b)
|
||||
@@ -963,7 +730,7 @@ struct bitset_test {
|
||||
have_intersection = true;
|
||||
|
||||
BOOST_CHECK(a.intersects(b) == have_intersection);
|
||||
// also check commutativity
|
||||
// also check it is commutative
|
||||
BOOST_CHECK(b.intersects(a) == have_intersection);
|
||||
}
|
||||
|
||||
@@ -1026,41 +793,23 @@ struct bitset_test {
|
||||
|
||||
static bool less_than(const Bitset& a, const Bitset& b)
|
||||
{
|
||||
|
||||
typedef BOOST_DEDUCED_TYPENAME Bitset::size_type size_type;
|
||||
|
||||
size_type asize(a.size());
|
||||
size_type bsize(b.size());
|
||||
|
||||
if (!bsize)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
else if (!asize)
|
||||
{
|
||||
// Compare from most significant to least.
|
||||
// Careful, don't send unsigned int into negative territory!
|
||||
if (a.size() == 0)
|
||||
return false;
|
||||
|
||||
std::size_t I;
|
||||
for (I = a.size() - 1; I > 0; --I)
|
||||
if (a[I] < b[I])
|
||||
return true;
|
||||
}
|
||||
else if (a[I] > b[I])
|
||||
return false;
|
||||
// if (a[I] = b[I]) skip to next
|
||||
|
||||
if (a[0] < b[0])
|
||||
return true;
|
||||
else
|
||||
{
|
||||
|
||||
// Compare from most significant to least.
|
||||
|
||||
size_type leqsize(std::min BOOST_PREVENT_MACRO_SUBSTITUTION(asize,bsize));
|
||||
size_type I;
|
||||
for (I = 0; I < leqsize; ++I,--asize,--bsize)
|
||||
{
|
||||
|
||||
size_type i = asize-1;
|
||||
size_type j = bsize-1;
|
||||
|
||||
if (a[i] < b[j])
|
||||
return true;
|
||||
else if (a[i] > b[j])
|
||||
return false;
|
||||
// if (a[i] = b[j]) skip to next
|
||||
}
|
||||
return (a.size() < b.size());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static typename Bitset::size_type next_bit_on(const Bitset& b, typename Bitset::size_type prev)
|
||||
@@ -1127,25 +876,6 @@ struct bitset_test {
|
||||
}
|
||||
}
|
||||
|
||||
static void test_set_bit(const Bitset& b, std::size_t pos, bool value)
|
||||
{
|
||||
Bitset lhs(b);
|
||||
std::size_t N = lhs.size();
|
||||
if (pos < N) {
|
||||
Bitset prev(lhs);
|
||||
// Stores a new value in the bit at position pos in lhs.
|
||||
BOOST_CHECK(lhs.test_set(pos, value) == prev[pos]);
|
||||
BOOST_CHECK(lhs[pos] == value);
|
||||
|
||||
// All other values of lhs remain unchanged
|
||||
for (std::size_t I = 0; I < N; ++I)
|
||||
if (I != pos)
|
||||
BOOST_CHECK(lhs[I] == prev[I]);
|
||||
} else {
|
||||
// Not in range, doesn't satisfy precondition.
|
||||
}
|
||||
}
|
||||
|
||||
static void operator_shift_left(const Bitset& lhs, std::size_t pos)
|
||||
{
|
||||
Bitset x(lhs);
|
||||
@@ -1210,7 +940,7 @@ struct bitset_test {
|
||||
//-------------------------------------------------------------------------
|
||||
|
||||
// operator<<( [basic_]ostream,
|
||||
template <typename Stream>
|
||||
template<typename Stream>
|
||||
static void stream_inserter(const Bitset & b,
|
||||
Stream & s,
|
||||
const char * file_name
|
||||
@@ -1236,7 +966,8 @@ struct bitset_test {
|
||||
|
||||
bool did_throw = false;
|
||||
try {
|
||||
s << b;
|
||||
static_cast<void>
|
||||
(s << b);
|
||||
}
|
||||
#if defined BOOST_OLD_IOSTREAMS
|
||||
catch(...) {
|
||||
@@ -1251,14 +982,14 @@ struct bitset_test {
|
||||
}
|
||||
#endif
|
||||
|
||||
BOOST_CHECK(did_throw || !stream_was_good || (s.width() == 0));
|
||||
BOOST_CHECK(did_throw || !stream_was_good || (s.width() == 0)); // gps
|
||||
|
||||
if (!stream_was_good) {
|
||||
if (!stream_was_good) { // gps
|
||||
BOOST_CHECK(s.good() == false);
|
||||
|
||||
// this should actually be oldstate == s.rdstate()
|
||||
// but some implementations add badbit in the
|
||||
// sentry constructor
|
||||
// sentry constructor - gps
|
||||
//
|
||||
BOOST_CHECK((oldstate & s.rdstate()) == oldstate);
|
||||
BOOST_CHECK(s.width() == w);
|
||||
@@ -1269,8 +1000,8 @@ struct bitset_test {
|
||||
// This test require that os be an output _and_ input stream.
|
||||
// Of course dynamic_bitset's operator << doesn't require that.
|
||||
|
||||
size_type total_len = w <= 0 || static_cast<size_type>(w) < b.size()? b.size() : static_cast<size_type>(w);
|
||||
const string_type padding (total_len - b.size(), fill_char);
|
||||
size_type total_len = w <= 0 || (size_type)(w) < b.size()? b.size() : w;
|
||||
const string_type padding (total_len - b.size(), fill_char); // gps
|
||||
string_type expected;
|
||||
boost::to_string(b, expected);
|
||||
if ((s.flags() & std::ios::adjustfield) != std::ios::left)
|
||||
@@ -1284,13 +1015,13 @@ struct bitset_test {
|
||||
s.close();
|
||||
corresponding_input_stream_type is(file_name);
|
||||
string_type contents;
|
||||
std::getline(is, contents, char_type());
|
||||
std::getline(is, contents, char_type()); // gps
|
||||
BOOST_CHECK(contents == expected);
|
||||
}
|
||||
}
|
||||
|
||||
// operator>>( [basic_]istream
|
||||
template <typename Stream, typename String>
|
||||
template<typename Stream, typename String>
|
||||
static void stream_extractor(Bitset& b,
|
||||
Stream& is,
|
||||
String& str
|
||||
@@ -1311,11 +1042,12 @@ struct bitset_test {
|
||||
const std::ios::iostate except = is.exceptions();
|
||||
bool has_stream_exceptions = true;
|
||||
try {
|
||||
is >> b;
|
||||
static_cast<void>
|
||||
(is >> b);
|
||||
}
|
||||
catch(const std::ios::failure &) {
|
||||
did_throw = true;
|
||||
}
|
||||
}// catch bad alloc?? - gps
|
||||
|
||||
// postconditions
|
||||
BOOST_CHECK(except == is.exceptions()); // paranoid
|
||||
@@ -1360,7 +1092,7 @@ struct bitset_test {
|
||||
// {digits} or part of them
|
||||
const typename Bitset::size_type max_digits =
|
||||
w > 0 && static_cast<typename Bitset::size_type>(w) < b.max_size()
|
||||
? static_cast<typename Bitset::size_type>(w) : b.max_size();
|
||||
? w : b.max_size();
|
||||
|
||||
for( ; pos < len && (pos - after_spaces) < max_digits; ++pos) {
|
||||
if(!is_one_or_zero(is, str[pos]))
|
||||
@@ -1371,7 +1103,7 @@ struct bitset_test {
|
||||
|
||||
// eofbit
|
||||
if((after_digits == len && max_digits > num_digits ))
|
||||
BOOST_CHECK(has_flags(is, std::ios::eofbit));
|
||||
BOOST_CHECK(has_flags(is, std::ios::eofbit)); // gps
|
||||
else
|
||||
BOOST_CHECK(!has_flags(is, std::ios::eofbit));
|
||||
|
||||
@@ -1414,16 +1146,16 @@ struct bitset_test {
|
||||
// bitset though there's nothing in the file to be extracted.
|
||||
// Note that the dynamic_bitset docs say a sentry object is
|
||||
// constructed and then converted to bool, thus we rely on
|
||||
// what the underlying library does.
|
||||
// what the underlying library does. - gps
|
||||
//
|
||||
#if !defined(BOOST_DINKUMWARE_STDLIB) || (BOOST_DINKUMWARE_STDLIB >= 306)
|
||||
#if !defined(BOOST_DINKUMWARE_STDLIB) || (BOOST_DINKUMWARE_STDLIB >= 306) // what about STLPORT? - gps
|
||||
BOOST_CHECK(b == a_copy);
|
||||
#else
|
||||
BOOST_CHECK(b.empty() == true);
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
String sub = str.substr(after_spaces, num_digits);
|
||||
String sub = str.substr(after_spaces, num_digits); // gps
|
||||
BOOST_CHECK(b == Bitset(sub));
|
||||
}
|
||||
|
||||
@@ -1436,7 +1168,7 @@ struct bitset_test {
|
||||
// clear the stream to allow further reading then
|
||||
// retrieve any remaining chars with a single getline()
|
||||
is.exceptions(std::ios::goodbit);
|
||||
is.clear();
|
||||
is.clear(); // gps
|
||||
String remainder;
|
||||
std::getline(is, remainder, Ch());
|
||||
if(stream_was_good)
|
||||
@@ -1 +0,0 @@
|
||||
The documentation for the dynamic_bitset library is the top-level index.html file.
|
||||
@@ -1,11 +1,6 @@
|
||||
// -----------------------------------------------------------
|
||||
// Copyright (c) 2001 Jeremy Siek
|
||||
// Copyright (c) 2003-2006 Gennaro Prota
|
||||
// Copyright (c) 2014 Ahmed Charles
|
||||
// Copyright (c) 2014 Riccardo Marcangelo
|
||||
//
|
||||
// Copyright (c) 2014 Glen Joseph Fernandes
|
||||
// (glenjofe@gmail.com)
|
||||
// --------------------------------------------------------
|
||||
// (C) Copyright Jeremy Siek 2001.
|
||||
// (C) Copyright Gennaro Prota 2003 - 2004.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
@@ -13,47 +8,17 @@
|
||||
//
|
||||
// -----------------------------------------------------------
|
||||
|
||||
|
||||
#include "bitset_test.hpp"
|
||||
#include "boost/dynamic_bitset/dynamic_bitset.hpp"
|
||||
#include "boost/dynamic_bitset.hpp"
|
||||
#include "boost/limits.hpp"
|
||||
#include "boost/config.hpp"
|
||||
|
||||
#include "boost/detail/workaround.hpp"
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
|
||||
#include <cstdlib>
|
||||
|
||||
template<class T>
|
||||
class minimal_allocator {
|
||||
public:
|
||||
typedef T value_type;
|
||||
|
||||
minimal_allocator() {}
|
||||
|
||||
template <typename U>
|
||||
minimal_allocator(const minimal_allocator<U>&) {}
|
||||
|
||||
T* allocate(std::size_t n) {
|
||||
void* p = std::malloc(sizeof(T) * n);
|
||||
if (!p) {
|
||||
throw std::bad_alloc();
|
||||
}
|
||||
return static_cast<T*>(p);
|
||||
}
|
||||
|
||||
void deallocate(T* p, std::size_t) {
|
||||
std::free(p);
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
#define BOOST_BITSET_TEST_COUNT(x) (sizeof(x)/sizeof(x[0]))
|
||||
|
||||
|
||||
// Codewarrior 8.3 for Win fails without this.
|
||||
// Thanks Howard Hinnant ;)
|
||||
#if defined __MWERKS__ && BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
|
||||
# pragma parse_func_templ off
|
||||
#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
|
||||
#pragma parse_func_templ off
|
||||
#endif
|
||||
|
||||
|
||||
@@ -86,112 +51,50 @@ void run_string_tests(const String& s
|
||||
|
||||
}
|
||||
|
||||
// tests the do-the-right-thing constructor dispatch
|
||||
template <typename Tests, typename T>
|
||||
void run_numeric_ctor_tests( BOOST_EXPLICIT_TEMPLATE_TYPE(Tests)
|
||||
BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T) )
|
||||
{
|
||||
|
||||
const int bits_per_block = Tests::bits_per_block;
|
||||
const int width = std::numeric_limits<T>::digits;
|
||||
const T ma = (std::numeric_limits<T>::max)();
|
||||
const T mi = (std::numeric_limits<T>::min)();
|
||||
|
||||
int sizes[] = {
|
||||
0, 7*width/10, width, 13*width/10, 3*width,
|
||||
7*bits_per_block/10, bits_per_block, 13*bits_per_block/10, 3*bits_per_block
|
||||
};
|
||||
|
||||
const T numbers[] = {
|
||||
T(-1), T(-3), T(-8), T(-15), T(mi/2), T(mi),
|
||||
T(0), T(1), T(3), T(8), T(15), T(ma/2), T(ma)
|
||||
};
|
||||
|
||||
for (std::size_t s = 0; s < BOOST_BITSET_TEST_COUNT(sizes); ++s) {
|
||||
for (std::size_t n = 0; n < BOOST_BITSET_TEST_COUNT(numbers); ++n ) {
|
||||
|
||||
// can match ctor from ulong or templated one
|
||||
Tests::from_unsigned_long(sizes[s], numbers[n]);
|
||||
|
||||
typedef std::size_t compare_type;
|
||||
const compare_type sz = sizes[s];
|
||||
// this condition is to be sure that size is representable in T, so
|
||||
// that for signed T's we avoid implementation-defined behavior [if ma
|
||||
// is larger than what std::size_t can hold then this is ok for our
|
||||
// purposes: our sizes are anyhow < max(size_t)], which in turn could
|
||||
// make the first argument of from_unsigned_long() a small negative,
|
||||
// later converted to a very large unsigned. Example: signed 8-bit
|
||||
// char (CHAR_MAX=127), bits_per_block=64, sz = 192 > 127.
|
||||
const bool fits =
|
||||
sz <= static_cast<compare_type>(ma);
|
||||
|
||||
if (fits) {
|
||||
// can match templated ctor only (so we test dispatching)
|
||||
Tests::from_unsigned_long(static_cast<T>(sizes[s]), numbers[n]);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
template <typename Block>
|
||||
void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
{
|
||||
typedef boost::dynamic_bitset<Block> bitset_type;
|
||||
typedef bitset_test<bitset_type> Tests;
|
||||
typedef bitset_test< bitset_type > Tests;
|
||||
const int bits_per_block = bitset_type::bits_per_block;
|
||||
|
||||
const std::string long_string = get_long_string();
|
||||
const Block all_1s = static_cast<Block>(-1);
|
||||
|
||||
//=====================================================================
|
||||
// Test construction from unsigned long
|
||||
{
|
||||
// NOTE:
|
||||
//
|
||||
// 1. keep this in sync with the numeric types supported
|
||||
// for constructor dispatch (of course)
|
||||
// 2. bool is tested separately; ugly and inelegant, but
|
||||
// we don't have much time to think of a better solution
|
||||
// which is likely to work on broken compilers
|
||||
//
|
||||
const int sizes[] = {
|
||||
0, 1, 3,
|
||||
7*bits_per_block/10, bits_per_block, 13*bits_per_block/10, 3*bits_per_block
|
||||
};
|
||||
|
||||
const bool values[] = { false, true };
|
||||
const std::size_t ulong_width = std::numeric_limits<unsigned long>::digits;
|
||||
const unsigned long ulong_max =(std::numeric_limits<unsigned long>::max)();
|
||||
|
||||
for (std::size_t s = 0; s < BOOST_BITSET_TEST_COUNT(sizes); ++s) {
|
||||
for (std::size_t v = 0; v < BOOST_BITSET_TEST_COUNT(values); ++v) {
|
||||
Tests::from_unsigned_long(sizes[s], values[v]);
|
||||
Tests::from_unsigned_long(sizes[s] != 0, values[v]);
|
||||
}
|
||||
unsigned long numbers[] = { 0, 1, 40247, ulong_max >> 1, ulong_max };
|
||||
const std::size_t array_count = sizeof(numbers) / sizeof(numbers[0]);
|
||||
|
||||
for (std::size_t i = 0; i < array_count; ++i) {
|
||||
unsigned long number = numbers[i];
|
||||
std::size_t n = 0;
|
||||
Tests::from_unsigned_long(n, number);
|
||||
|
||||
n = std::size_t(0.7 * double(ulong_width));
|
||||
Tests::from_unsigned_long(n, number);
|
||||
|
||||
n = 1 * ulong_width;
|
||||
Tests::from_unsigned_long(n, number);
|
||||
|
||||
n = std::size_t(1.3 * double(ulong_width));
|
||||
Tests::from_unsigned_long(n, number);
|
||||
|
||||
n = std::size_t(0.7 * double(bits_per_block));
|
||||
Tests::from_unsigned_long(n, number);
|
||||
|
||||
n = 1 * bits_per_block;
|
||||
Tests::from_unsigned_long(n, number);
|
||||
|
||||
n = std::size_t(1.3 * double(bits_per_block));
|
||||
Tests::from_unsigned_long(n, number);
|
||||
|
||||
n = 3 * bits_per_block;
|
||||
Tests::from_unsigned_long(n, number);
|
||||
}
|
||||
|
||||
run_numeric_ctor_tests<Tests, char>();
|
||||
|
||||
#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
run_numeric_ctor_tests<Tests, wchar_t>();
|
||||
#endif
|
||||
|
||||
run_numeric_ctor_tests<Tests, signed char>();
|
||||
run_numeric_ctor_tests<Tests, short int>();
|
||||
run_numeric_ctor_tests<Tests, int>();
|
||||
run_numeric_ctor_tests<Tests, long int>();
|
||||
|
||||
run_numeric_ctor_tests<Tests, unsigned char>();
|
||||
run_numeric_ctor_tests<Tests, unsigned short>();
|
||||
run_numeric_ctor_tests<Tests, unsigned int>();
|
||||
run_numeric_ctor_tests<Tests, unsigned long>();
|
||||
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
run_numeric_ctor_tests<Tests, ::boost::long_long_type>();
|
||||
run_numeric_ctor_tests<Tests, ::boost::ulong_long_type>();
|
||||
#endif
|
||||
|
||||
}
|
||||
//=====================================================================
|
||||
// Test construction from a string
|
||||
@@ -207,7 +110,7 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
// one hand I should have better tests. On the other one
|
||||
// I don't want tests for dynamic_bitset to cope with locales,
|
||||
// ctype::widen, etc. (but that's what you deserve when you
|
||||
// don't separate concerns at the library level)
|
||||
// don't separate concerns at the library level) - gps
|
||||
//
|
||||
run_string_tests<Tests>(
|
||||
std::wstring(L"11111000000111111111010101010101010101010111111"));
|
||||
@@ -220,7 +123,8 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
|
||||
}
|
||||
//=====================================================================
|
||||
// test from_block_range
|
||||
// Test construction from a block range
|
||||
// [gps - this comment is erroneous]
|
||||
{
|
||||
std::vector<Block> blocks;
|
||||
Tests::from_block_range(blocks);
|
||||
@@ -229,7 +133,7 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
std::vector<Block> blocks(3);
|
||||
blocks[0] = static_cast<Block>(0);
|
||||
blocks[1] = static_cast<Block>(1);
|
||||
blocks[2] = all_1s;
|
||||
blocks[2] = ~Block(0);
|
||||
Tests::from_block_range(blocks);
|
||||
}
|
||||
{
|
||||
@@ -269,70 +173,29 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
Tests::copy_constructor(b);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test copy assignment operator
|
||||
// Test assignment operator
|
||||
{
|
||||
bitset_type a, b;
|
||||
Tests::copy_assignment_operator(a, b);
|
||||
Tests::assignment_operator(a, b);
|
||||
}
|
||||
{
|
||||
bitset_type a(std::string("1")), b(std::string("0"));
|
||||
Tests::copy_assignment_operator(a, b);
|
||||
Tests::assignment_operator(a, b);
|
||||
}
|
||||
{
|
||||
bitset_type a(long_string), b(long_string);
|
||||
Tests::copy_assignment_operator(a, b);
|
||||
Tests::assignment_operator(a, b);
|
||||
}
|
||||
{
|
||||
bitset_type a;
|
||||
bitset_type b(long_string); // b greater than a, a empty
|
||||
Tests::copy_assignment_operator(a, b);
|
||||
Tests::assignment_operator(a, b);
|
||||
}
|
||||
{
|
||||
bitset_type a(std::string("0"));
|
||||
bitset_type b(long_string); // b greater than a
|
||||
Tests::copy_assignment_operator(a, b);
|
||||
Tests::assignment_operator(a, b);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
//=====================================================================
|
||||
// Test move constructor
|
||||
{
|
||||
boost::dynamic_bitset<Block> b;
|
||||
Tests::move_constructor(b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(std::string("0"));
|
||||
Tests::move_constructor(b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::move_constructor(b);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test move assignment operator
|
||||
{
|
||||
bitset_type a, b;
|
||||
Tests::move_assignment_operator(a, b);
|
||||
}
|
||||
{
|
||||
bitset_type a(std::string("1")), b(std::string("0"));
|
||||
Tests::move_assignment_operator(a, b);
|
||||
}
|
||||
{
|
||||
bitset_type a(long_string), b(long_string);
|
||||
Tests::move_assignment_operator(a, b);
|
||||
}
|
||||
{
|
||||
bitset_type a;
|
||||
bitset_type b(long_string); // b greater than a, a empty
|
||||
Tests::move_assignment_operator(a, b);
|
||||
}
|
||||
{
|
||||
bitset_type a(std::string("0"));
|
||||
bitset_type b(long_string); // b greater than a
|
||||
Tests::move_assignment_operator(a, b);
|
||||
}
|
||||
#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
|
||||
//=====================================================================
|
||||
// Test swap
|
||||
{
|
||||
@@ -385,25 +248,6 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
Tests::clear(a);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test pop back
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(std::string("01"));
|
||||
Tests::pop_back(a);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(std::string("10"));
|
||||
Tests::pop_back(a);
|
||||
}
|
||||
{
|
||||
const int size_to_fill_all_blocks = 4 * bits_per_block;
|
||||
boost::dynamic_bitset<Block> a(size_to_fill_all_blocks, 255ul);
|
||||
Tests::pop_back(a);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(long_string);
|
||||
Tests::pop_back(a);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test append bit
|
||||
{
|
||||
boost::dynamic_bitset<Block> a;
|
||||
@@ -461,7 +305,7 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
std::vector<Block> blocks(3);
|
||||
blocks[0] = static_cast<Block>(0);
|
||||
blocks[1] = static_cast<Block>(1);
|
||||
blocks[2] = all_1s;
|
||||
blocks[2] = ~Block(0);
|
||||
Tests::append_block_range(a, blocks);
|
||||
}
|
||||
{
|
||||
@@ -486,7 +330,7 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
std::vector<Block> blocks(3);
|
||||
blocks[0] = static_cast<Block>(0);
|
||||
blocks[1] = static_cast<Block>(1);
|
||||
blocks[2] = all_1s;
|
||||
blocks[2] = ~Block(0);
|
||||
Tests::append_block_range(a, blocks);
|
||||
}
|
||||
//=====================================================================
|
||||
@@ -509,14 +353,6 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
bit_vec[i] = long_string[n - 1 - i] == '0' ? 0 : 1;
|
||||
Tests::operator_bracket(b, bit_vec);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
|
||||
{
|
||||
typedef boost::dynamic_bitset<Block,
|
||||
minimal_allocator<Block> > Bitset;
|
||||
Bitset b;
|
||||
bitset_test<Bitset>::max_size(b);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
int
|
||||
@@ -1,8 +1,6 @@
|
||||
// -----------------------------------------------------------
|
||||
// Copyright (c) 2001 Jeremy Siek
|
||||
// Copyright (c) 2003-2006 Gennaro Prota
|
||||
// Copyright (c) 2014 Ahmed Charles
|
||||
// Copyright (c) 2018 Evgeny Shulgin
|
||||
// --------------------------------------------------------
|
||||
// (C) Copyright Jeremy Siek 2001.
|
||||
// (C) Copyright Gennaro Prota 2003 - 2004.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
@@ -10,8 +8,9 @@
|
||||
//
|
||||
// -----------------------------------------------------------
|
||||
|
||||
|
||||
#include "bitset_test.hpp"
|
||||
#include "boost/dynamic_bitset/dynamic_bitset.hpp"
|
||||
#include "boost/dynamic_bitset.hpp"
|
||||
#include "boost/config.hpp"
|
||||
|
||||
|
||||
@@ -196,51 +195,14 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
{ // case pos >= b.size()
|
||||
boost::dynamic_bitset<Block> b;
|
||||
Tests::set_one(b, 0, true);
|
||||
Tests::set_one(b, 0, false);
|
||||
}
|
||||
{ // case pos < b.size()
|
||||
boost::dynamic_bitset<Block> b(std::string("0"));
|
||||
Tests::set_one(b, 0, true);
|
||||
Tests::set_one(b, 0, false);
|
||||
}
|
||||
{ // case pos == b.size() / 2
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::set_one(b, long_string.size()/2, true);
|
||||
Tests::set_one(b, long_string.size()/2, false);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test b.set(pos, len)
|
||||
{ // case size is 1
|
||||
boost::dynamic_bitset<Block> b(std::string("0"));
|
||||
Tests::set_segment(b, 0, 1, true);
|
||||
Tests::set_segment(b, 0, 1, false);
|
||||
}
|
||||
{ // case fill the whole set
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::set_segment(b, 0, b.size(), true);
|
||||
Tests::set_segment(b, 0, b.size(), false);
|
||||
}
|
||||
{ // case pos = size / 4, len = size / 2
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::set_segment(b, b.size() / 4, b.size() / 2, true);
|
||||
Tests::set_segment(b, b.size() / 4, b.size() / 2, false);
|
||||
}
|
||||
{ // case pos = block_size / 2, len = size - block_size
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::set_segment(b, boost::dynamic_bitset<Block>::bits_per_block / 2,
|
||||
b.size() - boost::dynamic_bitset<Block>::bits_per_block, true);
|
||||
Tests::set_segment(b, boost::dynamic_bitset<Block>::bits_per_block / 2,
|
||||
b.size() - boost::dynamic_bitset<Block>::bits_per_block, false);
|
||||
}
|
||||
{ // case pos = 1, len = size - 2
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::set_segment(b, 1, b.size() - 2, true);
|
||||
Tests::set_segment(b, 1, b.size() - 2, false);
|
||||
}
|
||||
{ // case pos = 3, len = 7
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::set_segment(b, 3, 7, true);
|
||||
Tests::set_segment(b, 3, 7, false);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test b.reset()
|
||||
@@ -271,33 +233,6 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
Tests::reset_one(b, long_string.size()/2);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test b.reset(pos, len)
|
||||
{ // case size is 1
|
||||
boost::dynamic_bitset<Block> b(std::string("0"));
|
||||
Tests::reset_segment(b, 0, 1);
|
||||
}
|
||||
{ // case fill the whole set
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::reset_segment(b, 0, b.size());
|
||||
}
|
||||
{ // case pos = size / 4, len = size / 2
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::reset_segment(b, b.size() / 4, b.size() / 2);
|
||||
}
|
||||
{ // case pos = block_size / 2, len = size - block_size
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::reset_segment(b, boost::dynamic_bitset<Block>::bits_per_block / 2,
|
||||
b.size() - boost::dynamic_bitset<Block>::bits_per_block);
|
||||
}
|
||||
{ // case pos = 1, len = size - 2
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::reset_segment(b, 1, b.size() - 2);
|
||||
}
|
||||
{ // case pos = 3, len = 7
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::reset_segment(b, 3, 7);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test ~b
|
||||
{
|
||||
boost::dynamic_bitset<Block> b;
|
||||
@@ -339,33 +274,6 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::flip_one(b, long_string.size()/2);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test b.flip(pos, len)
|
||||
{ // case size is 1
|
||||
boost::dynamic_bitset<Block> b(std::string("0"));
|
||||
Tests::flip_segment(b, 0, 1);
|
||||
}
|
||||
{ // case fill the whole set
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::flip_segment(b, 0, b.size());
|
||||
}
|
||||
{ // case pos = size / 4, len = size / 2
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::flip_segment(b, b.size() / 4, b.size() / 2);
|
||||
}
|
||||
{ // case pos = block_size / 2, len = size - block_size
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::flip_segment(b, boost::dynamic_bitset<Block>::bits_per_block / 2,
|
||||
b.size() - boost::dynamic_bitset<Block>::bits_per_block);
|
||||
}
|
||||
{ // case pos = 1, len = size - 2
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::flip_segment(b, 1, b.size() - 2);
|
||||
}
|
||||
{ // case pos = 3, len = 7
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::flip_segment(b, 3, 7);
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
@@ -1,8 +1,6 @@
|
||||
// -----------------------------------------------------------
|
||||
// Copyright (c) 2001 Jeremy Siek
|
||||
// Copyright (c) 2003-2006 Gennaro Prota
|
||||
// Copyright (c) 2014 Ahmed Charles
|
||||
// Copyright (c) 2014 Riccardo Marcangelo
|
||||
// --------------------------------------------------------
|
||||
// (C) Copyright Jeremy Siek 2001.
|
||||
// (C) Copyright Gennaro Prota 2003 - 2004.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
@@ -10,16 +8,17 @@
|
||||
//
|
||||
// -----------------------------------------------------------
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "bitset_test.hpp"
|
||||
#include "boost/dynamic_bitset/dynamic_bitset.hpp"
|
||||
#include "boost/dynamic_bitset.hpp"
|
||||
#include "boost/limits.hpp"
|
||||
#include "boost/config.hpp"
|
||||
|
||||
|
||||
template <typename Block>
|
||||
void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
{
|
||||
// a bunch of typedefs which will be handy later on
|
||||
// a bunch of typedefs to have handy later on
|
||||
typedef boost::dynamic_bitset<Block> bitset_type;
|
||||
typedef bitset_test<bitset_type> Tests;
|
||||
// typedef typename bitset_type::size_type size_type; // unusable with Borland 5.5.1
|
||||
@@ -31,7 +30,7 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
// Test b.empty()
|
||||
{
|
||||
bitset_type b;
|
||||
Tests::empty(b);
|
||||
Tests::empty(b); // gps
|
||||
}
|
||||
{
|
||||
bitset_type b(1, 1ul);
|
||||
@@ -53,13 +52,9 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
Tests::to_ulong(b);
|
||||
}
|
||||
{
|
||||
Block all_ones = ~Block(0);
|
||||
boost::dynamic_bitset<Block> b(bitset_type::bits_per_block,
|
||||
static_cast<unsigned long>(-1));
|
||||
Tests::to_ulong(b);
|
||||
}
|
||||
{
|
||||
std::string str(ul_width - 1, '1');
|
||||
boost::dynamic_bitset<Block> b(str);
|
||||
static_cast<unsigned long>(all_ones));
|
||||
Tests::to_ulong(b);
|
||||
}
|
||||
{
|
||||
@@ -95,14 +90,6 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
boost::dynamic_bitset<Block> b(std::string("0"));
|
||||
Tests::count(b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(std::string("1"));
|
||||
Tests::count(b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(8, 255ul);
|
||||
Tests::count(b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::count(b);
|
||||
@@ -122,103 +109,32 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
Tests::size(b);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test b.capacity()
|
||||
{
|
||||
boost::dynamic_bitset<Block> b;
|
||||
Tests::capacity_test_one(b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(100);
|
||||
Tests::capacity_test_two(b);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test b.reserve()
|
||||
{
|
||||
boost::dynamic_bitset<Block> b;
|
||||
Tests::reserve_test_one(b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(100);
|
||||
Tests::reserve_test_two(b);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test b.shrink_to_fit()
|
||||
{
|
||||
boost::dynamic_bitset<Block> b;
|
||||
Tests::shrink_to_fit_test_one(b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(100);
|
||||
Tests::shrink_to_fit_test_two(b);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test b.all()
|
||||
{
|
||||
boost::dynamic_bitset<Block> b;
|
||||
Tests::all(b);
|
||||
Tests::all(~b);
|
||||
Tests::all(b.set());
|
||||
Tests::all(b.reset());
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(std::string("0"));
|
||||
Tests::all(b);
|
||||
Tests::all(~b);
|
||||
Tests::all(b.set());
|
||||
Tests::all(b.reset());
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::all(b);
|
||||
Tests::all(~b);
|
||||
Tests::all(b.set());
|
||||
Tests::all(b.reset());
|
||||
}
|
||||
//=====================================================================
|
||||
// Test b.any()
|
||||
{
|
||||
boost::dynamic_bitset<Block> b;
|
||||
Tests::any(b);
|
||||
Tests::any(~b);
|
||||
Tests::any(b.set());
|
||||
Tests::any(b.reset());
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(std::string("0"));
|
||||
Tests::any(b);
|
||||
Tests::any(~b);
|
||||
Tests::any(b.set());
|
||||
Tests::any(b.reset());
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::any(b);
|
||||
Tests::any(~b);
|
||||
Tests::any(b.set());
|
||||
Tests::any(b.reset());
|
||||
}
|
||||
//=====================================================================
|
||||
// Test b.none()
|
||||
{
|
||||
boost::dynamic_bitset<Block> b;
|
||||
Tests::none(b);
|
||||
Tests::none(~b);
|
||||
Tests::none(b.set());
|
||||
Tests::none(b.reset());
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(std::string("0"));
|
||||
Tests::none(b);
|
||||
Tests::none(~b);
|
||||
Tests::none(b.set());
|
||||
Tests::none(b.reset());
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::none(b);
|
||||
Tests::none(~b);
|
||||
Tests::none(b.set());
|
||||
Tests::none(b.reset());
|
||||
}
|
||||
//=====================================================================
|
||||
// Test a.is_subset_of(b)
|
||||
@@ -472,18 +388,6 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
boost::dynamic_bitset<Block> a(std::string("1")), b(std::string("1"));
|
||||
Tests::operator_less_than(a, b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(std::string("10")), b(std::string("11"));
|
||||
Tests::operator_less_than(a, b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(std::string("101")), b(std::string("11"));
|
||||
Tests::operator_less_than(a, b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(std::string("10")), b(std::string("111"));
|
||||
Tests::operator_less_than(a, b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(long_string), b(long_string);
|
||||
Tests::operator_less_than(a, b);
|
||||
@@ -498,7 +402,7 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
b[long_string.size()/2].flip();
|
||||
Tests::operator_less_than(a, b);
|
||||
}
|
||||
// check for consistency with ulong behaviour when the sizes are equal
|
||||
// check for consistency with ulong behaviour
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(3, 4ul), b(3, 5ul);
|
||||
assert(a < b);
|
||||
@@ -511,31 +415,6 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
boost::dynamic_bitset<Block> a(3, 5ul), b(3, 4ul);
|
||||
assert(!(a < b));
|
||||
}
|
||||
// when the sizes are not equal lexicographic compare does not necessarily correspond to ulong behavior
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(4, 4ul), b(3, 5ul);
|
||||
assert(a < b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(3, 4ul), b(4, 5ul);
|
||||
assert(!(a < b));
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(4, 4ul), b(3, 4ul);
|
||||
assert(a < b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(3, 4ul), b(4, 4ul);
|
||||
assert(!(a < b));
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(4, 5ul), b(3, 4ul);
|
||||
assert(a < b);
|
||||
}
|
||||
{
|
||||
boost::dynamic_bitset<Block> a(3, 5ul), b(4, 4ul);
|
||||
assert(!(a < b));
|
||||
}
|
||||
//=====================================================================
|
||||
// Test operator<=
|
||||
{
|
||||
@@ -674,23 +553,6 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
Tests::test_bit(b, long_string.size()/2);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test b.test_set(pos)
|
||||
{ // case pos >= b.size()
|
||||
boost::dynamic_bitset<Block> b;
|
||||
Tests::test_set_bit(b, 0, true);
|
||||
Tests::test_set_bit(b, 0, false);
|
||||
}
|
||||
{ // case pos < b.size()
|
||||
boost::dynamic_bitset<Block> b(std::string("0"));
|
||||
Tests::test_set_bit(b, 0, true);
|
||||
Tests::test_set_bit(b, 0, false);
|
||||
}
|
||||
{ // case pos == b.size() / 2
|
||||
boost::dynamic_bitset<Block> b(long_string);
|
||||
Tests::test_set_bit(b, long_string.size() / 2, true);
|
||||
Tests::test_set_bit(b, long_string.size() / 2, false);
|
||||
}
|
||||
//=====================================================================
|
||||
// Test b << pos
|
||||
{ // case pos == 0
|
||||
std::size_t pos = 0;
|
||||
@@ -798,7 +660,6 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
test_main(int, char*[])
|
||||
{
|
||||
@@ -1,6 +1,6 @@
|
||||
// -----------------------------------------------------------
|
||||
// Copyright (c) 2001 Jeremy Siek
|
||||
// Copyright (c) 2003-2006 Gennaro Prota
|
||||
// --------------------------------------------------------
|
||||
// (C) Copyright Jeremy Siek 2001.
|
||||
// (C) Copyright Gennaro Prota 2003 - 2004.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
@@ -10,9 +10,9 @@
|
||||
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
#include <cstddef> // for std::size_t
|
||||
#include <cstddef> // for std::size_t
|
||||
#include <stdexcept> // for std::logic_error
|
||||
#include <assert.h>
|
||||
#include <cassert>
|
||||
|
||||
#include "boost/config.hpp"
|
||||
#if !defined (BOOST_NO_STRINGSTREAM)
|
||||
@@ -20,14 +20,14 @@
|
||||
#endif
|
||||
|
||||
#include "bitset_test.hpp"
|
||||
#include "boost/dynamic_bitset/dynamic_bitset.hpp"
|
||||
#include "boost/dynamic_bitset.hpp"
|
||||
#include "boost/detail/workaround.hpp"
|
||||
|
||||
|
||||
// Codewarrior 8.3 for Win fails without this.
|
||||
// Thanks Howard Hinnant ;)
|
||||
#if defined __MWERKS__ && BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
|
||||
# pragma parse_func_templ off
|
||||
#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
|
||||
#pragma parse_func_templ off
|
||||
#endif
|
||||
|
||||
|
||||
@@ -42,15 +42,9 @@ std::wstring widen_string( const std::string & str,
|
||||
std::wstring result;
|
||||
const std::string::size_type len = str.length();
|
||||
if(len != 0) {
|
||||
|
||||
typedef std::ctype<wchar_t> ct_type;
|
||||
typedef std::wstring::traits_type tr_type;
|
||||
const ct_type & ct = BOOST_USE_FACET(ct_type, loc);
|
||||
|
||||
result.resize(len);
|
||||
for (std::size_t i = 0; i < len; ++i)
|
||||
tr_type::assign(result[i], ct.widen(str[i]));
|
||||
|
||||
BOOST_USE_FACET(std::ctype<wchar_t>, loc)
|
||||
.widen(&str[0], 1 + &str[len-1], &result[0]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
@@ -125,27 +119,26 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
}
|
||||
{
|
||||
// test 1a - file stream
|
||||
scoped_temp_file stf;
|
||||
bitset_type b(strings[si]);
|
||||
std::ofstream file(stf.path().string().c_str(), std::ios::trunc);
|
||||
std::ofstream file(test_file_name(), std::ios::trunc);
|
||||
file.width(w);
|
||||
file.fill(fill_chars[ci]);
|
||||
file.exceptions(masks[mi]);
|
||||
Tests::stream_inserter(b, file, stf.path().string().c_str());
|
||||
Tests::stream_inserter(b, file, test_file_name());
|
||||
|
||||
}
|
||||
{
|
||||
//NOTE: there are NO string stream tests
|
||||
//NOTE: there are NO string stream tests - gps
|
||||
}
|
||||
#if !defined (BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS)
|
||||
{
|
||||
// test 1b - wide file stream
|
||||
scoped_temp_file stf;
|
||||
bitset_type b(strings[si]);
|
||||
std::wofstream file(stf.path().string().c_str());
|
||||
std::wofstream file(test_file_name());
|
||||
file.width(w);
|
||||
file.fill(fill_chars[ci]);
|
||||
file.exceptions(masks[mi]);
|
||||
Tests::stream_inserter(b, file, stf.path().string().c_str());
|
||||
Tests::stream_inserter(b, file, test_file_name());
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@@ -170,18 +163,18 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
// a good "real life" test. Some characters, such as '\v' and '\f', are not
|
||||
// used exactly because they are the ones which will most likely give problems
|
||||
// on some systems (for instance '\f' could actually be written as a sequence
|
||||
// of new-lines, and we could never be able to read it back)
|
||||
// of new-lines, and we could never be able to read it back) [gps]
|
||||
//
|
||||
// Note how the bitset object is not initially empty. That helps checking
|
||||
// that it isn't erroneously clear()ed by operator>>.
|
||||
|
||||
|
||||
std::ios::iostate masks[] = {
|
||||
std::ios::goodbit,
|
||||
std::ios::eofbit,
|
||||
std::ios::failbit,
|
||||
std::ios::eofbit | std::ios::failbit
|
||||
};
|
||||
std::ios::goodbit,
|
||||
std::ios::eofbit,
|
||||
std::ios::failbit,
|
||||
std::ios::eofbit | std::ios::failbit
|
||||
};
|
||||
|
||||
const std::string spaces = "\t\n "; //"\t\n\v\f ";
|
||||
|
||||
@@ -258,14 +251,13 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
}
|
||||
// test 1a - (narrow) file stream
|
||||
{
|
||||
scoped_temp_file stf;
|
||||
bitset_type b(1, 255ul);
|
||||
{
|
||||
std::ofstream f(stf.path().string().c_str());
|
||||
std::ofstream f(test_file_name());
|
||||
f << strings[si];
|
||||
}
|
||||
|
||||
std::ifstream f(stf.path().string().c_str());
|
||||
std::ifstream f(test_file_name());
|
||||
f.width(w);
|
||||
f.exceptions(masks[mi]);
|
||||
Tests::stream_extractor(b, f, strings[si]);
|
||||
@@ -284,15 +276,14 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
#if !defined(BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS)
|
||||
// test 1b - wchar_t file stream
|
||||
{
|
||||
scoped_temp_file stf;
|
||||
std::wstring wstr = widen_string(strings[si]);
|
||||
bitset_type b(1, 255ul);
|
||||
{
|
||||
std::basic_ofstream<wchar_t> of(stf.path().string().c_str());
|
||||
std::basic_ofstream<wchar_t> of(test_file_name());
|
||||
of << wstr;
|
||||
}
|
||||
|
||||
std::basic_ifstream<wchar_t> f(stf.path().string().c_str());
|
||||
std::basic_ifstream<wchar_t> f(test_file_name());
|
||||
f.width(w);
|
||||
f.exceptions(masks[mi]);
|
||||
Tests::stream_extractor(b, f, wstr);
|
||||
1267
dynamic_bitset.html
1267
dynamic_bitset.html
File diff suppressed because it is too large
Load Diff
@@ -1,25 +0,0 @@
|
||||
# -----------------------------------------------------------
|
||||
# Copyright (c) 2002 Gennaro Prota
|
||||
#
|
||||
# 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)
|
||||
#
|
||||
# -----------------------------------------------------------
|
||||
|
||||
exe timing_tests
|
||||
: timing_tests.cpp
|
||||
;
|
||||
|
||||
exe example1
|
||||
: example1.cpp
|
||||
;
|
||||
|
||||
exe example2
|
||||
: example2.cpp
|
||||
;
|
||||
|
||||
exe example3
|
||||
: example3.cpp
|
||||
;
|
||||
|
||||
@@ -3,33 +3,23 @@
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
|
||||
// An example of setting and reading some bits. Note that operator[]
|
||||
// goes from the least-significant bit at 0 to the most significant
|
||||
// bit at size()-1. The operator<< for dynamic_bitset prints the
|
||||
// bitset from most-significant to least-significant, since that is
|
||||
// the format most people are used to reading.
|
||||
//
|
||||
// The output is:
|
||||
//
|
||||
// 11001
|
||||
// 10011
|
||||
// ---------------------------------------------------------------------
|
||||
// Sample output:
|
||||
// 1
|
||||
// 1
|
||||
// 0
|
||||
// 0
|
||||
// 1
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/dynamic_bitset.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::dynamic_bitset<> x(5); // all 0's by default
|
||||
x[0] = 1;
|
||||
x[1] = 1;
|
||||
x[4] = 1;
|
||||
for (boost::dynamic_bitset<>::size_type i = 0; i < x.size(); ++i)
|
||||
std::cout << x[i];
|
||||
std::cout << "\n";
|
||||
std::cout << x << "\n";
|
||||
|
||||
return 0;
|
||||
int main() {
|
||||
boost::dynamic_bitset<> x(5); // all 0's by default
|
||||
x[0] = 1;
|
||||
x[1] = 1;
|
||||
x[4] = 1;
|
||||
for (boost::dynamic_bitset<>::size_type i = 0; i < x.size(); ++i)
|
||||
std::cout << x[i];
|
||||
std::cout << "\n";
|
||||
std::cout << x << "\n";
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -3,30 +3,27 @@
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// Sample output:
|
||||
//
|
||||
// Sample output:
|
||||
// bits(0) = 00
|
||||
// bits(1) = 01
|
||||
// bits(2) = 10
|
||||
// bits(3) = 11
|
||||
|
||||
|
||||
#include <iostream>
|
||||
#include <boost/dynamic_bitset.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
const boost::dynamic_bitset<> b0(2, 0ul);
|
||||
const boost::dynamic_bitset<> b0(2, 0ul);
|
||||
std::cout << "bits(0) = " << b0 << std::endl;
|
||||
|
||||
const boost::dynamic_bitset<> b1(2, 1ul);
|
||||
const boost::dynamic_bitset<> b1(2, 1ul);
|
||||
std::cout << "bits(1) = " << b1 << std::endl;
|
||||
|
||||
const boost::dynamic_bitset<> b2(2, 2ul);
|
||||
const boost::dynamic_bitset<> b2(2, 2ul);
|
||||
std::cout << "bits(2) = " << b2 << std::endl;
|
||||
|
||||
const boost::dynamic_bitset<> b3(2, 3ul);
|
||||
const boost::dynamic_bitset<> b3(2, 3ul);
|
||||
std::cout << "bits(3) = " << b3 << std::endl;
|
||||
|
||||
return 0;
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -1,71 +1,35 @@
|
||||
// Copyright (c) 2001 Jeremy Siek
|
||||
// Copyright (c) 2008 Gennaro Prota
|
||||
// (C) Copyright Jeremy Siek 2001.
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// Sample run:
|
||||
//
|
||||
// mask = 101010101010
|
||||
// x.size() = 0
|
||||
// Enter a bitset in binary: x = 100100010
|
||||
//
|
||||
// Input number: 100100010
|
||||
// x.size() is now: 9
|
||||
// As unsigned long: 290
|
||||
// Mask (possibly resized): 010101010
|
||||
// And with mask: 000100010
|
||||
// Or with mask: 110101010
|
||||
// Shifted left by 1: 001000100
|
||||
// Shifted right by 1: 010010001
|
||||
// Sample output:
|
||||
// mask = 101010101010
|
||||
// Enter a 12-bit bitset in binary: 100110101101
|
||||
// x = 100110101101
|
||||
// As ulong: 2477
|
||||
// And with mask: 100010101000
|
||||
// Or with mask: 101110101111
|
||||
|
||||
|
||||
|
||||
#include "boost/dynamic_bitset.hpp"
|
||||
|
||||
#include <ostream>
|
||||
#include <iostream>
|
||||
#include <boost/dynamic_bitset.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::dynamic_bitset<> mask(12, 2730ul);
|
||||
std::cout << "mask = " << mask << std::endl;
|
||||
int main(int, char*[]) {
|
||||
const boost::dynamic_bitset<> mask(12, 2730ul);
|
||||
std::cout << "mask = " << mask << std::endl;
|
||||
|
||||
boost::dynamic_bitset<> x;
|
||||
std::cout << "x.size() = " << x.size() << std::endl;
|
||||
boost::dynamic_bitset<> x(12);
|
||||
std::cout << "x.size()=" << x.size() << std::endl;
|
||||
|
||||
std::cout << "Enter a bitset in binary: x = " << std::flush;
|
||||
if (std::cin >> x) {
|
||||
const std::size_t sz = x.size();
|
||||
std::cout << std::endl;
|
||||
std::cout << "Input number: " << x << std::endl;
|
||||
std::cout << "x.size() is now: " << sz << std::endl;
|
||||
|
||||
bool fits_in_ulong = true;
|
||||
unsigned long ul = 0;
|
||||
try {
|
||||
ul = x.to_ulong();
|
||||
} catch(std::overflow_error &) {
|
||||
fits_in_ulong = false;
|
||||
}
|
||||
|
||||
std::cout << "As unsigned long: ";
|
||||
if(fits_in_ulong) {
|
||||
std::cout << ul;
|
||||
} else {
|
||||
std::cout << "(overflow exception)";
|
||||
}
|
||||
|
||||
std::cout << std::endl;
|
||||
|
||||
mask.resize(sz);
|
||||
|
||||
std::cout << "Mask (possibly resized): " << mask << std::endl;
|
||||
|
||||
std::cout << "And with mask: " << (x & mask) << std::endl;
|
||||
std::cout << "Or with mask: " << (x | mask) << std::endl;
|
||||
std::cout << "Shifted left by 1: " << (x << 1) << std::endl;
|
||||
std::cout << "Shifted right by 1: " << (x >> 1) << std::endl;
|
||||
}
|
||||
return 0;
|
||||
std::cout << "Enter a 12-bit bitset in binary: " << std::flush;
|
||||
if (std::cin >> x) {
|
||||
std::cout << "input number: " << x << std::endl;
|
||||
std::cout << "As unsigned long: " << x.to_ulong() << std::endl;
|
||||
std::cout << "And with mask: " << (x & mask) << std::endl;
|
||||
std::cout << "Or with mask: " << (x | mask) << std::endl;
|
||||
std::cout << "Shifted left: " << (x << 1) << std::endl;
|
||||
std::cout << "Shifted right: " << (x >> 1) << std::endl;
|
||||
}
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
// -----------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 2003-2004 Gennaro Prota
|
||||
// boost::dynamic_bitset timing tests
|
||||
|
||||
// (C) Copyright Gennaro Prota 2003 - 2004.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
@@ -8,8 +9,6 @@
|
||||
//
|
||||
// -----------------------------------------------------------
|
||||
|
||||
// boost::dynamic_bitset timing tests
|
||||
//
|
||||
// NOTE:
|
||||
// ~~~~~
|
||||
// This is a preliminary, incomplete version.
|
||||
@@ -23,15 +22,10 @@
|
||||
// table in detail/dynamic_bitset.hpp and report any interesting
|
||||
// discovery on the list as well.
|
||||
|
||||
// You might also want to try both counting methods (by_bytes vs.
|
||||
// by_blocks) to see if the one that is selected automatically is
|
||||
// actually the fastest on your system.
|
||||
|
||||
//
|
||||
//
|
||||
// -----------------------------------------------------------------------//
|
||||
|
||||
|
||||
#include "boost/config.hpp"
|
||||
|
||||
#if defined (__STL_CONFIG_H) && !defined (__STL_USE_NEW_IOSTREAMS)
|
||||
@@ -59,9 +53,9 @@ namespace {
|
||||
// see http://gcc.gnu.org/ml/gcc-bugs/1999-03n/msg00884.html
|
||||
//
|
||||
class boost_version {
|
||||
int m_major;
|
||||
int m_minor;
|
||||
int m_subminor;
|
||||
const int m_major;
|
||||
const int m_minor;
|
||||
const int m_subminor;
|
||||
|
||||
public:
|
||||
boost_version(unsigned long v = BOOST_VERSION):
|
||||
@@ -95,11 +89,11 @@ template <typename T>
|
||||
void timing_test(T* = 0) // dummy parameter to workaround VC6
|
||||
{
|
||||
|
||||
const unsigned long num = 30 * 100000;
|
||||
const unsigned long num = 100000;
|
||||
|
||||
|
||||
// This variable is printed at the end of the test,
|
||||
// to prevent the optimizer from removing the call to
|
||||
// to prevent the optimizer eliminating the call to
|
||||
// count() in the loop below.
|
||||
typename boost::dynamic_bitset<T>::size_type dummy = 0;
|
||||
|
||||
@@ -127,6 +121,7 @@ void timing_test(T* = 0) // dummy parameter to workaround VC6
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
prologue();
|
||||
|
||||
timing_test<unsigned char>();
|
||||
|
||||
168
include/boost/detail/dynamic_bitset.hpp
Normal file
168
include/boost/detail/dynamic_bitset.hpp
Normal file
@@ -0,0 +1,168 @@
|
||||
// --------------------------------------------------
|
||||
//
|
||||
// (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002.
|
||||
// (C) Copyright Gennaro Prota 2003 - 2004.
|
||||
//
|
||||
// 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 http://www.boost.org/libs/dynamic_bitset for documentation.
|
||||
|
||||
|
||||
#ifndef BOOST_DETAIL_DYNAMIC_BITSET_HPP
|
||||
#define BOOST_DETAIL_DYNAMIC_BITSET_HPP
|
||||
|
||||
#include <cstddef> // for std::size_t
|
||||
#include "boost/config.hpp"
|
||||
#include "boost/detail/workaround.hpp"
|
||||
//#include "boost/static_assert.hpp" // gps
|
||||
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace detail {
|
||||
|
||||
// Gives (read-)access to the object representation
|
||||
// of an object of type T (3.9p4). CANNOT be used
|
||||
// on a base sub-object
|
||||
//
|
||||
template <typename T>
|
||||
inline const unsigned char * object_representation (T* p)
|
||||
{
|
||||
return static_cast<const unsigned char *>(static_cast<const void *>(p));
|
||||
}
|
||||
|
||||
|
||||
// ------- count function implementation --------------
|
||||
|
||||
namespace dynamic_bitset_count_impl {
|
||||
|
||||
typedef unsigned char byte_type;
|
||||
|
||||
enum mode { access_by_bytes, access_by_blocks };
|
||||
|
||||
template <mode> struct mode_to_type {};
|
||||
|
||||
// the table: wrapped in a class template, so
|
||||
// that it is only instantiated if/when needed
|
||||
//
|
||||
template <bool dummy_name = true>
|
||||
struct count_table { static const byte_type table[]; };
|
||||
|
||||
template <>
|
||||
struct count_table<false> { /* no table */ };
|
||||
|
||||
|
||||
const unsigned int table_width = 8;
|
||||
template <bool b>
|
||||
const byte_type count_table<b>::table[] =
|
||||
{
|
||||
// Automatically generated by GPTableGen.exe v.1.0
|
||||
//
|
||||
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
|
||||
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
||||
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
||||
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
||||
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
||||
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
||||
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
||||
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
|
||||
};
|
||||
|
||||
|
||||
// overload for access by bytes
|
||||
//
|
||||
|
||||
template <typename Iterator>
|
||||
inline std::size_t do_count(Iterator first, std::size_t length,
|
||||
int /*dummy param*/,
|
||||
mode_to_type<access_by_bytes>* )
|
||||
{
|
||||
std::size_t num = 0;
|
||||
if (length)
|
||||
{
|
||||
const byte_type * p = object_representation(&*first);
|
||||
length *= sizeof(*first);
|
||||
|
||||
do {
|
||||
num += count_table<>::table[*p];
|
||||
++p;
|
||||
--length;
|
||||
|
||||
} while (length);
|
||||
}
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
|
||||
// overload for access by blocks
|
||||
//
|
||||
template <typename Iterator, typename ValueType>
|
||||
inline std::size_t do_count(Iterator first, std::size_t length, ValueType,
|
||||
mode_to_type<access_by_blocks>*)
|
||||
{
|
||||
std::size_t num = 0;
|
||||
while (length){
|
||||
|
||||
ValueType value = *first;
|
||||
while (value) {
|
||||
num += count_table<>::table[value & ((1u<<table_width) - 1)];
|
||||
value >>= table_width;
|
||||
}
|
||||
|
||||
++first;
|
||||
--length;
|
||||
}
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
|
||||
} // dynamic_bitset_count_impl
|
||||
// -------------------------------------------------------
|
||||
|
||||
|
||||
// Some library implementations simply return a dummy
|
||||
// value such as
|
||||
//
|
||||
// size_type(-1) / sizeof(T)
|
||||
//
|
||||
// from vector<>::max_size. This tries to get out more
|
||||
// meaningful info.
|
||||
//
|
||||
template <typename T>
|
||||
typename T::size_type vector_max_size_workaround(const T & v) {
|
||||
|
||||
typedef typename T::allocator_type allocator_type;
|
||||
|
||||
const typename allocator_type::size_type alloc_max =
|
||||
v.get_allocator().max_size();
|
||||
const typename T::size_type container_max = v.max_size();
|
||||
|
||||
return alloc_max < container_max?
|
||||
alloc_max :
|
||||
container_max;
|
||||
}
|
||||
|
||||
// for static_asserts
|
||||
template <typename T>
|
||||
struct dynamic_bitset_allowed_block_type {
|
||||
enum { value = (T(-1) > 0) }; // ensure T has no sign
|
||||
};
|
||||
|
||||
template <>
|
||||
struct dynamic_bitset_allowed_block_type<bool> {
|
||||
enum { value = false };
|
||||
};
|
||||
|
||||
|
||||
} // namespace detail
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // include guard
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
// -----------------------------------------------------------
|
||||
// --------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek
|
||||
// Copyright (c) 2003-2004, 2008 Gennaro Prota
|
||||
// (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002.
|
||||
// (C) Copyright Gennaro Prota 2003 - 2004.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
@@ -9,6 +9,8 @@
|
||||
//
|
||||
// -----------------------------------------------------------
|
||||
|
||||
// See http://www.boost.org/libs/dynamic_bitset for documentation.
|
||||
|
||||
#ifndef BOOST_DYNAMIC_BITSET_HPP
|
||||
#define BOOST_DYNAMIC_BITSET_HPP
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
// -----------------------------------------------------------
|
||||
// --------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek
|
||||
// Copyright (c) 2003-2006, 2008 Gennaro Prota
|
||||
// (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002.
|
||||
// (C) Copyright Gennaro Prota 2003 - 2004.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
@@ -9,6 +9,9 @@
|
||||
//
|
||||
// -----------------------------------------------------------
|
||||
|
||||
// See http://www.boost.org/libs/dynamic_bitset for documentation.
|
||||
|
||||
|
||||
#ifndef BOOST_DYNAMIC_BITSET_CONFIG_HPP_GP_20040424
|
||||
#define BOOST_DYNAMIC_BITSET_CONFIG_HPP_GP_20040424
|
||||
|
||||
@@ -20,13 +23,19 @@
|
||||
# define BOOST_OLD_IOSTREAMS
|
||||
#endif
|
||||
|
||||
// no-op function to workaround gcc bug c++/8419
|
||||
//
|
||||
// this should be in the config system some day
|
||||
// see http://lists.boost.org/MailArchives/boost/msg62291.php
|
||||
#define BOOST_DYNAMIC_BITSET_GNUC_VERSION ( __GNUC__ * 100 * 100 \
|
||||
+ __GNUC_MINOR__ * 100)
|
||||
|
||||
// workaround for gcc bug c++/8419 - gps
|
||||
|
||||
namespace boost { namespace detail {
|
||||
template <typename T> T make_non_const(T t) { return t; }
|
||||
}}
|
||||
|
||||
#if defined(__GNUC__)
|
||||
#if defined(__GNUC__) && BOOST_WORKAROUND(BOOST_DYNAMIC_BITSET_GNUC_VERSION, \
|
||||
BOOST_TESTED_AT(30300))
|
||||
# define BOOST_DYNAMIC_BITSET_WRAP_CONSTANT(expr) \
|
||||
(boost::detail::make_non_const(expr))
|
||||
#else
|
||||
@@ -39,7 +48,7 @@ namespace boost { namespace detail {
|
||||
#define BOOST_DYNAMIC_BITSET_DONT_USE_FRIENDS
|
||||
#endif
|
||||
|
||||
// if we can't use friends then we simply expose private members
|
||||
// if we can't use friends then private members are exposed
|
||||
//
|
||||
#if defined(BOOST_DYNAMIC_BITSET_DONT_USE_FRIENDS)
|
||||
#define BOOST_DYNAMIC_BITSET_PRIVATE public
|
||||
|
||||
@@ -1,293 +0,0 @@
|
||||
// -----------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek
|
||||
// Copyright (c) 2003-2006, 2008 Gennaro Prota
|
||||
// Copyright (c) 2014 Glen Joseph Fernandes
|
||||
// (glenjofe@gmail.com)
|
||||
// Copyright (c) 2018 Evgeny Shulgin
|
||||
//
|
||||
// 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_DETAIL_DYNAMIC_BITSET_HPP
|
||||
#define BOOST_DETAIL_DYNAMIC_BITSET_HPP
|
||||
|
||||
#include <memory>
|
||||
#include <cstddef>
|
||||
#include "boost/config.hpp"
|
||||
#include "boost/detail/workaround.hpp"
|
||||
|
||||
#if ((defined(BOOST_MSVC) && (BOOST_MSVC >= 1600)) || (defined(__clang__) && defined(__c2__)) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && (defined(_M_IX86) || defined(_M_X64))
|
||||
#include <intrin.h>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace detail {
|
||||
namespace dynamic_bitset_impl {
|
||||
|
||||
// Gives (read-)access to the object representation
|
||||
// of an object of type T (3.9p4). CANNOT be used
|
||||
// on a base sub-object
|
||||
//
|
||||
template <typename T>
|
||||
inline const unsigned char * object_representation (T* p)
|
||||
{
|
||||
return static_cast<const unsigned char *>(static_cast<const void *>(p));
|
||||
}
|
||||
|
||||
template<typename T, int amount, int width /* = default */>
|
||||
struct shifter
|
||||
{
|
||||
static void left_shift(T & v) {
|
||||
amount >= width ? (v = 0)
|
||||
: (v >>= BOOST_DYNAMIC_BITSET_WRAP_CONSTANT(amount));
|
||||
}
|
||||
};
|
||||
|
||||
// ------- count function implementation --------------
|
||||
|
||||
typedef unsigned char byte_type;
|
||||
|
||||
// These two entities
|
||||
//
|
||||
// enum mode { access_by_bytes, access_by_blocks };
|
||||
// template <mode> struct mode_to_type {};
|
||||
//
|
||||
// were removed, since the regression logs (as of 24 Aug 2008)
|
||||
// showed that several compilers had troubles with recognizing
|
||||
//
|
||||
// const mode m = access_by_bytes
|
||||
//
|
||||
// as a constant expression
|
||||
//
|
||||
// * So, we'll use bool, instead of enum *.
|
||||
//
|
||||
template <bool value>
|
||||
struct value_to_type
|
||||
{
|
||||
value_to_type() {}
|
||||
};
|
||||
const bool access_by_bytes = true;
|
||||
const bool access_by_blocks = false;
|
||||
|
||||
|
||||
// the table: wrapped in a class template, so
|
||||
// that it is only instantiated if/when needed
|
||||
//
|
||||
template <bool dummy_name = true>
|
||||
struct count_table { static const byte_type table[]; };
|
||||
|
||||
template <>
|
||||
struct count_table<false> { /* no table */ };
|
||||
|
||||
|
||||
const unsigned int table_width = 8;
|
||||
template <bool b>
|
||||
const byte_type count_table<b>::table[] =
|
||||
{
|
||||
// Automatically generated by GPTableGen.exe v.1.0
|
||||
//
|
||||
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
|
||||
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
||||
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
||||
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
||||
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
|
||||
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
||||
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
|
||||
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
|
||||
};
|
||||
|
||||
|
||||
// overload for access by bytes
|
||||
//
|
||||
|
||||
template <typename Iterator>
|
||||
inline std::size_t do_count(Iterator first, std::size_t length,
|
||||
int /*dummy param*/,
|
||||
value_to_type<access_by_bytes>* )
|
||||
{
|
||||
std::size_t num = 0;
|
||||
if (length)
|
||||
{
|
||||
const byte_type * p = object_representation(&*first);
|
||||
length *= sizeof(*first);
|
||||
|
||||
do {
|
||||
num += count_table<>::table[*p];
|
||||
++p;
|
||||
--length;
|
||||
|
||||
} while (length);
|
||||
}
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
|
||||
// Some platforms have fast popcount operation, that allow us to implement
|
||||
// counting bits much more efficiently
|
||||
//
|
||||
template <typename ValueType>
|
||||
BOOST_FORCEINLINE std::size_t popcount(ValueType value) BOOST_NOEXCEPT
|
||||
{
|
||||
std::size_t num = 0;
|
||||
while (value) {
|
||||
num += count_table<>::table[value & ((1u<<table_width) - 1)];
|
||||
value >>= table_width;
|
||||
}
|
||||
return num;
|
||||
}
|
||||
|
||||
#if ((defined(BOOST_MSVC) && (BOOST_MSVC >= 1600)) || (defined(__clang__) && defined(__c2__)) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && (defined(_M_IX86) || defined(_M_X64))
|
||||
template <>
|
||||
BOOST_FORCEINLINE std::size_t popcount<unsigned short>(unsigned short value) BOOST_NOEXCEPT
|
||||
{
|
||||
return static_cast<std::size_t>(__popcnt16(value));
|
||||
}
|
||||
|
||||
template <>
|
||||
BOOST_FORCEINLINE std::size_t popcount<unsigned int>(unsigned int value) BOOST_NOEXCEPT
|
||||
{
|
||||
return static_cast<std::size_t>(__popcnt(value));
|
||||
}
|
||||
|
||||
#ifdef _M_X64
|
||||
template <>
|
||||
BOOST_FORCEINLINE std::size_t popcount<unsigned __int64>(unsigned __int64 value) BOOST_NOEXCEPT
|
||||
{
|
||||
return static_cast<std::size_t>(__popcnt64(value));
|
||||
}
|
||||
#endif
|
||||
|
||||
#elif defined(BOOST_GCC) || defined(__clang__) || (defined(BOOST_INTEL) && defined(__GNUC__))
|
||||
template <>
|
||||
BOOST_FORCEINLINE std::size_t popcount<unsigned int>(unsigned int value) BOOST_NOEXCEPT
|
||||
{
|
||||
return __builtin_popcount(value);
|
||||
}
|
||||
|
||||
template <>
|
||||
BOOST_FORCEINLINE std::size_t popcount<unsigned long>(unsigned long value) BOOST_NOEXCEPT
|
||||
{
|
||||
return __builtin_popcountl(value);
|
||||
}
|
||||
|
||||
template <>
|
||||
BOOST_FORCEINLINE std::size_t popcount<boost::ulong_long_type>(boost::ulong_long_type value) BOOST_NOEXCEPT
|
||||
{
|
||||
return __builtin_popcountll(value);
|
||||
}
|
||||
#endif
|
||||
|
||||
// overload for access by blocks
|
||||
//
|
||||
template <typename Iterator, typename ValueType>
|
||||
inline std::size_t do_count(Iterator first, std::size_t length, ValueType,
|
||||
value_to_type<access_by_blocks>*)
|
||||
{
|
||||
std::size_t num = 0;
|
||||
while (length){
|
||||
num += popcount<ValueType>(*first);
|
||||
++first;
|
||||
--length;
|
||||
}
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
// -------------------------------------------------------
|
||||
|
||||
|
||||
// Some library implementations simply return a dummy
|
||||
// value such as
|
||||
//
|
||||
// size_type(-1) / sizeof(T)
|
||||
//
|
||||
// from vector<>::max_size. This tries to get more
|
||||
// meaningful info.
|
||||
//
|
||||
template <typename T>
|
||||
inline typename T::size_type vector_max_size_workaround(const T & v)
|
||||
BOOST_NOEXCEPT
|
||||
{
|
||||
typedef typename T::allocator_type allocator_type;
|
||||
|
||||
const allocator_type& alloc = v.get_allocator();
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
|
||||
typedef std::allocator_traits<allocator_type> allocator_traits;
|
||||
|
||||
const typename allocator_traits::size_type alloc_max =
|
||||
allocator_traits::max_size(alloc);
|
||||
#else
|
||||
const typename allocator_type::size_type alloc_max = alloc.max_size();
|
||||
#endif
|
||||
|
||||
const typename T::size_type container_max = v.max_size();
|
||||
|
||||
return alloc_max < container_max ? alloc_max : container_max;
|
||||
}
|
||||
|
||||
// for static_asserts
|
||||
template <typename T>
|
||||
struct allowed_block_type {
|
||||
enum { value = T(-1) > 0 }; // ensure T has no sign
|
||||
};
|
||||
|
||||
template <>
|
||||
struct allowed_block_type<bool> {
|
||||
enum { value = false };
|
||||
};
|
||||
|
||||
|
||||
template <typename T>
|
||||
struct is_numeric {
|
||||
enum { value = false };
|
||||
};
|
||||
|
||||
# define BOOST_dynamic_bitset_is_numeric(x) \
|
||||
template<> \
|
||||
struct is_numeric< x > { \
|
||||
enum { value = true }; \
|
||||
} /**/
|
||||
|
||||
BOOST_dynamic_bitset_is_numeric(bool);
|
||||
BOOST_dynamic_bitset_is_numeric(char);
|
||||
|
||||
#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
||||
BOOST_dynamic_bitset_is_numeric(wchar_t);
|
||||
#endif
|
||||
|
||||
BOOST_dynamic_bitset_is_numeric(signed char);
|
||||
BOOST_dynamic_bitset_is_numeric(short int);
|
||||
BOOST_dynamic_bitset_is_numeric(int);
|
||||
BOOST_dynamic_bitset_is_numeric(long int);
|
||||
|
||||
BOOST_dynamic_bitset_is_numeric(unsigned char);
|
||||
BOOST_dynamic_bitset_is_numeric(unsigned short);
|
||||
BOOST_dynamic_bitset_is_numeric(unsigned int);
|
||||
BOOST_dynamic_bitset_is_numeric(unsigned long);
|
||||
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
BOOST_dynamic_bitset_is_numeric(::boost::long_long_type);
|
||||
BOOST_dynamic_bitset_is_numeric(::boost::ulong_long_type);
|
||||
#endif
|
||||
|
||||
// intentionally omitted
|
||||
//BOOST_dynamic_bitset_is_numeric(float);
|
||||
//BOOST_dynamic_bitset_is_numeric(double);
|
||||
//BOOST_dynamic_bitset_is_numeric(long double);
|
||||
|
||||
#undef BOOST_dynamic_bitset_is_numeric
|
||||
|
||||
} // dynamic_bitset_impl
|
||||
} // namespace detail
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // include guard
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,46 +0,0 @@
|
||||
// -----------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 2015 Seth Heeren
|
||||
//
|
||||
// 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_DYNAMIC_BITSET_SERIALIZATION_HPP
|
||||
#define BOOST_DYNAMIC_BITSET_SERIALIZATION_HPP
|
||||
|
||||
#include "boost/dynamic_bitset/dynamic_bitset.hpp"
|
||||
#include <boost/serialization/vector.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
// implementation for optional zero-copy serialization support
|
||||
template <typename Block, typename Allocator>
|
||||
class dynamic_bitset<Block, Allocator>::serialize_impl
|
||||
{
|
||||
public:
|
||||
template <typename Ar>
|
||||
static void serialize(Ar& ar, dynamic_bitset<Block, Allocator>& bs, unsigned) {
|
||||
ar & serialization::make_nvp("m_num_bits", bs.m_num_bits)
|
||||
& serialization::make_nvp("m_bits", bs.m_bits);
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
// ADL hook to Boost Serialization library
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
|
||||
template <typename Ar, typename Block, typename Allocator>
|
||||
void serialize(Ar& ar, dynamic_bitset<Block, Allocator>& bs, unsigned version) {
|
||||
dynamic_bitset<Block, Allocator>::serialize_impl::serialize(ar, bs, version);
|
||||
}
|
||||
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
|
||||
#endif // include guard
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
// -----------------------------------------------------------
|
||||
// --------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek
|
||||
// Copyright (c) 2003-2004 Gennaro Prota
|
||||
// (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002.
|
||||
// (C) Copyright Gennaro Prota 2003 - 2004.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
@@ -9,6 +9,9 @@
|
||||
//
|
||||
// -----------------------------------------------------------
|
||||
|
||||
// See http://www.boost.org/libs/dynamic_bitset for documentation.
|
||||
|
||||
|
||||
#ifndef BOOST_DYNAMIC_BITSET_FWD_HPP
|
||||
#define BOOST_DYNAMIC_BITSET_FWD_HPP
|
||||
|
||||
@@ -20,6 +23,6 @@ template <typename Block = unsigned long,
|
||||
typename Allocator = std::allocator<Block> >
|
||||
class dynamic_bitset;
|
||||
|
||||
}
|
||||
} // namespace boost
|
||||
|
||||
#endif // include guard
|
||||
|
||||
@@ -1,29 +1,29 @@
|
||||
// -----------------------------------------------------------
|
||||
// -------------------------------------
|
||||
// lowest_bit.hpp
|
||||
//
|
||||
// Position of the lowest bit 'on'
|
||||
//
|
||||
// Copyright (c) 2003-2004, 2008 Gennaro Prota
|
||||
// (C) Copyright Gennaro Prota 2003 - 2004.
|
||||
//
|
||||
// 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_LOWEST_BIT_HPP_GP_20030301
|
||||
#define BOOST_LOWEST_BIT_HPP_GP_20030301
|
||||
|
||||
#include "boost/integer/integer_log2.hpp"
|
||||
#include "boost/assert.hpp"
|
||||
#include <cassert>
|
||||
#include "boost/pending/integer_log2.hpp"
|
||||
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
|
||||
template <typename T>
|
||||
int lowest_bit(T x) {
|
||||
|
||||
BOOST_ASSERT(x >= 1); // PRE
|
||||
assert(x >= 1); // PRE
|
||||
|
||||
// clear all bits on except the rightmost one,
|
||||
// then calculate the logarithm base 2
|
||||
@@ -32,7 +32,7 @@ namespace detail {
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
39
index.html
39
index.html
@@ -1,15 +1,24 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv=refresh content="0; URL=dynamic_bitset.html">
|
||||
<title>Automatic redirection</title>
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="dynamic_bitset.html">dynamic_bitset.html</a>. <hr>
|
||||
<p>© Copyright Beman Dawes, 2001</p>
|
||||
<p>Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy
|
||||
at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
|
||||
</body>
|
||||
</html>
|
||||
<!--
|
||||
Copyright Beman Dawes 2002
|
||||
Copyright Gennaro Prota 2006
|
||||
|
||||
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)
|
||||
|
||||
-->
|
||||
|
||||
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml">
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=dynamic_bitset.html" />
|
||||
<title></title>
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to <a href=
|
||||
"dynamic_bitset.html">dynamic_bitset.html</a>.
|
||||
</body>
|
||||
|
||||
</html>
|
||||
|
||||
@@ -1,16 +0,0 @@
|
||||
{
|
||||
"key": "dynamic_bitset",
|
||||
"name": "Dynamic Bitset",
|
||||
"authors": [
|
||||
"Jeremy Siek",
|
||||
"Chuck Allison"
|
||||
],
|
||||
"description": "The dynamic_bitset class represents a set of bits. It provides accesses to the value of individual bits via an operator[] and provides all of the bitwise operators that one can apply to builtin integers, such as operator& and operator<<. The number of bits in the set is specified at runtime via a parameter to the constructor of the dynamic_bitset.",
|
||||
"documentation": "dynamic_bitset.html",
|
||||
"category": [
|
||||
"Containers"
|
||||
],
|
||||
"maintainers": [
|
||||
"Jeremy Siek <jeremy.siek -at- gmail.com>"
|
||||
]
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
#
|
||||
# Copyright Vladimir Prus 2004
|
||||
#
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt)
|
||||
#
|
||||
|
||||
import os ;
|
||||
|
||||
test-suite dynamic_bitset :
|
||||
|
||||
[ run dyn_bitset_unit_tests1.cpp : : : <library>/boost/system//boost_system ]
|
||||
[ run dyn_bitset_unit_tests2.cpp : : : <library>/boost/system//boost_system ]
|
||||
[ run dyn_bitset_unit_tests3.cpp : : : <library>/boost/system//boost_system ]
|
||||
[ run dyn_bitset_unit_tests4.cpp : : : <library>/boost/filesystem//boost_filesystem
|
||||
<library>/boost/system//boost_system ]
|
||||
[ run test_ambiguous_set.cpp ]
|
||||
[ run test_lowest_bit.cpp ]
|
||||
;
|
||||
|
||||
# due to https://github.com/boostorg/serialization/issues/108
|
||||
if ! [ os.environ UBSAN_OPTIONS ]
|
||||
{
|
||||
test-suite dynamic_bitset_serialization :
|
||||
|
||||
[ run dyn_bitset_unit_tests5.cpp
|
||||
: : : <define>_SCL_SECURE_NO_WARNINGS=1
|
||||
<library>/boost/serialization//boost_serialization
|
||||
<library>/boost/system//boost_system ]
|
||||
;
|
||||
}
|
||||
@@ -1,111 +0,0 @@
|
||||
// -----------------------------------------------------------
|
||||
// Copyright (c) 2001 Jeremy Siek
|
||||
// Copyright (c) 2003-2006 Gennaro Prota
|
||||
//
|
||||
// Copyright (c) 2015 Seth Heeren
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// -----------------------------------------------------------
|
||||
|
||||
#include "boost/config.hpp"
|
||||
#if !defined (BOOST_NO_STRINGSTREAM)
|
||||
# include <sstream>
|
||||
#endif
|
||||
|
||||
#include "bitset_test.hpp"
|
||||
#include "boost/dynamic_bitset/serialization.hpp"
|
||||
#include "boost/detail/workaround.hpp"
|
||||
|
||||
|
||||
// Codewarrior 8.3 for Win fails without this.
|
||||
// Thanks Howard Hinnant ;)
|
||||
#if defined __MWERKS__ && BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
|
||||
# pragma parse_func_templ off
|
||||
#endif
|
||||
|
||||
|
||||
#if defined BOOST_NO_STD_WSTRING || defined BOOST_NO_STD_LOCALE
|
||||
# define BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS
|
||||
#endif
|
||||
|
||||
#include <boost/archive/binary_oarchive.hpp>
|
||||
#include <boost/archive/binary_iarchive.hpp>
|
||||
#include <boost/archive/xml_oarchive.hpp>
|
||||
#include <boost/archive/xml_iarchive.hpp>
|
||||
#include <sstream>
|
||||
|
||||
namespace {
|
||||
template <typename Block>
|
||||
struct SerializableType {
|
||||
boost::dynamic_bitset<Block> x;
|
||||
|
||||
private:
|
||||
friend class boost::serialization::access;
|
||||
template <class Archive> void serialize(Archive &ar, const unsigned int) {
|
||||
ar & BOOST_SERIALIZATION_NVP(x);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Block, typename IArchive, typename OArchive>
|
||||
void test_serialization( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
{
|
||||
SerializableType<Block> a;
|
||||
|
||||
for (int i=0; i<128; ++i)
|
||||
a.x.resize(11*i, i%2);
|
||||
|
||||
#if !defined (BOOST_NO_STRINGSTREAM)
|
||||
std::stringstream ss;
|
||||
|
||||
// test serialization
|
||||
{
|
||||
OArchive oa(ss);
|
||||
oa << BOOST_SERIALIZATION_NVP(a);
|
||||
}
|
||||
|
||||
// test de-serialization
|
||||
{
|
||||
IArchive ia(ss);
|
||||
SerializableType<Block> b;
|
||||
ia >> BOOST_SERIALIZATION_NVP(b);
|
||||
|
||||
assert(a.x == b.x);
|
||||
}
|
||||
#else
|
||||
# error "TODO implement file-based test path?"
|
||||
#endif
|
||||
}
|
||||
|
||||
template <typename Block>
|
||||
void test_binary_archive( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) {
|
||||
test_serialization<Block, boost::archive::binary_iarchive, boost::archive::binary_oarchive>();
|
||||
}
|
||||
|
||||
template <typename Block>
|
||||
void test_xml_archive( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) {
|
||||
test_serialization<Block, boost::archive::xml_iarchive, boost::archive::xml_oarchive>();
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Block>
|
||||
void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
|
||||
{
|
||||
test_binary_archive<Block>();
|
||||
test_xml_archive<Block>();
|
||||
}
|
||||
|
||||
int test_main(int, char*[])
|
||||
{
|
||||
run_test_cases<unsigned char>();
|
||||
run_test_cases<unsigned short>();
|
||||
run_test_cases<unsigned int>();
|
||||
run_test_cases<unsigned long>();
|
||||
# ifdef BOOST_HAS_LONG_LONG
|
||||
run_test_cases< ::boost::ulong_long_type>();
|
||||
# endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
//
|
||||
// Copyright (C) 2018 James E. King III
|
||||
//
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/dynamic_bitset.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
boost::dynamic_bitset<> x(5); // all 0's by default
|
||||
x.set(1, 2);
|
||||
x.set(3, 1, true);
|
||||
x.set(2, 1, false);
|
||||
BOOST_TEST(!x.test(0));
|
||||
BOOST_TEST( x.test(1));
|
||||
BOOST_TEST(!x.test(2));
|
||||
BOOST_TEST( x.test(3));
|
||||
BOOST_TEST(!x.test(4));
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
//
|
||||
// Copyright (C) 2018 James E. King III
|
||||
//
|
||||
// Permission to copy, use, modify, sell and distribute this software
|
||||
// is granted provided this copyright notice appears in all copies.
|
||||
// This software is provided "as is" without express or implied
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/dynamic_bitset/detail/lowest_bit.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
for (boost::int32_t i = 1; i < 32; ++i) {
|
||||
BOOST_TEST_EQ(i, boost::detail::lowest_bit(1u << i));
|
||||
}
|
||||
|
||||
BOOST_TEST_EQ(2, boost::detail::lowest_bit(123456788));
|
||||
BOOST_TEST_EQ(30, boost::detail::lowest_bit(static_cast<boost::int64_t>(1507208177123328)));
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
Reference in New Issue
Block a user