forked from boostorg/iterator
Compare commits
127 Commits
boost-1.65
...
boost-1.75
Author | SHA1 | Date | |
---|---|---|---|
8e457e716b | |||
32f4f4d086 | |||
72f0ebe8d0 | |||
d7ad43a925 | |||
733c0fb9cb | |||
5b18ae976e | |||
da8604615e | |||
8fc94469da | |||
b86c817481 | |||
9649d42392 | |||
0c5f0b822a | |||
dc7bf5cc05 | |||
80ec58bb3b | |||
c2929ea6c6 | |||
4fe679bb0d | |||
fdcd8439c0 | |||
3a8728a595 | |||
897ff65fdc | |||
bfe2a004d2 | |||
d528fc0b11 | |||
540f999d0b | |||
54dee0db96 | |||
814965402e | |||
2af5a16539 | |||
171c716d03 | |||
398fe907d0 | |||
e31ae13df5 | |||
02e74bf26a | |||
20b5a9c11a | |||
73918b8616 | |||
bb1efd3370 | |||
3cc4107d01 | |||
6ab148be01 | |||
06875a754d | |||
b844c8df53 | |||
194087e8ca | |||
b5edc8b64f | |||
44cee00831 | |||
b2adecb951 | |||
e16f2de233 | |||
218dc4baf1 | |||
0013c5c4f0 | |||
386dbf1054 | |||
486721bbfe | |||
5ad48c4d14 | |||
adecfd94f3 | |||
affe7e6d84 | |||
91b392a478 | |||
84227ea6ba | |||
67ac957273 | |||
f86cd29f52 | |||
fff85e7db9 | |||
d6c6f0ce16 | |||
81faa161cf | |||
7e5a32b3ea | |||
1b388c2496 | |||
30b93d7428 | |||
28b8cc8c9c | |||
992a314211 | |||
422ad12716 | |||
b2585dda6a | |||
8b5e92a0c4 | |||
a36ed0f35d | |||
0a08203107 | |||
38ef552209 | |||
a85dfaa7f2 | |||
2af60e066d | |||
7442334ce1 | |||
8577675c85 | |||
685b3fe855 | |||
a653a39cf4 | |||
c338572735 | |||
07afd26ca2 | |||
d058933767 | |||
e2f81e9b48 | |||
379200dfd1 | |||
a26314dfb9 | |||
e61592c553 | |||
a3751006db | |||
40da532a4d | |||
7ce9f87954 | |||
553b9713ac | |||
ba32745e80 | |||
282b28e51f | |||
479898d9d5 | |||
c1a375284d | |||
24d2f58f98 | |||
25a91d5981 | |||
9b78dc1006 | |||
89ca2fd1ae | |||
79277b78d2 | |||
eb90ad7a99 | |||
de07014e9a | |||
25dc5c6c9c | |||
048c3dfa72 | |||
f7dfc36a9c | |||
c529399fb1 | |||
6faa3a942b | |||
0c6b09ef6a | |||
83220e7aea | |||
991ea534ee | |||
210633c08c | |||
3275ee3c82 | |||
a72deda3ac | |||
2b6b6bf8ad | |||
0107df44ab | |||
011288c2c8 | |||
eaf1a48583 | |||
52fbe950ec | |||
6a672cecbd | |||
577203bee8 | |||
5f6ac9c020 | |||
a48de6a8b8 | |||
5f6fd2dec6 | |||
e3577e7687 | |||
5ba36b063e | |||
bab02bb82e | |||
d251a6f515 | |||
9d054b25ce | |||
d1b22ac8e8 | |||
abe77db3e0 | |||
398819237e | |||
a4bacb5077 | |||
5ba5f2c2d4 | |||
6c1b356be1 | |||
bfcf52ace6 | |||
e2c927628c |
403
.travis.yml
403
.travis.yml
@ -1,4 +1,5 @@
|
||||
# Copyright 2016 Peter Dimov
|
||||
# Copyright 2016, 2017 Peter Dimov
|
||||
# Copyright 2019 Andrey Semashev
|
||||
# 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)
|
||||
|
||||
@ -8,32 +9,406 @@ sudo: false
|
||||
|
||||
python: "2.7"
|
||||
|
||||
os:
|
||||
- linux
|
||||
- osx
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- develop
|
||||
- /feature\/.*/
|
||||
|
||||
env:
|
||||
matrix:
|
||||
- BOGUS_JOB=true
|
||||
|
||||
matrix:
|
||||
|
||||
exclude:
|
||||
- env: BOGUS_JOB=true
|
||||
|
||||
include:
|
||||
# gcc, Linux
|
||||
# Note: gcc-4.4 in C++0x mode fails zip_iterator tests with std::tuple
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: gcc-4.4
|
||||
env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.4
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: gcc-4.6
|
||||
env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: gcc-4.7
|
||||
env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: gcc-4.8
|
||||
env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: gcc-4.9
|
||||
env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: gcc-5
|
||||
env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-5
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: gcc-6
|
||||
env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: gcc-7
|
||||
env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: gcc-8
|
||||
env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
dist: bionic
|
||||
compiler: gcc-9
|
||||
env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-9
|
||||
sources:
|
||||
- sourceline: "ppa:ubuntu-toolchain-r/test"
|
||||
|
||||
- os: linux
|
||||
dist: bionic
|
||||
compiler: gcc-10
|
||||
env: TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,17,20
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-10
|
||||
sources:
|
||||
- sourceline: "ppa:ubuntu-toolchain-r/test"
|
||||
|
||||
- os: linux
|
||||
dist: bionic
|
||||
compiler: gcc-UBSAN
|
||||
env: UBSAN=1 TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,17,20 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-10
|
||||
sources:
|
||||
- sourceline: "ppa:ubuntu-toolchain-r/test"
|
||||
|
||||
# clang, Linux
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: clang-3.5
|
||||
env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.5
|
||||
- libstdc++-4.9-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.5 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: clang-3.6
|
||||
env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.6
|
||||
- libstdc++-5-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.6 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: trusty
|
||||
compiler: clang-3.7
|
||||
env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.7
|
||||
- libstdc++-5-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: "deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-3.7 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: clang-3.8
|
||||
env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.8
|
||||
- libstdc++-6-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-3.8 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: clang-3.9
|
||||
env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.9
|
||||
- libstdc++-6-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-3.9 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: clang-4
|
||||
env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-4.0
|
||||
- libstdc++-6-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-4.0 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: clang-5
|
||||
env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-5.0
|
||||
- libstdc++-7-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-5.0 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: clang-6
|
||||
env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-6.0
|
||||
- libstdc++-8-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-6.0 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: clang-7
|
||||
env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-7
|
||||
- libstdc++-8-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-7 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: clang-8
|
||||
env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-8
|
||||
- libstdc++-8-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-8 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: clang-9
|
||||
env: TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11,14,17,2a
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-9
|
||||
- libstdc++-9-dev
|
||||
sources:
|
||||
- sourceline: "ppa:ubuntu-toolchain-r/test"
|
||||
- sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: clang-10
|
||||
env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-10
|
||||
- libstdc++-9-dev
|
||||
sources:
|
||||
- sourceline: "ppa:ubuntu-toolchain-r/test"
|
||||
- sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: clang-UBSAN
|
||||
env: UBSAN=1 TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20 UBSAN_OPTIONS=print_stacktrace=1
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-10
|
||||
- libstdc++-9-dev
|
||||
sources:
|
||||
- sourceline: "ppa:ubuntu-toolchain-r/test"
|
||||
- sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: clang-libc++
|
||||
env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20 CXXFLAGS="-stdlib=libc++" LINKFLAGS="-stdlib=libc++"
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-10
|
||||
- libc++-10-dev
|
||||
- libc++abi-10-dev
|
||||
sources:
|
||||
- sourceline: "ppa:ubuntu-toolchain-r/test"
|
||||
- sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
- os: linux
|
||||
dist: xenial
|
||||
compiler: clang-libc++-UBSAN
|
||||
env: UBSAN=1 TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20 UBSAN_OPTIONS=print_stacktrace=1 CXXFLAGS="-stdlib=libc++" LINKFLAGS="-stdlib=libc++"
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-10
|
||||
- libc++-10-dev
|
||||
- libc++abi-10-dev
|
||||
sources:
|
||||
- sourceline: "ppa:ubuntu-toolchain-r/test"
|
||||
- sourceline: "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main"
|
||||
key_url: "https://apt.llvm.org/llvm-snapshot.gpg.key"
|
||||
|
||||
# clang, OS X
|
||||
# OS X builds are slow on Travis CI
|
||||
# - os: osx
|
||||
# env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
|
||||
# osx_image: xcode9.4
|
||||
#
|
||||
# - os: osx
|
||||
# env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
|
||||
# osx_image: xcode10.3
|
||||
|
||||
- os: osx
|
||||
env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,17
|
||||
osx_image: xcode11.2
|
||||
|
||||
install:
|
||||
- GIT_FETCH_JOBS=8
|
||||
- BOOST_BRANCH=develop
|
||||
- if [ "$TRAVIS_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
|
||||
- cd ..
|
||||
- git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
- git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
- cd boost-root
|
||||
- git submodule update --init --depth 1 tools/build
|
||||
- git submodule update --init --depth 1 libs/config
|
||||
- git submodule update --init --depth 1 tools/boostdep
|
||||
- git submodule init tools/build
|
||||
- git submodule init tools/boostdep
|
||||
- git submodule init tools/boost_install
|
||||
- git submodule init libs/headers
|
||||
- git submodule init libs/config
|
||||
- git submodule update --jobs $GIT_FETCH_JOBS
|
||||
- cp -r $TRAVIS_BUILD_DIR/* libs/iterator
|
||||
- python tools/boostdep/depinst/depinst.py iterator
|
||||
- python tools/boostdep/depinst/depinst.py --git_args "--jobs $GIT_FETCH_JOBS" iterator
|
||||
- ./bootstrap.sh
|
||||
- ./b2 headers
|
||||
|
||||
script:
|
||||
- TOOLSET=gcc,clang
|
||||
- if [ $TRAVIS_OS_NAME == osx ]; then TOOLSET=clang; fi
|
||||
- ./b2 --verbose-test libs/config/test//config_info toolset=$TOOLSET || true
|
||||
- ./b2 libs/iterator/test toolset=$TOOLSET
|
||||
- |-
|
||||
echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
|
||||
- BUILD_JOBS=`(nproc || sysctl -n hw.ncpu) 2> /dev/null`
|
||||
- ./b2 -j $BUILD_JOBS libs/iterator/test toolset=$TOOLSET cxxstd=$CXXSTD ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on visibility=global} ${CXXFLAGS:+cxxflags="$CXXFLAGS"} ${LINKFLAGS:+linkflags="$LINKFLAGS"}
|
||||
|
||||
notifications:
|
||||
email:
|
||||
|
34
CMakeLists.txt
Normal file
34
CMakeLists.txt
Normal file
@ -0,0 +1,34 @@
|
||||
# Copyright 2018 Peter Dimov
|
||||
# Copyright 2018 Andrey Semashev
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
# Partial (add_subdirectory only) and experimental CMake support
|
||||
# Subject to change; please do not rely on the contents of this file yet.
|
||||
|
||||
cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
project(BoostIterator LANGUAGES CXX)
|
||||
|
||||
add_library(boost_iterator INTERFACE)
|
||||
add_library(Boost::iterator ALIAS boost_iterator)
|
||||
|
||||
target_include_directories(boost_iterator INTERFACE include)
|
||||
|
||||
target_link_libraries(boost_iterator
|
||||
INTERFACE
|
||||
Boost::assert
|
||||
Boost::concept_check
|
||||
Boost::config
|
||||
Boost::conversion
|
||||
Boost::core
|
||||
Boost::detail
|
||||
Boost::function_types
|
||||
Boost::fusion
|
||||
Boost::mpl
|
||||
Boost::optional
|
||||
Boost::smart_ptr
|
||||
Boost::static_assert
|
||||
Boost::type_traits
|
||||
Boost::utility
|
||||
)
|
80
appveyor.yml
Normal file
80
appveyor.yml
Normal file
@ -0,0 +1,80 @@
|
||||
# Copyright 2017 Edward Diener
|
||||
# Copyright 2019 Andrey Semashev
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
|
||||
version: 1.0.{build}-{branch}
|
||||
|
||||
shallow_clone: true
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- develop
|
||||
- /feature\/.*/
|
||||
|
||||
environment:
|
||||
matrix:
|
||||
- TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
- TOOLSET: msvc-14.0
|
||||
ADDRMD: 32,64
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
- TOOLSET: msvc-14.1
|
||||
CXXSTD: 14,17
|
||||
ADDRMD: 32,64
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
- TOOLSET: msvc-14.2
|
||||
ADDRMD: 32,64
|
||||
CXXSTD: 14,17
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
|
||||
- TOOLSET: clang-win
|
||||
ADDRMD: 32,64
|
||||
CXXSTD: 14,17
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
- TOOLSET: gcc
|
||||
CXXSTD: 03,11,14,1z
|
||||
ADDPATH: C:\cygwin\bin;
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
- TOOLSET: gcc
|
||||
CXXSTD: 03,11,14,1z
|
||||
ADDPATH: C:\cygwin64\bin;
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
- TOOLSET: gcc
|
||||
CXXSTD: 03,11,14,1z
|
||||
ADDPATH: C:\mingw\bin;
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
- TOOLSET: gcc
|
||||
CXXSTD: 03,11,14,1z
|
||||
ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
- TOOLSET: gcc
|
||||
CXXSTD: 03,11,14,1z
|
||||
ADDPATH: C:\mingw-w64\x86_64-7.3.0-posix-seh-rt_v5-rev0\mingw64\bin;
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
|
||||
|
||||
install:
|
||||
- set GIT_FETCH_JOBS=8
|
||||
- set BOOST_BRANCH=develop
|
||||
- if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
|
||||
- cd ..
|
||||
- git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
- cd boost-root
|
||||
- git submodule init tools/build
|
||||
- git submodule init tools/boostdep
|
||||
- git submodule init tools/boost_install
|
||||
- git submodule init libs/headers
|
||||
- git submodule init libs/config
|
||||
- git submodule update --jobs %GIT_FETCH_JOBS%
|
||||
- xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\iterator
|
||||
- python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" iterator
|
||||
- cmd /c bootstrap
|
||||
- b2 -d0 headers
|
||||
|
||||
build: off
|
||||
|
||||
test_script:
|
||||
- PATH=%ADDPATH%%PATH%
|
||||
- if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
|
||||
- if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
|
||||
- b2 -j %NUMBER_OF_PROCESSORS% libs/iterator/test toolset=%TOOLSET% %CXXSTD% %ADDRMD%
|
@ -16,7 +16,7 @@ boostbook standalone
|
||||
<xsl:param>boost.root=../../../..
|
||||
<xsl:param>toc.max.depth=3
|
||||
<xsl:param>toc.section.depth=3
|
||||
<xsl:param>chunk.section.depth=4
|
||||
<xsl:param>chunk.section.depth=2
|
||||
<format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/iterator/doc
|
||||
;
|
||||
|
||||
|
75
doc/advance.rst
Normal file
75
doc/advance.rst
Normal file
@ -0,0 +1,75 @@
|
||||
.. Copyright (C) 2017 Michel Morin.
|
||||
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)
|
||||
|
||||
=======
|
||||
advance
|
||||
=======
|
||||
|
||||
``boost::iterators::advance`` is an adapted version of ``std::advance`` for
|
||||
the Boost iterator traversal concepts.
|
||||
|
||||
|
||||
Header
|
||||
------
|
||||
|
||||
``<boost/iterator/advance.hpp>``
|
||||
|
||||
|
||||
Synopsis
|
||||
--------
|
||||
|
||||
::
|
||||
|
||||
template <typename Iterator, typename Distance>
|
||||
constexpr void advance(Iterator& it, Distance n);
|
||||
|
||||
|
||||
Description
|
||||
-----------
|
||||
|
||||
Moves ``it`` forward by ``n`` increments
|
||||
(or backward by ``|n|`` decrements if ``n`` is negative).
|
||||
|
||||
|
||||
Requirements
|
||||
------------
|
||||
|
||||
``Iterator`` should model Incrementable Iterator.
|
||||
|
||||
|
||||
Preconditions
|
||||
-------------
|
||||
|
||||
Let ``it``\ :sub:`i` be the iterator obtained by incrementing
|
||||
(or decrementing if ``n`` is negative) ``it`` by *i*. All the iterators
|
||||
``it``\ :sub:`i` for *i* = 0, 1, 2, ..., ``|n|`` should be valid.
|
||||
|
||||
If ``Iterator`` does not model Bidirectional Traversal Iterator,
|
||||
``n`` should be non-negative.
|
||||
|
||||
|
||||
Complexity
|
||||
----------
|
||||
|
||||
If ``Iterator`` models Random Access Traversal Iterator, it takes constant time;
|
||||
otherwise it takes linear time.
|
||||
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
- This function is not a customization point and is protected against
|
||||
being found by argument-dependent lookup (ADL).
|
||||
- This function is ``constexpr`` only in C++14 or later.
|
||||
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
| Author: Michel Morin
|
||||
| Copyright |C| 2017 Michel Morin
|
||||
| Distributed under the `Boost Software License, Version 1.0
|
||||
<http://www.boost.org/LICENSE_1_0.txt>`_.
|
||||
|
||||
.. |C| unicode:: U+00A9 .. COPYRIGHT SIGN
|
72
doc/distance.rst
Normal file
72
doc/distance.rst
Normal file
@ -0,0 +1,72 @@
|
||||
.. Copyright (C) 2017 Michel Morin.
|
||||
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)
|
||||
|
||||
========
|
||||
distance
|
||||
========
|
||||
|
||||
``boost::iterators::distance`` is an adapted version of ``std::distance`` for
|
||||
the Boost iterator traversal concepts.
|
||||
|
||||
|
||||
Header
|
||||
------
|
||||
|
||||
``<boost/iterator/distance.hpp>``
|
||||
|
||||
|
||||
Synopsis
|
||||
--------
|
||||
|
||||
::
|
||||
|
||||
template <typename Iterator>
|
||||
constexpr typename iterator_difference<Iterator>::type
|
||||
distance(Iterator first, Iterator last);
|
||||
|
||||
|
||||
Description
|
||||
-----------
|
||||
|
||||
Computes the (signed) distance from ``first`` to ``last``.
|
||||
|
||||
|
||||
Requirements
|
||||
------------
|
||||
|
||||
``Iterator`` should model Single Pass Iterator.
|
||||
|
||||
|
||||
Preconditions
|
||||
-------------
|
||||
|
||||
If ``Iterator`` models Random Access Traversal Iterator,
|
||||
``[first, last)`` or ``[last, first)`` should be valid;
|
||||
otherwise ``[first, last)`` should be valid.
|
||||
|
||||
|
||||
Complexity
|
||||
----------
|
||||
|
||||
If ``Iterator`` models Random Access Traversal Iterator, it takes constant time;
|
||||
otherwise it takes linear time.
|
||||
|
||||
|
||||
Notes
|
||||
-----
|
||||
|
||||
- This function is not a customization point and is protected against
|
||||
being found by argument-dependent lookup (ADL).
|
||||
- This function is ``constexpr`` only in C++14 or later.
|
||||
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
| Author: Michel Morin
|
||||
| Copyright |C| 2017 Michel Morin
|
||||
| Distributed under the `Boost Software License, Version 1.0
|
||||
<http://www.boost.org/LICENSE_1_0.txt>`_.
|
||||
|
||||
.. |C| unicode:: U+00A9 .. COPYRIGHT SIGN
|
@ -131,6 +131,9 @@ is called to get the value to return.</li>
|
||||
<li><a class="reference external" href="function_output_iterator.html"><tt class="docutils literal"><span class="pre">function_output_iterator</span></tt></a> (<a class="reference external" href="function_output_iterator.pdf">PDF</a>): an output iterator wrapping a unary function
|
||||
object; each time an element is written into the dereferenced
|
||||
iterator, it is passed as a parameter to the function object.</li>
|
||||
<li><a class="reference external" href="generator_iterator.htm"><tt class="docutils literal"><span class="pre">generator_iterator</span></tt></a>: an input iterator wrapping a reference to a generator (nullary function object);
|
||||
each time the iterator is dereferenced, the function object
|
||||
is called to get the value to return. This is a more outdated analogue of <tt class="docutils literal"><span class="pre">function_input_iterator</span></tt>.</li>
|
||||
<li><a class="reference external" href="indirect_iterator.html"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt></a> (<a class="reference external" href="indirect_iterator.pdf">PDF</a>): an iterator over the objects <em>pointed-to</em> by the
|
||||
elements of some sequence.</li>
|
||||
<li><a class="reference external" href="permutation_iterator.html"><tt class="docutils literal"><span class="pre">permutation_iterator</span></tt></a> (<a class="reference external" href="permutation_iterator.pdf">PDF</a>): an iterator over the elements of some random-access
|
||||
|
@ -146,6 +146,10 @@ iterator templates based on the Boost `iterator facade and adaptor`_.
|
||||
object; each time an element is written into the dereferenced
|
||||
iterator, it is passed as a parameter to the function object.
|
||||
|
||||
* |generator|_: an input iterator wrapping a generator (nullary
|
||||
function object); each time the iterator is dereferenced, the function object
|
||||
is called to get the value to return. This is an outdated analogue of |function_input|_.
|
||||
|
||||
* |indirect|_ (PDF__): an iterator over the objects *pointed-to* by the
|
||||
elements of some sequence.
|
||||
|
||||
@ -183,6 +187,9 @@ __ function_input_iterator.pdf
|
||||
.. _function_output: function_output_iterator.html
|
||||
__ function_output_iterator.pdf
|
||||
|
||||
.. |generator| replace:: ``generator_iterator``
|
||||
.. _generator: generator_iterator.htm
|
||||
|
||||
.. |indirect| replace:: ``indirect_iterator``
|
||||
.. _indirect: indirect_iterator.html
|
||||
__ indirect_iterator.pdf
|
||||
@ -213,6 +220,23 @@ __ zip_iterator.pdf
|
||||
Iterator Utilities
|
||||
====================
|
||||
|
||||
Operations
|
||||
----------
|
||||
|
||||
The standard library does not handle new-style iterators properly,
|
||||
because it knows nothing about the iterator traversal concepts.
|
||||
The Boost.Iterator library provides implementations that fully understand
|
||||
the new concepts for the two basic operations:
|
||||
|
||||
- |advance|_
|
||||
- |distance|_
|
||||
|
||||
.. |advance| replace:: ``advance``
|
||||
.. _advance: advance.html
|
||||
|
||||
.. |distance| replace:: ``distance``
|
||||
.. _distance: distance.html
|
||||
|
||||
Traits
|
||||
------
|
||||
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
[section:adaptor Iterator Adaptor]
|
||||
|
||||
The `iterator_adaptor` class template adapts some `Base` [#base]_
|
||||
@ -47,7 +46,7 @@ that assumption.
|
||||
, class Reference = use_default
|
||||
, class Difference = use_default
|
||||
>
|
||||
class iterator_adaptor
|
||||
class iterator_adaptor
|
||||
: public iterator_facade<Derived, *V'*, *C'*, *R'*, *D'*> // see details
|
||||
{
|
||||
friend class iterator_core_access;
|
||||
@ -60,21 +59,21 @@ that assumption.
|
||||
typedef iterator_adaptor iterator_adaptor\_;
|
||||
Base const& base_reference() const;
|
||||
Base& base_reference();
|
||||
private: // Core iterator interface for iterator_facade.
|
||||
private: // Core iterator interface for iterator_facade.
|
||||
typename iterator_adaptor::reference dereference() const;
|
||||
|
||||
template <
|
||||
class OtherDerived, class OtherIterator, class V, class C, class R, class D
|
||||
>
|
||||
class OtherDerived, class OtherIterator, class V, class C, class R, class D
|
||||
>
|
||||
bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const;
|
||||
|
||||
|
||||
void advance(typename iterator_adaptor::difference_type n);
|
||||
void increment();
|
||||
void decrement();
|
||||
|
||||
template <
|
||||
class OtherDerived, class OtherIterator, class V, class C, class R, class D
|
||||
>
|
||||
>
|
||||
typename iterator_adaptor::difference_type distance_to(
|
||||
iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const;
|
||||
|
||||
@ -133,7 +132,7 @@ above are defined as follows:
|
||||
iterator_adaptor();
|
||||
|
||||
[*Requires:] The `Base` type must be Default Constructible.[br]
|
||||
[*Returns:] An instance of `iterator_adaptor` with
|
||||
[*Returns:] An instance of `iterator_adaptor` with
|
||||
`m_iterator` default constructed.
|
||||
|
||||
|
||||
@ -167,7 +166,7 @@ above are defined as follows:
|
||||
|
||||
template <
|
||||
class OtherDerived, class OtherIterator, class V, class C, class R, class D
|
||||
>
|
||||
>
|
||||
bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const;
|
||||
|
||||
[*Returns:] `m_iterator == x.base()`
|
||||
@ -188,7 +187,7 @@ above are defined as follows:
|
||||
|
||||
template <
|
||||
class OtherDerived, class OtherIterator, class V, class C, class R, class D
|
||||
>
|
||||
>
|
||||
typename iterator_adaptor::difference_type distance_to(
|
||||
iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const;
|
||||
|
||||
@ -229,7 +228,7 @@ operations on the underlying pointer, via the `node_iterator`\ 's
|
||||
|dereference_and_equal|_). The only real behavioral difference
|
||||
between `node_base*` and `node_iterator` can be observed when
|
||||
they are incremented: `node_iterator` follows the
|
||||
`m_next` pointer, while `node_base*` just applies an address offset.
|
||||
`m_next` pointer, while `node_base*` just applies an address offset.
|
||||
|
||||
.. |dereference_and_equal| replace:: `dereference` and `equal` member functions
|
||||
.. _dereference_and_equal: iterator_facade.html#implementing-the-core-operations
|
||||
@ -287,8 +286,8 @@ this technique is known not to work with Borland C++ 5.6.4 and
|
||||
Metrowerks CodeWarrior versions prior to 9.0]
|
||||
|
||||
You can see an example program that exercises this version of the
|
||||
node iterators
|
||||
[@../example/node_iterator3.cpp `here`].
|
||||
node iterators
|
||||
[example_link node_iterator3.cpp..here].
|
||||
|
||||
|
||||
In the case of `node_iter`, it's not very compelling to pass
|
||||
@ -306,7 +305,7 @@ types to its `Base` saves the implementor of
|
||||
|
||||
std::iterator_traits<Iterator>::*some-associated-type*
|
||||
|
||||
at least four times.
|
||||
at least four times.
|
||||
|
||||
We urge you to review the documentation and implementations of
|
||||
|reverse_iterator|_ and the other Boost `specialized iterator
|
||||
@ -330,4 +329,4 @@ __ index.html#specialized-adaptors
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
149
doc/quickbook/algorithms.qbk
Normal file
149
doc/quickbook/algorithms.qbk
Normal file
@ -0,0 +1,149 @@
|
||||
[section:algorithms Algorithms]
|
||||
|
||||
[section:advance Function template `advance()`]
|
||||
|
||||
The `boost::iterators::advance` function template is an adapted version of `std::advance` for the Boost iterator [link iterator.concepts.traversal traversal concepts].
|
||||
|
||||
[heading Header]
|
||||
|
||||
<boost/iterator/advance.hpp>
|
||||
|
||||
[heading Synopsis]
|
||||
|
||||
template <typename Iterator, typename Distance>
|
||||
constexpr void advance(Iterator& it, Distance n);
|
||||
|
||||
|
||||
[heading Description]
|
||||
|
||||
Moves `it` forward by `n` increments (or backward by `|n|` decrements if `n` is negative).
|
||||
|
||||
[heading Requirements]
|
||||
|
||||
`Iterator` should model Incrementable Iterator.
|
||||
|
||||
[heading Preconditions]
|
||||
|
||||
Let `it`[sub `i`] be the iterator obtained by incrementing (or decrementing if `n` is negative) `it` by `i`. All the iterators `it`[sub `i`] for `i` = 0, 1, 2, ..., `|n|` should be valid.
|
||||
|
||||
If `Iterator` does not model [link iterator.concepts.traversal.bidirectional Bidirectional Traversal Iterator], `n` should be non-negative.
|
||||
|
||||
[heading Complexity]
|
||||
|
||||
If `Iterator` models [link iterator.concepts.traversal.random_access Random Access Traversal Iterator], it takes constant time; otherwise it takes linear time.
|
||||
|
||||
[heading Notes]
|
||||
|
||||
* This function is not a customization point and is protected against being found by argument-dependent lookup (ADL).
|
||||
* This function is `constexpr` only in C++14 or later.
|
||||
|
||||
[heading Acknowledgements]
|
||||
|
||||
Contributed by Michel Morin.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:distance Function template `distance()`]
|
||||
|
||||
The `boost::iterators::distance` function template is an adapted version of `std::distance` for the Boost iterator [link iterator.concepts.traversal traversal concepts].
|
||||
|
||||
[heading Header]
|
||||
|
||||
<boost/iterator/distance.hpp>
|
||||
|
||||
[heading Synopsis]
|
||||
|
||||
template <typename Iterator>
|
||||
constexpr typename iterator_difference<Iterator>::type
|
||||
distance(Iterator first, Iterator last);
|
||||
|
||||
[heading Description]
|
||||
|
||||
Computes the (signed) distance from `first` to `last`.
|
||||
|
||||
[heading Requirements]
|
||||
|
||||
`Iterator` should model [link iterator.concepts.traversal.single_pass Single Pass Iterator].
|
||||
|
||||
[heading Preconditions]
|
||||
|
||||
If `Iterator` models [link iterator.concepts.traversal.random_access Random Access Traversal Iterator], `[first, last)` or `[last, first)` should be valid; otherwise `[first, last)` should be valid.
|
||||
|
||||
[heading Complexity]
|
||||
|
||||
If `Iterator` models [link iterator.concepts.traversal.random_access Random Access Traversal Iterator], it takes constant time; otherwise it takes linear time.
|
||||
|
||||
[heading Notes]
|
||||
|
||||
* This function is not a customization point and is protected against being found by argument-dependent lookup (ADL).
|
||||
* This function is `constexpr` only in C++14 or later.
|
||||
|
||||
[heading Acknowledgements]
|
||||
|
||||
Contributed by Michel Morin.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:next_prior Function templates `next()` and `prior()`]
|
||||
|
||||
Certain data types, such as the C++ Standard Library's forward and bidirectional iterators, do not provide addition and subtraction via `operator+()` or `operator-()`. This means that non-modifying computation of the next or prior value requires a temporary, even though `operator++()` or `operator--()` is provided. It also means that writing code like `itr+1` inside a template restricts the iterator category to random access iterators.
|
||||
|
||||
The `next()` and `prior()` functions defined in `boost/next_prior.hpp` provide a simple way around these problems.
|
||||
|
||||
[heading Synopsis]
|
||||
|
||||
template <class T>
|
||||
T next(T x)
|
||||
{
|
||||
return ++x;
|
||||
}
|
||||
|
||||
template <class T, class Distance>
|
||||
T next(T x, Distance n)
|
||||
{
|
||||
std::advance(x, n);
|
||||
return x;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
T prior(T x)
|
||||
{
|
||||
return --x;
|
||||
}
|
||||
|
||||
template <class T, class Distance>
|
||||
T prior(T x, Distance n)
|
||||
{
|
||||
std::advance(x, -n);
|
||||
return x;
|
||||
}
|
||||
|
||||
[note Function implementations above are given for exposition only. The actual implementation has the same effect for iterators, but has different properties, as documented later.]
|
||||
|
||||
[heading Usage]
|
||||
|
||||
Usage is simple:
|
||||
|
||||
const std::list<T>::iterator p = get_some_iterator();
|
||||
const std::list<T>::iterator prev = boost::prior(p);
|
||||
const std::list<T>::iterator next = boost::next(prev, 2);
|
||||
|
||||
The distance from the given iterator should be supplied as an absolute value. For example, the iterator four iterators prior to the given iterator `p` may be obtained by `prior(p, 4)`.
|
||||
|
||||
With C++11, the Standard Library provides `std::next()` and `std::prev()` function templates, which serve the same purpose. However, there are advantages to `boost::next()` and `boost::prior()`.
|
||||
|
||||
First, `boost::next()` and `boost::prior()` are compatible not only with iterators but with any type that provides arithmetic operators `operator++()`, `operator--()`, `operator+()`, `operator-()`, `operator+=()` or `operator-=()`. For example, this is possible:
|
||||
|
||||
int x = 10;
|
||||
int y = boost::next(x, 5);
|
||||
assert(y == 15);
|
||||
|
||||
Second, `boost::next()` and `boost::prior()` use [link iterator.concepts.traversal traversal categories] to select the most efficient implementation. For some kinds of iterators, such as [link iterator.specialized.transform transform iterators], the standard iterator category does not reflect the traversal category correctly and therefore `std::next()` and `std::prev()` will fall back to linear complexity.
|
||||
|
||||
[heading Acknowledgements]
|
||||
|
||||
Contributed by [@http://www.boost.org/people/dave_abrahams.htm Dave Abrahams]. Two-argument versions by Daniel Walker.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
@ -1,4 +1,3 @@
|
||||
|
||||
[section:archetypes Iterator Archetypes]
|
||||
|
||||
The `iterator_archetype` class constructs a minimal implementation of
|
||||
@ -41,23 +40,23 @@ The access category types provided correspond to the following
|
||||
standard iterator access concept combinations:
|
||||
|
||||
readable_iterator_t :=
|
||||
|
||||
|
||||
Readable Iterator
|
||||
|
||||
writable_iterator_t :=
|
||||
|
||||
|
||||
Writeable Iterator
|
||||
|
||||
readable_writable_iterator_t :=
|
||||
|
||||
|
||||
Readable Iterator & Writeable Iterator & Swappable Iterator
|
||||
|
||||
readable_lvalue_iterator_t :=
|
||||
|
||||
|
||||
Readable Iterator & Lvalue Iterator
|
||||
|
||||
writeable_lvalue_iterator_t :=
|
||||
|
||||
|
||||
Readable Iterator & Writeable Iterator & Swappable Iterator & Lvalue Iterator
|
||||
|
||||
[h3 Traits]
|
||||
@ -66,25 +65,25 @@ The nested trait types are defined as follows:
|
||||
|
||||
|
||||
if (AccessCategory == readable_iterator_t)
|
||||
|
||||
|
||||
value_type = Value
|
||||
reference = Value
|
||||
pointer = Value*
|
||||
|
||||
else if (AccessCategory == writable_iterator_t)
|
||||
|
||||
|
||||
value_type = void
|
||||
reference = void
|
||||
pointer = void
|
||||
|
||||
else if (AccessCategory == readable_writable_iterator_t)
|
||||
|
||||
|
||||
value_type = Value
|
||||
|
||||
reference :=
|
||||
|
||||
A type X that is convertible to Value for which the following
|
||||
expression is valid. Given an object x of type X and v of type
|
||||
expression is valid. Given an object x of type X and v of type
|
||||
Value.
|
||||
|
||||
x = v
|
||||
@ -92,13 +91,13 @@ The nested trait types are defined as follows:
|
||||
pointer = Value*
|
||||
|
||||
else if (AccessCategory == readable_lvalue_iterator_t)
|
||||
|
||||
|
||||
value_type = Value
|
||||
reference = Value const&
|
||||
pointer = Value const*
|
||||
|
||||
else if (AccessCategory == writable_lvalue_iterator_t)
|
||||
|
||||
|
||||
value_type = Value
|
||||
reference = Value&
|
||||
pointer = Value*
|
||||
@ -108,11 +107,11 @@ The nested trait types are defined as follows:
|
||||
difference_type := ptrdiff_t
|
||||
|
||||
else
|
||||
|
||||
|
||||
difference_type := unspecified type
|
||||
|
||||
|
||||
iterator_category :=
|
||||
|
||||
iterator_category :=
|
||||
|
||||
A type X satisfying the following two constraints:
|
||||
|
||||
@ -156,5 +155,4 @@ the iterator concept specified by `AccessCategory` and
|
||||
arguments. `iterator_archetype` does not model any other access
|
||||
concepts or any more derived traversal concepts.
|
||||
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
@ -4,7 +4,7 @@ The iterator concept checking classes provide a mechanism for a
|
||||
template to report better error messages when a user instantiates the
|
||||
template with a type that does not meet the requirements of the
|
||||
template. For an introduction to using concept checking classes, see
|
||||
the documentation for the boost::concept_check library.
|
||||
the documentation for the _concept_check_ library.
|
||||
|
||||
[h2 `iterator_concepts.hpp` Synopsis]
|
||||
|
||||
@ -51,4 +51,4 @@ the documentation for the boost::concept_check library.
|
||||
|
||||
}
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
@ -1,9 +1,8 @@
|
||||
|
||||
[section:concepts Iterator Concepts]
|
||||
|
||||
[section:concepts_access Access]
|
||||
[section:access Access]
|
||||
|
||||
[h2 Readable Iterator Concept]
|
||||
[section:readable Readable Iterator Concept]
|
||||
|
||||
A class or built-in type `X` models the *Readable Iterator* concept
|
||||
for value type `T` if, in addition to `X` being Assignable and
|
||||
@ -32,17 +31,18 @@ type `T`.
|
||||
[`U&`]
|
||||
[pre: `(*a).m` is well-defined. Equivalent to `(*a).m`.]
|
||||
]
|
||||
]
|
||||
|
||||
[h2 Writable Iterator Concept ]
|
||||
|
||||
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:writable Writable Iterator Concept]
|
||||
|
||||
A class or built-in type `X` models the *Writable Iterator* concept
|
||||
if, in addition to `X` being Copy Constructible, the following
|
||||
expressions are valid and respect the stated semantics. Writable
|
||||
Iterators have an associated *set of value types*.
|
||||
|
||||
[table Writable Iterator Requirements (in addition to Copy Constructible)
|
||||
[table Writable Iterator Requirements (in addition to Copy Constructible)
|
||||
[
|
||||
[Expression]
|
||||
[Return Type]
|
||||
@ -55,13 +55,15 @@ Iterators have an associated *set of value types*.
|
||||
]
|
||||
]
|
||||
|
||||
[h2 Swappable Iterator Concept]
|
||||
[endsect]
|
||||
|
||||
[section:swappable Swappable Iterator Concept]
|
||||
|
||||
A class or built-in type `X` models the *Swappable Iterator* concept
|
||||
if, in addition to `X` being Copy Constructible, the following
|
||||
expressions are valid and respect the stated semantics.
|
||||
|
||||
[table Swappable Iterator Requirements (in addition to Copy Constructible)
|
||||
[table Swappable Iterator Requirements (in addition to Copy Constructible)
|
||||
[
|
||||
[Expression]
|
||||
[Return Type]
|
||||
@ -77,7 +79,9 @@ expressions are valid and respect the stated semantics.
|
||||
[blurb *Note:* An iterator that is a model of the *Readable* and *Writable Iterator* concepts
|
||||
is also a model of *Swappable Iterator*. *--end note*]
|
||||
|
||||
[h2 Lvalue Iterator Concept]
|
||||
[endsect]
|
||||
|
||||
[section:lvalue Lvalue Iterator Concept]
|
||||
|
||||
The *Lvalue Iterator* concept adds the requirement that the return
|
||||
type of `operator*` type be a reference to the value type of the
|
||||
@ -101,17 +105,17 @@ iterator.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:concepts_traversal Traversal]
|
||||
[endsect]
|
||||
|
||||
[h2 Incrementable Iterator Concept]
|
||||
[section:traversal Traversal]
|
||||
|
||||
[section:incrementable Incrementable Iterator Concept]
|
||||
|
||||
A class or built-in type `X` models the *Incrementable Iterator*
|
||||
concept if, in addition to `X` being Assignable and Copy
|
||||
Constructible, the following expressions are valid and respect the
|
||||
stated semantics.
|
||||
|
||||
|
||||
[table Incrementable Iterator Requirements (in addition to Assignable, Copy Constructible)
|
||||
[
|
||||
[Expression ]
|
||||
@ -129,7 +133,7 @@ stated semantics.
|
||||
[``
|
||||
{
|
||||
X tmp = r;
|
||||
++r;
|
||||
++r;
|
||||
return tmp;
|
||||
}
|
||||
``]
|
||||
@ -141,7 +145,9 @@ stated semantics.
|
||||
]
|
||||
]
|
||||
|
||||
[h2 Single Pass Iterator Concept]
|
||||
[endsect]
|
||||
|
||||
[section:single_pass Single Pass Iterator Concept]
|
||||
|
||||
A class or built-in type `X` models the *Single Pass Iterator*
|
||||
concept if the following expressions are valid and respect the stated
|
||||
@ -168,6 +174,11 @@ semantics.
|
||||
[convertible to `bool`]
|
||||
[`!(a == b)`]
|
||||
]
|
||||
[
|
||||
[`iterator_traits<X>::difference_type`]
|
||||
[A signed integral type representing the distance between iterators]
|
||||
[]
|
||||
]
|
||||
[
|
||||
[`iterator_traversal<X>::type`]
|
||||
[Convertible to`single_pass_traversal_tag`]
|
||||
@ -175,8 +186,9 @@ semantics.
|
||||
]
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[h2 Forward Traversal Concept]
|
||||
[section:forward Forward Traversal Concept]
|
||||
|
||||
A class or built-in type `X` models the *Forward Traversal*
|
||||
concept if, in addition to `X` meeting the requirements of Default
|
||||
@ -199,11 +211,6 @@ valid and respect the stated semantics.
|
||||
[`X&`]
|
||||
[`r == s` and `r` is dereferenceable implies `++r == ++s.`]
|
||||
]
|
||||
[
|
||||
[`iterator_traits<X>::difference_type`]
|
||||
[A signed integral type representing the distance between iterators]
|
||||
[]
|
||||
]
|
||||
[
|
||||
[`iterator_traversal<X>::type`]
|
||||
[Convertible to `forward_traversal_tag`]
|
||||
@ -211,7 +218,9 @@ valid and respect the stated semantics.
|
||||
]
|
||||
]
|
||||
|
||||
[h2 Bidirectional Traversal Concept]
|
||||
[endsect]
|
||||
|
||||
[section:bidirectional Bidirectional Traversal Concept]
|
||||
|
||||
A class or built-in type `X` models the *Bidirectional Traversal*
|
||||
concept if, in addition to `X` meeting the requirements of Forward
|
||||
@ -223,7 +232,7 @@ the stated semantics.
|
||||
[Expression]
|
||||
[Return Type]
|
||||
[Assertion/Semantics/Pre-/Post-condition]
|
||||
]
|
||||
]
|
||||
[
|
||||
[`--r`]
|
||||
[`X&`]
|
||||
@ -247,7 +256,9 @@ the stated semantics.
|
||||
]
|
||||
]
|
||||
|
||||
[h2 Random Access Traversal Concept]
|
||||
[endsect]
|
||||
|
||||
[section:random_access Random Access Traversal Concept]
|
||||
|
||||
A class or built-in type `X` models the *Random Access Traversal*
|
||||
concept if the following expressions are valid and respect the stated
|
||||
@ -255,8 +266,8 @@ semantics. In the table below, `Distance` is
|
||||
`iterator_traits<X>::difference_type` and `n` represents a
|
||||
constant object of type `Distance`.
|
||||
|
||||
[table Random Access Traversal Iterator Requirements (in addition to Bidirectional Traversal)
|
||||
[
|
||||
[table Random Access Traversal Iterator Requirements (in addition to Bidirectional Traversal)
|
||||
[
|
||||
[Expression]
|
||||
[Return Type]
|
||||
[Operational Semantics]
|
||||
@ -266,10 +277,10 @@ constant object of type `Distance`.
|
||||
[`r += n`]
|
||||
[ `X&`]
|
||||
[``
|
||||
{
|
||||
{
|
||||
Distance m = n;
|
||||
if (m >= 0)
|
||||
while (m--)
|
||||
while (m--)
|
||||
++r;
|
||||
else
|
||||
while (m++)
|
||||
@ -279,18 +290,18 @@ constant object of type `Distance`.
|
||||
``]
|
||||
[ ]
|
||||
]
|
||||
[
|
||||
[
|
||||
[`a + n`, `n + a`]
|
||||
[`X`]
|
||||
[``
|
||||
{
|
||||
{
|
||||
X tmp = a;
|
||||
return tmp+= n;
|
||||
}
|
||||
``]
|
||||
[]
|
||||
]
|
||||
[
|
||||
[
|
||||
[`r -= n`]
|
||||
[`X&`]
|
||||
[`return r += -n`]
|
||||
@ -300,9 +311,9 @@ constant object of type `Distance`.
|
||||
[`a - n`]
|
||||
[`X`]
|
||||
[``
|
||||
{
|
||||
{
|
||||
X tmp = a;
|
||||
return tmp-= n;
|
||||
return tmp-= n;
|
||||
}
|
||||
``]
|
||||
[]
|
||||
@ -314,13 +325,13 @@ constant object of type `Distance`.
|
||||
[pre: there exists a value `n` of `Distance` such that `a + n == b`. `b == a + (b - a)`.]
|
||||
]
|
||||
[
|
||||
[`a\[n\]`]
|
||||
[`a[n]`]
|
||||
[convertible to T]
|
||||
[`*(a + n)`]
|
||||
[pre: a is a *Readable Iterator*]
|
||||
]
|
||||
[
|
||||
[`a\[n\] = v`]
|
||||
[`a[n] = v`]
|
||||
[convertible to T]
|
||||
[`*(a + n) = v`]
|
||||
[pre: a is a *Writable iterator*]
|
||||
@ -359,4 +370,6 @@ constant object of type `Distance`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
[section:counting Counting Iterator]
|
||||
|
||||
A `counting_iterator` adapts an object by adding an `operator*` that
|
||||
@ -18,28 +17,30 @@ into the first array via indirection through the second array.
|
||||
std::vector<int> numbers;
|
||||
typedef std::vector<int>::iterator n_iter;
|
||||
std::copy(boost::counting_iterator<int>(0),
|
||||
boost::counting_iterator<int>(N),
|
||||
std::back_inserter(numbers));
|
||||
boost::counting_iterator<int>(N),
|
||||
std::back_inserter(numbers));
|
||||
|
||||
std::vector<std::vector<int>::iterator> pointers;
|
||||
std::copy(boost::make_counting_iterator(numbers.begin()),
|
||||
boost::make_counting_iterator(numbers.end()),
|
||||
std::back_inserter(pointers));
|
||||
boost::make_counting_iterator(numbers.end()),
|
||||
std::back_inserter(pointers));
|
||||
|
||||
std::cout << "indirectly printing out the numbers from 0 to "
|
||||
<< N << std::endl;
|
||||
std::cout << "indirectly printing out the numbers from 0 to "
|
||||
<< N << std::endl;
|
||||
std::copy(boost::make_indirect_iterator(pointers.begin()),
|
||||
boost::make_indirect_iterator(pointers.end()),
|
||||
std::ostream_iterator<int>(std::cout, " "));
|
||||
boost::make_indirect_iterator(pointers.end()),
|
||||
std::ostream_iterator<int>(std::cout, " "));
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
The output is:
|
||||
|
||||
indirectly printing out the numbers from 0 to 7
|
||||
0 1 2 3 4 5 6
|
||||
[pre
|
||||
indirectly printing out the numbers from 0 to 7
|
||||
0 1 2 3 4 5 6
|
||||
]
|
||||
|
||||
The source code for this example can be found [@../example/counting_iterator_example.cpp here].
|
||||
The source code for this example can be found [example_link counting_iterator_example.cpp..here].
|
||||
|
||||
[h2 Reference]
|
||||
|
||||
@ -86,9 +87,9 @@ algorithm:
|
||||
random_access_traversal_tag, Incrementable, const Incrementable&)
|
||||
else
|
||||
return |iterator-category|_\ (
|
||||
iterator_traversal<Incrementable>::type,
|
||||
iterator_traversal<Incrementable>::type,
|
||||
Incrementable, const Incrementable&)
|
||||
|
||||
|
||||
[blurb *Note:* implementers are encouraged to provide an implementation of
|
||||
`operator-` and a `difference_type` that avoids overflows in
|
||||
the cases where `std::numeric_limits<Incrementable>::is_specialized`
|
||||
@ -181,7 +182,7 @@ operations.
|
||||
counting_iterator& operator--();
|
||||
|
||||
[*Effects: ] `--m_inc`[br]
|
||||
[*Returns: ] `*this`
|
||||
[*Returns: ] `*this`
|
||||
|
||||
|
||||
Incrementable const& base() const;
|
||||
@ -189,4 +190,4 @@ operations.
|
||||
[*Returns: ] `m_inc`
|
||||
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
[section:facade Iterator Facade]
|
||||
|
||||
While the iterator interface is rich, there is a core subset of the
|
||||
@ -141,7 +140,7 @@ standardize the gateway protocol. Note that even if
|
||||
open a safety loophole, as every core member function preserves the
|
||||
invariants of the iterator.
|
||||
|
||||
[h2 `operator\[\]`]
|
||||
[h2 `operator[]`]
|
||||
|
||||
The indexing operator for a generalized iterator presents special
|
||||
challenges. A random access iterator's `operator[]` is only
|
||||
@ -289,7 +288,7 @@ The `iterator_category` member of `iterator_facade` is
|
||||
|
||||
.. parsed-literal::
|
||||
|
||||
*iterator-category*\ (CategoryOrTraversal, value_type, reference)
|
||||
*iterator-category*\ (CategoryOrTraversal, reference, value_type)
|
||||
|
||||
where *iterator-category* is defined as follows:
|
||||
|
||||
@ -297,10 +296,10 @@ where *iterator-category* is defined as follows:
|
||||
|
||||
The `enable_if_interoperable` template used above is for exposition
|
||||
purposes. The member operators should only be in an overload set
|
||||
provided the derived types `Dr1` and `Dr2` are interoperable,
|
||||
provided the derived types `Dr1` and `Dr2` are interoperable,
|
||||
meaning that at least one of the types is convertible to the other. The
|
||||
`enable_if_interoperable` approach uses SFINAE to take the operators
|
||||
out of the overload set when the types are not interoperable.
|
||||
out of the overload set when the types are not interoperable.
|
||||
The operators should behave *as-if* `enable_if_interoperable`
|
||||
were defined to be:
|
||||
|
||||
@ -400,7 +399,7 @@ through member functions of class `iterator_core_access`.
|
||||
__ `operator arrow`_
|
||||
|
||||
[*Returns:] If `reference` is a reference type, an object of type `pointer` equal to: `&static_cast<Derived const*>(this)->dereference()`
|
||||
Otherwise returns an object of unspecified type such that,
|
||||
Otherwise returns an object of unspecified type such that,
|
||||
`(*static_cast<Derived const*>(this))->m` is equivalent to `(w = **static_cast<Derived const*>(this),
|
||||
w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
@ -417,7 +416,7 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
Derived& operator++();
|
||||
|
||||
[*Effects:]
|
||||
[*Effects:]
|
||||
|
||||
static_cast<Derived*>(this)->increment();
|
||||
return *static_cast<Derived*>(this);
|
||||
@ -457,7 +456,7 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
Derived& operator-=(difference_type n);
|
||||
|
||||
[*Effects:]
|
||||
|
||||
|
||||
static_cast<Derived*>(this)->advance(-n);
|
||||
return *static_cast<Derived*>(this);
|
||||
|
||||
@ -493,10 +492,10 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
then
|
||||
`((Dr1 const&)lhs).equal((Dr2 const&)rhs)`.
|
||||
|
||||
Otherwise,
|
||||
Otherwise,
|
||||
`((Dr2 const&)rhs).equal((Dr1 const&)lhs)`.
|
||||
]
|
||||
|
||||
@ -508,14 +507,14 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
|
||||
|
||||
[*Returns:]
|
||||
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
then
|
||||
`!((Dr1 const&)lhs).equal((Dr2 const&)rhs)`.
|
||||
|
||||
Otherwise,
|
||||
Otherwise,
|
||||
`!((Dr2 const&)rhs).equal((Dr1 const&)lhs)`.
|
||||
]
|
||||
|
||||
@ -527,14 +526,14 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
|
||||
|
||||
[*Returns:]
|
||||
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
then
|
||||
`((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) < 0`.
|
||||
|
||||
Otherwise,
|
||||
Otherwise,
|
||||
`((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) > 0`.
|
||||
]
|
||||
|
||||
@ -546,14 +545,14 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
|
||||
|
||||
[*Returns:]
|
||||
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
then
|
||||
`((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) <= 0`.
|
||||
|
||||
Otherwise,
|
||||
Otherwise,
|
||||
`((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) >= 0`.
|
||||
]
|
||||
|
||||
@ -565,14 +564,14 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
|
||||
|
||||
[*Returns:]
|
||||
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
then
|
||||
`((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) > 0`.
|
||||
|
||||
Otherwise,
|
||||
Otherwise,
|
||||
`((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) < 0`.
|
||||
]
|
||||
|
||||
@ -584,14 +583,14 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
|
||||
|
||||
[*Returns:]
|
||||
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
then
|
||||
`((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) >= 0`.
|
||||
|
||||
Otherwise,
|
||||
Otherwise,
|
||||
`((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) <= 0`.
|
||||
]
|
||||
|
||||
@ -605,27 +604,27 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
|
||||
|
||||
[*Return Type:]
|
||||
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
then
|
||||
`difference` shall be
|
||||
`iterator_traits<Dr1>::difference_type`.
|
||||
|
||||
Otherwise
|
||||
Otherwise
|
||||
`difference` shall be `iterator_traits<Dr2>::difference_type`
|
||||
]
|
||||
|
||||
[*Returns:]
|
||||
|
||||
|
||||
[pre
|
||||
if `is_convertible<Dr2,Dr1>::value`
|
||||
|
||||
then
|
||||
then
|
||||
`-((Dr1 const&)lhs).distance_to((Dr2 const&)rhs)`.
|
||||
|
||||
Otherwise,
|
||||
Otherwise,
|
||||
`((Dr2 const&)rhs).distance_to((Dr1 const&)lhs)`.
|
||||
]
|
||||
|
||||
@ -634,4 +633,4 @@ w.m)` for some temporary object `w` of type `value_type`.
|
||||
|
||||
[include facade_tutorial.qbk]
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
@ -1,12 +1,11 @@
|
||||
|
||||
[section:facade_tutorial Tutorial]
|
||||
|
||||
In this section we'll walk through the implementation of a few
|
||||
iterators using `iterator_facade`, based around the simple
|
||||
example of a linked list of polymorphic objects. This example was
|
||||
inspired by a
|
||||
inspired by a
|
||||
[@http://thread.gmane.org/gmane.comp.lib.boost.user/5100 `posting`]
|
||||
by Keith Macdonald on the
|
||||
by Keith Macdonald on the
|
||||
[@http://www.boost.org/more/mailing_lists.htm#users `Boost-Users`]
|
||||
mailing list.
|
||||
|
||||
@ -30,16 +29,16 @@ Say we've written a polymorphic linked list node base class:
|
||||
|
||||
// print to the stream
|
||||
virtual void print(std::ostream& s) const = 0;
|
||||
|
||||
|
||||
// double the value
|
||||
virtual void double_me() = 0;
|
||||
|
||||
void append(node_base* p)
|
||||
{
|
||||
if (m_next)
|
||||
m_next->append(p);
|
||||
if (m_next)
|
||||
m_next->append(p);
|
||||
else
|
||||
m_next = p;
|
||||
m_next = p;
|
||||
}
|
||||
|
||||
private:
|
||||
@ -210,7 +209,7 @@ the concepts we want our iterator to model. Referring to the
|
||||
table__, we can see that the first three rows are applicable
|
||||
because `node_iterator` needs to satisfy the requirements for
|
||||
`readable iterator`_, `single pass iterator`_, and `incrementable
|
||||
iterator`_.
|
||||
iterator`_.
|
||||
|
||||
__ `core operations`_
|
||||
|
||||
@ -254,10 +253,10 @@ make them private and grant friendship to
|
||||
};
|
||||
|
||||
Voila; a complete and conforming readable, forward-traversal
|
||||
iterator! For a working example of its use, see
|
||||
[@../example/node_iterator1.cpp `this program`].
|
||||
iterator! For a working example of its use, see
|
||||
[example_link node_iterator1.cpp..this program].
|
||||
|
||||
__ ../example/node_iterator1.cpp
|
||||
__ ../../example/node_iterator1.cpp
|
||||
|
||||
[h2 A constant `node_iterator`]
|
||||
|
||||
@ -265,7 +264,7 @@ __ ../example/node_iterator1.cpp
|
||||
The term **mutable iterator** means an iterator through which
|
||||
the object it references (its "referent") can be modified. A
|
||||
**constant iterator** is one which doesn't allow modification of
|
||||
its referent.[br][br]
|
||||
its referent.[br][br]
|
||||
The words *constant* and *mutable* don't refer to the ability to
|
||||
modify the iterator itself. For example, an `int const*` is a
|
||||
non-\ `const` *constant iterator*, which can be incremented
|
||||
@ -285,7 +284,7 @@ changes:
|
||||
|
||||
class const_node_iterator
|
||||
: public boost::iterator_facade<
|
||||
node_iterator
|
||||
const_node_iterator
|
||||
, node_base **const**
|
||||
, boost::forward_traversal_tag
|
||||
>
|
||||
@ -402,7 +401,7 @@ adding a templatized converting constructor [#broken]_ [#random]_:
|
||||
|
||||
template <class OtherValue>
|
||||
bool equal(node_iter<OtherValue> const& other) const
|
||||
{
|
||||
{
|
||||
return this->m_node == other.m_node;
|
||||
}
|
||||
|
||||
@ -428,11 +427,11 @@ adding a templatized converting constructor [#broken]_ [#random]_:
|
||||
`distance_to` function as well.
|
||||
|
||||
|
||||
__ ../example/node_iterator2.hpp
|
||||
__ ../../example/node_iterator2.hpp
|
||||
|
||||
You can see an example program which exercises our interoperable
|
||||
iterators
|
||||
[@../example/node_iterator2.cpp `here`].
|
||||
iterators
|
||||
[example_link node_iterator2.cpp..here].
|
||||
|
||||
|
||||
[h2 Telling the Truth]
|
||||
@ -467,7 +466,7 @@ appropriate:
|
||||
|
||||
...
|
||||
|
||||
private:
|
||||
private:
|
||||
struct enabler {};
|
||||
|
||||
public:
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
[section:filter Filter Iterator]
|
||||
|
||||
The filter iterator adaptor creates a view of an iterator range in
|
||||
@ -19,7 +18,6 @@ This example uses `filter_iterator` and then
|
||||
array of integers. Then `make_filter_iterator` is is used to output
|
||||
the integers greater than `-2`.
|
||||
|
||||
|
||||
struct is_positive_number {
|
||||
bool operator()(int x) { return 0 < x; }
|
||||
};
|
||||
@ -33,7 +31,7 @@ the integers greater than `-2`.
|
||||
base_iterator numbers(numbers_);
|
||||
|
||||
// Example using filter_iterator
|
||||
typedef boost::filter_iterator<is_positive_number, base_iterator>
|
||||
typedef boost::filter_iterator<is_positive_number, base_iterator>
|
||||
FilterIter;
|
||||
|
||||
is_positive_number predicate;
|
||||
@ -52,11 +50,11 @@ the integers greater than `-2`.
|
||||
// Another example using make_filter_iterator()
|
||||
std::copy(
|
||||
boost::make_filter_iterator(
|
||||
std::bind2nd(std::greater<int>(), -2)
|
||||
std::bind(std::greater<int>(), std::placeholders::_1, -2)
|
||||
, numbers, numbers + N)
|
||||
|
||||
, boost::make_filter_iterator(
|
||||
std::bind2nd(std::greater<int>(), -2)
|
||||
std::bind(std::greater<int>(), std::placeholders::_1, -2)
|
||||
, numbers + N, numbers + N)
|
||||
|
||||
, std::ostream_iterator<int>(std::cout, " ")
|
||||
@ -70,12 +68,13 @@ the integers greater than `-2`.
|
||||
|
||||
The output is:
|
||||
|
||||
4 5 8
|
||||
4 5 8
|
||||
0 -1 4 5 8
|
||||
[pre
|
||||
4 5 8
|
||||
4 5 8
|
||||
0 -1 4 5 8
|
||||
]
|
||||
|
||||
|
||||
The source code for this example can be found [@../example/filter_iterator_example.cpp here].
|
||||
The source code for this example can be found [example_link filter_iterator_example.cpp..here].
|
||||
|
||||
[h2 Reference]
|
||||
|
||||
@ -114,10 +113,10 @@ The source code for this example can be found [@../example/filter_iterator_examp
|
||||
|
||||
If `Iterator` models Readable Lvalue Iterator and Bidirectional Traversal
|
||||
Iterator then `iterator_category` is convertible to
|
||||
`std::bidirectional_iterator_tag`.
|
||||
`std::bidirectional_iterator_tag`.
|
||||
Otherwise, if `Iterator` models Readable Lvalue Iterator and Forward Traversal
|
||||
Iterator then `iterator_category` is convertible to
|
||||
`std::forward_iterator_tag`.
|
||||
`std::forward_iterator_tag`.
|
||||
Otherwise `iterator_category` is
|
||||
convertible to `std::input_iterator_tag`.
|
||||
|
||||
@ -164,7 +163,7 @@ following tables.
|
||||
[[Writable Lvalue Iterator, Bidirectional Iterator ][Mutable Bidirectional Iterator]]
|
||||
]
|
||||
|
||||
`filter_iterator<P1, X>` is interoperable with `filter_iterator<P2, Y>`
|
||||
`filter_iterator<P1, X>` is interoperable with `filter_iterator<P2, Y>`
|
||||
if and only if `X` is interoperable with `Y`.
|
||||
|
||||
|
||||
@ -179,14 +178,14 @@ operations.
|
||||
filter_iterator();
|
||||
|
||||
[*Requires: ]`Predicate` and `Iterator` must be Default Constructible.[br]
|
||||
[*Effects: ] Constructs a `filter_iterator` whose`m_pred`, `m_iter`, and `m_end`
|
||||
[*Effects: ] Constructs a `filter_iterator` whose`m_pred`, `m_iter`, and `m_end`
|
||||
members are a default constructed.
|
||||
|
||||
|
||||
filter_iterator(Predicate f, Iterator x, Iterator end = Iterator());
|
||||
|
||||
[*Effects: ] Constructs a `filter_iterator` where `m_iter` is either
|
||||
the first position in the range `[x,end)` such that `f(*m_iter) == true`
|
||||
the first position in the range `[x,end)` such that `f(*m_iter) == true`
|
||||
or else`m_iter == end`. The member `m_pred` is constructed from
|
||||
`f` and `m_end` from `end`.
|
||||
|
||||
@ -197,7 +196,7 @@ operations.
|
||||
[*Requires: ] `Predicate` must be Default Constructible and
|
||||
`Predicate` is a class type (not a function pointer).[br]
|
||||
[*Effects: ] Constructs a `filter_iterator` where `m_iter` is either
|
||||
the first position in the range `[x,end)` such that `m_pred(*m_iter) == true`
|
||||
the first position in the range `[x,end)` such that `m_pred(*m_iter) == true`
|
||||
or else`m_iter == end`. The member `m_pred` is default constructed.
|
||||
|
||||
|
||||
@ -236,7 +235,6 @@ operations.
|
||||
[*Effects: ] Increments `m_iter` and then continues to
|
||||
increment `m_iter` until either `m_iter == m_end`
|
||||
or `m_pred(*m_iter) == true`.[br]
|
||||
[*Returns: ] `*this`
|
||||
[*Returns: ] `*this`
|
||||
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
[section:function_output Function Output Iterator]
|
||||
|
||||
The function output iterator adaptor makes it easier to create custom
|
||||
@ -34,8 +33,8 @@ proxy object.
|
||||
x.push_back("!");
|
||||
|
||||
std::string s = "";
|
||||
std::copy(x.begin(), x.end(),
|
||||
boost::make_function_output_iterator(string_appender(s)));
|
||||
std::copy(x.begin(), x.end(),
|
||||
boost::make_function_output_iterator(string_appender(s)));
|
||||
|
||||
std::cout << s << std::endl;
|
||||
|
||||
@ -68,7 +67,7 @@ proxy object.
|
||||
|
||||
[h3 Requirements]
|
||||
|
||||
`UnaryFunction` must be Assignable and Copy Constructible.
|
||||
`UnaryFunction` must be Assignable and Copy Constructible.
|
||||
|
||||
[h3 Concepts]
|
||||
|
||||
@ -79,14 +78,14 @@ Incrementable Iterator concepts.
|
||||
|
||||
explicit function_output_iterator(const UnaryFunction& f = UnaryFunction());
|
||||
|
||||
[*Effects: ] Constructs an instance of `function_output_iterator`
|
||||
[*Effects: ] Constructs an instance of `function_output_iterator`
|
||||
with `m_f` constructed from `f`.
|
||||
|
||||
unspecified_type operator*();
|
||||
|
||||
[*Returns: ] An object `r` of unspecified type such that `r = t`
|
||||
is equivalent to `m_f(t)` for all `t`.
|
||||
|
||||
|
||||
|
||||
function_output_iterator& operator++();
|
||||
|
||||
@ -97,4 +96,4 @@ Incrementable Iterator concepts.
|
||||
|
||||
[*Returns: ] `*this`.
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
[section:indirect Indirect Iterator]
|
||||
|
||||
`indirect_iterator` adapts an iterator by applying an
|
||||
@ -50,30 +49,31 @@ using the `make_indirect_iterator` helper function.
|
||||
const_indirect_last(pointers_to_chars + N);
|
||||
|
||||
std::transform(const_indirect_first, const_indirect_last,
|
||||
mutable_indirect_first, std::bind1st(std::plus<char>(), 1));
|
||||
mutable_indirect_first, std::bind(std::plus<char>(), 1, std::placeholders::_1));
|
||||
|
||||
std::copy(mutable_indirect_first, mutable_indirect_last,
|
||||
std::ostream_iterator<char>(std::cout, ","));
|
||||
std::ostream_iterator<char>(std::cout, ","));
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
// Example of using make_indirect_iterator()
|
||||
|
||||
std::copy(boost::make_indirect_iterator(pointers_to_chars),
|
||||
boost::make_indirect_iterator(pointers_to_chars + N),
|
||||
std::ostream_iterator<char>(std::cout, ","));
|
||||
std::copy(boost::make_indirect_iterator(pointers_to_chars),
|
||||
boost::make_indirect_iterator(pointers_to_chars + N),
|
||||
std::ostream_iterator<char>(std::cout, ","));
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
The output is:
|
||||
|
||||
a,b,c,d,e,f,g,
|
||||
b,c,d,e,f,g,h,
|
||||
a,b,c,d,e,f,g,
|
||||
[pre
|
||||
a,b,c,d,e,f,g,
|
||||
b,c,d,e,f,g,h,
|
||||
a,b,c,d,e,f,g,
|
||||
]
|
||||
|
||||
|
||||
The source code for this example can be found
|
||||
[@../example/indirect_iterator_example.cpp here].
|
||||
The source code for this example can be found
|
||||
[example_link indirect_iterator_example.cpp..here].
|
||||
|
||||
|
||||
[h2 Reference]
|
||||
@ -137,9 +137,9 @@ the following pseudo-code, where `V` is
|
||||
else
|
||||
typedef Reference reference;
|
||||
|
||||
if (Value is use_default) then
|
||||
if (Value is use_default) then
|
||||
typedef pointee<V>::type\* pointer;
|
||||
else
|
||||
else
|
||||
typedef Value\* pointer;
|
||||
|
||||
if (Difference is use_default)
|
||||
@ -204,7 +204,7 @@ following operations:
|
||||
indirect_iterator();
|
||||
|
||||
[*Requires: ] `Iterator` must be Default Constructible.[br]
|
||||
[*Effects: ] Constructs an instance of `indirect_iterator` with
|
||||
[*Effects: ] Constructs an instance of `indirect_iterator` with
|
||||
a default-constructed `m_iterator`.
|
||||
|
||||
|
||||
@ -226,7 +226,7 @@ following operations:
|
||||
);
|
||||
|
||||
[*Requires: ] `Iterator2` is implicitly convertible to `Iterator`.[br]
|
||||
[*Effects: ] Constructs an instance of `indirect_iterator` whose
|
||||
[*Effects: ] Constructs an instance of `indirect_iterator` whose
|
||||
`m_iterator` subobject is constructed from `y.base()`.
|
||||
|
||||
|
||||
@ -251,4 +251,4 @@ following operations:
|
||||
[*Effects: ] `--m_iterator`[br]
|
||||
[*Returns: ] `*this`
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
[library Boost.Iterator
|
||||
[/ version 1.0.1]
|
||||
[quickbook 1.6]
|
||||
@ -29,7 +28,11 @@
|
||||
|
||||
[/ Links ]
|
||||
|
||||
[def _iterator_ [@../../libs/iterator/doc/index.html Boost.Iterator]]
|
||||
[def _iterator_ [@../../../iterator/doc/index.html Boost.Iterator]]
|
||||
[def _concept_check_ [@../../../concept_check/index.html Boost.ConceptCheck]]
|
||||
[template example_link[name descr]'''<ulink url="../../example/'''[name]'''">'''[descr]'''</ulink>''']
|
||||
|
||||
[template sub[x]'''<subscript>'''[x]'''</subscript>''']
|
||||
|
||||
[section:intro Introduction]
|
||||
|
||||
@ -71,19 +74,23 @@ and a _GOTW_50_. New-style iterators go well beyond
|
||||
patching up `vector<bool>`, though: there are lots of other
|
||||
iterators already in use which can't be adequately represented by
|
||||
the existing concepts. For details about the new iterator
|
||||
concepts, see our [@./new-iter-concepts.html Standard Proposal for New-Style Iterators].
|
||||
concepts, see our [@../new-iter-concepts.html Standard Proposal for New-Style Iterators].
|
||||
|
||||
[h2 Iterator Facade and Adaptor]
|
||||
|
||||
[def _facade_ [@./iterator_facade.html facade]]
|
||||
[def _adaptor_ [@./iterator_adaptor.html adaptor]]
|
||||
[/
|
||||
[def _facade_ [link iterator.generic.facade facade]]
|
||||
[def _adaptor_ [link iterator.generic.adaptor adaptor]]
|
||||
]
|
||||
[def _facade_ [@../iterator_facade.html facade]]
|
||||
[def _adaptor_ [@../iterator_adaptor.html adaptor]]
|
||||
|
||||
Writing standard-conforming iterators is tricky, but the need comes
|
||||
up often. In order to ease the implementation of new iterators,
|
||||
the Boost.Iterator library provides the _facade_ class template,
|
||||
which implements many useful defaults and compile-time checks
|
||||
designed to help the iterator author ensure that his iterator is
|
||||
correct.
|
||||
correct.
|
||||
|
||||
It is also common to define a new iterator that is similar to some
|
||||
underlying iterator or iterator-like type, but that modifies some
|
||||
@ -92,9 +99,9 @@ library supplies the _adaptor_ class template, which is specially
|
||||
designed to take advantage of as much of the underlying type's
|
||||
behavior as possible.
|
||||
|
||||
Both _facade_ and _adaptor_ as well as many of the `specialized
|
||||
adaptors`_ mentioned below have been proposed for standardization
|
||||
([@./facade-and-adaptor.html Standard Proposal For Iterator Facade and Adaptor]).
|
||||
Both _facade_ and _adaptor_ as well as many of the [link iterator.specialized specialized
|
||||
adaptors] mentioned below have been proposed for standardization
|
||||
([@../facade-and-adaptor.html Standard Proposal For Iterator Facade and Adaptor]).
|
||||
|
||||
[h2 Specialized Adaptors]
|
||||
|
||||
@ -103,15 +110,17 @@ iterator templates based on the Boost [link
|
||||
iterator.intro.iterator_facade_and_adaptor iterator facade and adaptor]
|
||||
templates.
|
||||
|
||||
[def _counting_ [@./counting_iterator.html `counting_iterator`]]
|
||||
[def _filter_ [@./filter_iterator.html `filter_iterator`]]
|
||||
[def _function_ [@./function_output_iterator.html `function_output_iterator`]]
|
||||
[def _indirect_ [@./indirect_iterator.html `indirect_iterator`]]
|
||||
[def _permutation_ [@./permutation_iterator.html `permutation_iterator`]]
|
||||
[def _reverse_ [@./reverse_iterator.html `reverse_iterator`]]
|
||||
[def _shared_ [@./shared_container_iterator.html `shared_container_iterator`]]
|
||||
[def _transform_ [@./transform_iterator.html `transform_iterator`]]
|
||||
[def _zip_ [@./zip_iterator.html `zip_iterator`]]
|
||||
[def _counting_ [link iterator.specialized.counting `counting_iterator`]]
|
||||
[def _filter_ [link iterator.specialized.filter `filter_iterator`]]
|
||||
[def _function_input_ [@../function_input_iterator.html `function_input_iterator`]]
|
||||
[def _function_output_ [link iterator.specialized.function_output `function_output_iterator`]]
|
||||
[def _generator_ [@../generator_iterator.htm `generator_iterator`]]
|
||||
[def _indirect_ [link iterator.specialized.indirect `indirect_iterator`]]
|
||||
[def _permutation_ [link iterator.specialized.permutation `permutation_iterator`]]
|
||||
[def _reverse_ [link iterator.specialized.reverse `reverse_iterator`]]
|
||||
[def _shared_ [link iterator.specialized.shared_container `shared_container_iterator`]]
|
||||
[def _transform_ [link iterator.specialized.transform `transform_iterator`]]
|
||||
[def _zip_ [link iterator.specialized.zip `zip_iterator`]]
|
||||
|
||||
[def _shared_ptr_ [@../../smart_ptr/shared_ptr.htm `shared_ptr`]]
|
||||
|
||||
@ -121,10 +130,18 @@ templates.
|
||||
* _filter_: an iterator over the subset of elements of some
|
||||
sequence which satisfy a given predicate
|
||||
|
||||
* _function_: an output iterator wrapping a unary function
|
||||
* _function_input_: an input iterator wrapping a generator (nullary
|
||||
function object); each time the iterator is dereferenced, the function object
|
||||
is called to get the value to return.
|
||||
|
||||
* _function_output_: an output iterator wrapping a unary function
|
||||
object; each time an element is written into the dereferenced
|
||||
iterator, it is passed as a parameter to the function object.
|
||||
|
||||
* _generator_: an input iterator wrapping a generator (nullary
|
||||
function object); each time the iterator is dereferenced, the function object
|
||||
is called to get the value to return. An outdated analogue of _function_input_.
|
||||
|
||||
* _indirect_: an iterator over the objects *pointed-to* by the
|
||||
elements of some sequence.
|
||||
|
||||
@ -133,7 +150,7 @@ templates.
|
||||
|
||||
* _reverse_: an iterator which traverses the elements of some
|
||||
bidirectional sequence in reverse. Corrects many of the
|
||||
shortcomings of C++98's ``std::reverse_iterator``.
|
||||
shortcomings of C++98's `std::reverse_iterator`.
|
||||
|
||||
* _shared_: an iterator over elements of a container whose
|
||||
lifetime is maintained by a _shared_ptr_ stored in the iterator.
|
||||
@ -141,7 +158,7 @@ templates.
|
||||
* _transform_: an iterator over elements which are the result of
|
||||
applying some functional transformation to the elements of an
|
||||
underlying sequence. This component also replaces the old
|
||||
``projection_iterator_adaptor``.
|
||||
`projection_iterator_adaptor`.
|
||||
|
||||
* _zip_: an iterator over tuples of the elements at corresponding
|
||||
positions of heterogeneous underlying iterators.
|
||||
@ -150,9 +167,9 @@ templates.
|
||||
|
||||
[h3 Traits]
|
||||
|
||||
[def _pointee_ [@./pointee.html `pointee.hpp`]]
|
||||
[def _iterator_traits_ [@./iterator_traits.html `iterator_traits.hpp`]]
|
||||
[def _interoperable_ [@./interoperable.html `interoperable.hpp`]]
|
||||
[def _pointee_ [link iterator.utilities.traits `pointee.hpp`]]
|
||||
[def _iterator_traits_ [link iterator.utilities.iterator_traits `iterator_traits.hpp`]]
|
||||
[def _interoperable_ [@../interoperable.html `interoperable.hpp`]]
|
||||
[def _MPL_ [@../../mpl/doc/index.html [*MPL]]]
|
||||
|
||||
* _pointee_: Provides the capability to deduce the referent types
|
||||
@ -163,19 +180,40 @@ templates.
|
||||
retrieve an iterator's traits. Also corrects for the deficiencies
|
||||
of broken implementations of `std::iterator_traits`.
|
||||
|
||||
[\ * |interoperable|_ (PDF__): Provides an _MPL_ compatible metafunction for
|
||||
testing iterator interoperability
|
||||
[/
|
||||
* _interoperable_: Provides an _MPL_ compatible metafunction for
|
||||
testing iterator interoperability
|
||||
]
|
||||
|
||||
[h3 Testing and Concept Checking]
|
||||
|
||||
[def _iterator_concepts_ [@./iterator_concepts.html `iterator_concepts.hpp`]]
|
||||
[def _iterator_archetypes_ [@./iterator_archetypes.html `iterator_archetypes.hpp`]]
|
||||
[def _iterator_concepts_ [link iterator.concepts `iterator_concepts.hpp`]]
|
||||
[def _iterator_archetypes_ [link iterator.utilities.archetypes `iterator_archetypes.hpp`]]
|
||||
|
||||
* _iterator_concepts_: Concept checking classes for the new iterator concepts.
|
||||
|
||||
* _iterator_archetypes_: Concept archetype classes for the new iterators concepts.
|
||||
|
||||
[h2 Iterator Algorithms]
|
||||
|
||||
The library provides a number of generic algorithms for use with iterators. These
|
||||
algorithms take advantage of the new concepts defined by the library to provide
|
||||
better performance and functionality.
|
||||
|
||||
[def _advance_ [link iterator.algorithms.advance `advance.hpp`]]
|
||||
[def _distance_ [link iterator.algorithms.distance `distance.hpp`]]
|
||||
[def _next_prior_ [link iterator.algorithms.next_prior `next_prior.hpp`]]
|
||||
|
||||
* _advance_: Provides `advance()` function for advancing an iterator a given number
|
||||
of positions forward or backward.
|
||||
|
||||
* _distance_: Provides `distance()` function for computing distance between two
|
||||
iterators.
|
||||
|
||||
* _next_prior_: Provides `next()` and `prior()` functions for obtaining
|
||||
next and prior iterators to a given iterator. The functions are also compatible
|
||||
with non-iterator types.
|
||||
|
||||
[endsect]
|
||||
|
||||
[include concepts.qbk]
|
||||
@ -196,12 +234,14 @@ templates.
|
||||
|
||||
[include concept_checking.qbk]
|
||||
|
||||
[include traits.qbk]
|
||||
[include iterator_traits.qbk]
|
||||
|
||||
[include utilities.qbk]
|
||||
[include type_traits.qbk]
|
||||
|
||||
[endsect]
|
||||
|
||||
[include algorithms.qbk]
|
||||
|
||||
[section:upgrading Upgrading from the old Boost Iterator Adaptor Library]
|
||||
|
||||
[def _type_generator_ [@http://www.boost.org/more/generic_programming.html#type_generator type generator]]
|
||||
@ -265,5 +305,3 @@ library you see today.
|
||||
Patterns, C++ Report, February 1995, pp. 24-27.]
|
||||
|
||||
[endsect]
|
||||
|
||||
|
@ -1,5 +1,4 @@
|
||||
|
||||
[section:traits Iterator Traits]
|
||||
[section:iterator_traits Iterator Traits]
|
||||
|
||||
`std::iterator_traits` provides access to five associated types
|
||||
of any iterator: its `value_type`, `reference`, `pointer`,
|
||||
@ -15,15 +14,15 @@ Header `<boost/iterator/iterator_traits.hpp>`:
|
||||
template <class Iterator>
|
||||
struct iterator_value
|
||||
{
|
||||
typedef typename
|
||||
std::iterator_traits<Iterator>::value_type
|
||||
typedef typename
|
||||
std::iterator_traits<Iterator>::value_type
|
||||
type;
|
||||
};
|
||||
|
||||
template <class Iterator>
|
||||
struct iterator_reference
|
||||
{
|
||||
typedef typename
|
||||
typedef typename
|
||||
std::iterator_traits<Iterator>::reference
|
||||
type;
|
||||
};
|
||||
@ -31,8 +30,8 @@ Header `<boost/iterator/iterator_traits.hpp>`:
|
||||
template <class Iterator>
|
||||
struct iterator_pointer
|
||||
{
|
||||
typedef typename
|
||||
std::iterator_traits<Iterator>::pointer
|
||||
typedef typename
|
||||
std::iterator_traits<Iterator>::pointer
|
||||
type;
|
||||
};
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
[section:permutation Permutation Iterator]
|
||||
|
||||
The permutation iterator adaptor provides a permuted view of a given
|
||||
@ -35,7 +34,7 @@ past-the-end iterator to the indices.
|
||||
*el_it = std::distance(elements.begin(), el_it);
|
||||
|
||||
index_type indices( index_size );
|
||||
for(index_type::iterator i_it = indices.begin() ; i_it != indices.end() ; ++i_it )
|
||||
for(index_type::iterator i_it = indices.begin() ; i_it != indices.end() ; ++i_it )
|
||||
*i_it = element_range_size - index_size + std::distance(indices.begin(), i_it);
|
||||
std::reverse( indices.begin(), indices.end() );
|
||||
|
||||
@ -75,27 +74,28 @@ past-the-end iterator to the indices.
|
||||
|
||||
The output is:
|
||||
|
||||
The original range is : 0 1 2 3 4 5 6 7 8 9
|
||||
The reindexing scheme is : 9 8 7 6
|
||||
The permutated range is : 9 8 7 6
|
||||
Elements at even indices in the permutation : 9 7
|
||||
Permutation backwards : 6 7 8 9
|
||||
Iterate backward with stride 2 : 6 8
|
||||
|
||||
[pre
|
||||
The original range is : 0 1 2 3 4 5 6 7 8 9
|
||||
The reindexing scheme is : 9 8 7 6
|
||||
The permutated range is : 9 8 7 6
|
||||
Elements at even indices in the permutation : 9 7
|
||||
Permutation backwards : 6 7 8 9
|
||||
Iterate backward with stride 2 : 6 8
|
||||
]
|
||||
|
||||
The source code for this example can be found
|
||||
[@../example/permutation_iter_example.cpp here].
|
||||
[example_link permutation_iter_example.cpp..here].
|
||||
|
||||
[h2 Reference]
|
||||
|
||||
[h3 Synopsis]
|
||||
|
||||
template< class ElementIterator
|
||||
, class IndexIterator
|
||||
, class ValueT = use_default
|
||||
, class CategoryT = use_default
|
||||
, class ReferenceT = use_default
|
||||
, class DifferenceT = use_default >
|
||||
, class IndexIterator
|
||||
, class ValueT = use_default
|
||||
, class CategoryT = use_default
|
||||
, class ReferenceT = use_default
|
||||
, class DifferenceT = use_default >
|
||||
class permutation_iterator
|
||||
{
|
||||
public:
|
||||
@ -104,10 +104,10 @@ The source code for this example can be found
|
||||
|
||||
template< class OEIter, class OIIter, class V, class C, class R, class D >
|
||||
permutation_iterator(
|
||||
permutation_iterator<OEIter, OIIter, V, C, R, D> const& r
|
||||
, typename enable_if_convertible<OEIter, ElementIterator>::type* = 0
|
||||
, typename enable_if_convertible<OIIter, IndexIterator>::type* = 0
|
||||
);
|
||||
permutation_iterator<OEIter, OIIter, V, C, R, D> const& r
|
||||
, typename enable_if_convertible<OEIter, ElementIterator>::type* = 0
|
||||
, typename enable_if_convertible<OIIter, IndexIterator>::type* = 0
|
||||
);
|
||||
reference operator*() const;
|
||||
permutation_iterator& operator++();
|
||||
ElementIterator const& base() const;
|
||||
@ -117,7 +117,7 @@ The source code for this example can be found
|
||||
};
|
||||
|
||||
template <class ElementIterator, class IndexIterator>
|
||||
permutation_iterator<ElementIterator, IndexIterator>
|
||||
permutation_iterator<ElementIterator, IndexIterator>
|
||||
make_permutation_iterator( ElementIterator e, IndexIterator i);
|
||||
|
||||
|
||||
@ -134,15 +134,15 @@ the `IndexIterator` must be convertible to the difference type of
|
||||
as `IndexIterator` and the same iterator access concepts as
|
||||
`ElementIterator`.
|
||||
|
||||
If `IndexIterator` models Single Pass Iterator and
|
||||
If `IndexIterator` models Single Pass Iterator and
|
||||
`ElementIterator` models Readable Iterator then
|
||||
`permutation_iterator` models Input Iterator.
|
||||
|
||||
If `IndexIterator` models Forward Traversal Iterator and
|
||||
If `IndexIterator` models Forward Traversal Iterator and
|
||||
`ElementIterator` models Readable Lvalue Iterator then
|
||||
`permutation_iterator` models Forward Iterator.
|
||||
|
||||
If `IndexIterator` models Bidirectional Traversal Iterator and
|
||||
If `IndexIterator` models Bidirectional Traversal Iterator and
|
||||
`ElementIterator` models Readable Lvalue Iterator then
|
||||
`permutation_iterator` models Bidirectional Iterator.
|
||||
|
||||
@ -173,10 +173,10 @@ following operations.
|
||||
|
||||
template< class OEIter, class OIIter, class V, class C, class R, class D >
|
||||
permutation_iterator(
|
||||
permutation_iterator<OEIter, OIIter, V, C, R, D> const& r
|
||||
, typename enable_if_convertible<OEIter, ElementIterator>::type* = 0
|
||||
, typename enable_if_convertible<OIIter, IndexIterator>::type* = 0
|
||||
);
|
||||
permutation_iterator<OEIter, OIIter, V, C, R, D> const& r
|
||||
, typename enable_if_convertible<OEIter, ElementIterator>::type* = 0
|
||||
, typename enable_if_convertible<OIIter, IndexIterator>::type* = 0
|
||||
);
|
||||
|
||||
[*Effects: ] Constructs `m_elt` from `r.m_elt` and
|
||||
`m_order` from `y.m_order`.
|
||||
@ -199,9 +199,9 @@ following operations.
|
||||
|
||||
|
||||
template <class ElementIterator, class IndexIterator>
|
||||
permutation_iterator<ElementIterator, IndexIterator>
|
||||
permutation_iterator<ElementIterator, IndexIterator>
|
||||
make_permutation_iterator(ElementIterator e, IndexIterator i);
|
||||
|
||||
[*Returns: ] `permutation_iterator<ElementIterator, IndexIterator>(e, i)`
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
[section:reverse Reverse Iterator]
|
||||
|
||||
The reverse iterator adaptor iterates through the adapted iterator
|
||||
@ -9,7 +8,6 @@ range in the opposite direction.
|
||||
The following example prints an array of characters in reverse order
|
||||
using `reverse_iterator`.
|
||||
|
||||
|
||||
char letters_[] = "hello world!";
|
||||
const int N = sizeof(letters_)/sizeof(char) - 1;
|
||||
typedef char* base_iterator;
|
||||
@ -35,13 +33,14 @@ using `reverse_iterator`.
|
||||
|
||||
The output is:
|
||||
|
||||
original sequence of letters: hello world!
|
||||
sequence in reverse order: !dlrow olleh
|
||||
sequence in double-reversed (normal) order: hello world!
|
||||
|
||||
[pre
|
||||
original sequence of letters: hello world!
|
||||
sequence in reverse order: !dlrow olleh
|
||||
sequence in double-reversed (normal) order: hello world!
|
||||
]
|
||||
|
||||
The source code for this example can be found
|
||||
[@../example/reverse_iterator_example.cpp here].
|
||||
[example_link reverse_iterator_example.cpp..here].
|
||||
|
||||
[h2 Reference]
|
||||
|
||||
@ -116,7 +115,7 @@ operations.
|
||||
reverse_iterator();
|
||||
|
||||
[*Requires: ] `Iterator` must be Default Constructible.[br]
|
||||
[*Effects: ] Constructs an instance of `reverse_iterator` with `m_iterator`
|
||||
[*Effects: ] Constructs an instance of `reverse_iterator` with `m_iterator`
|
||||
default constructed.
|
||||
|
||||
explicit reverse_iterator(Iterator x);
|
||||
@ -132,7 +131,7 @@ operations.
|
||||
);
|
||||
|
||||
[*Requires: ] `OtherIterator` is implicitly convertible to `Iterator`.[br]
|
||||
[*Effects: ] Constructs instance of `reverse_iterator` whose
|
||||
[*Effects: ] Constructs instance of `reverse_iterator` whose
|
||||
`m_iterator` subobject is constructed from `y.base()`.
|
||||
|
||||
|
||||
@ -157,4 +156,4 @@ operations.
|
||||
[*Effects: ] `++m_iterator`[br]
|
||||
[*Returns: ] `*this`
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
[section:shared_container Shared Container Iterator]
|
||||
|
||||
Defined in header [@../../../boost/shared_container_iterator.hpp `boost/shared_container_iterator.hpp`].
|
||||
@ -27,12 +26,12 @@ iterator.
|
||||
namespace boost {
|
||||
template <typename Container>
|
||||
class shared_container_iterator;
|
||||
|
||||
|
||||
template <typename Container>
|
||||
shared_container_iterator<Container>
|
||||
make_shared_container_iterator(typename Container::iterator base,
|
||||
make_shared_container_iterator(typename Container::iterator base,
|
||||
boost::shared_ptr<Container> const& container);
|
||||
|
||||
|
||||
std::pair<
|
||||
typename shared_container_iterator<Container>,
|
||||
typename shared_container_iterator<Container>
|
||||
@ -46,7 +45,7 @@ iterator.
|
||||
|
||||
The class template `shared_container_iterator` is the shared container
|
||||
iterator type. The `Container` template type argument must model the
|
||||
[@http://www.sgi.com/tech/stl/Container.html Container] concept.
|
||||
[@http://www.sgi.com/tech/stl/Container.html Container] concept.
|
||||
|
||||
[h2 Example]
|
||||
|
||||
@ -56,48 +55,50 @@ original shared pointer `ints` ceases to exist after `set_range()`
|
||||
returns, the `shared_counter_iterator` objects maintain references to
|
||||
the underlying vector and thereby extend the container's lifetime.
|
||||
|
||||
[@../../../libs/utility/shared_iterator_example1.cpp `shared_iterator_example1.cpp`]:
|
||||
[example_link shared_iterator_example1.cpp..`shared_iterator_example1.cpp`]:
|
||||
|
||||
#include "shared_container_iterator.hpp"
|
||||
#include "boost/shared_ptr.hpp"
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
|
||||
typedef boost::shared_container_iterator< std::vector<int> > iterator;
|
||||
|
||||
|
||||
|
||||
|
||||
void set_range(iterator& i, iterator& end) {
|
||||
|
||||
|
||||
boost::shared_ptr< std::vector<int> > ints(new std::vector<int>());
|
||||
|
||||
|
||||
ints->push_back(0);
|
||||
ints->push_back(1);
|
||||
ints->push_back(2);
|
||||
ints->push_back(3);
|
||||
ints->push_back(4);
|
||||
ints->push_back(5);
|
||||
|
||||
|
||||
i = iterator(ints->begin(),ints);
|
||||
end = iterator(ints->end(),ints);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
int main() {
|
||||
|
||||
|
||||
iterator i,end;
|
||||
|
||||
|
||||
set_range(i,end);
|
||||
|
||||
|
||||
std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
|
||||
std::cout.put('\n');
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
The output from this part is:
|
||||
|
||||
0,1,2,3,4,5,
|
||||
[pre
|
||||
0,1,2,3,4,5,
|
||||
]
|
||||
|
||||
[table Template Parameters
|
||||
[[Parameter][Description]]
|
||||
@ -130,16 +131,16 @@ iterator will be valid. In addition it has the following constructor:
|
||||
boost::shared_ptr<Container> const& container)
|
||||
|
||||
This function provides an alternative to directly constructing a
|
||||
`shared_container_iterator`. Using the object generator, a
|
||||
`shared_container_iterator`. Using the object generator, a
|
||||
`shared_container_iterator` can be created and passed to a function without
|
||||
explicitly specifying its type.
|
||||
|
||||
[h2 Example]
|
||||
|
||||
This example, similar to the previous,
|
||||
This example, similar to the previous,
|
||||
uses `make_shared_container_iterator()` to create the iterators.
|
||||
|
||||
[@../../../libs/utility/shared_iterator_example2.cpp `shared_iterator_example2.cpp`]:
|
||||
[example_link shared_iterator_example2.cpp..`shared_iterator_example2.cpp`]:
|
||||
|
||||
#include "shared_container_iterator.hpp"
|
||||
#include "boost/shared_ptr.hpp"
|
||||
@ -147,35 +148,35 @@ uses `make_shared_container_iterator()` to create the iterators.
|
||||
#include <iterator>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename Iterator>
|
||||
void print_range_nl (Iterator begin, Iterator end) {
|
||||
typedef typename std::iterator_traits<Iterator>::value_type val;
|
||||
std::copy(begin,end,std::ostream_iterator<val>(std::cout,","));
|
||||
std::cout.put('\n');
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
int main() {
|
||||
|
||||
|
||||
typedef boost::shared_ptr< std::vector<int> > ints_t;
|
||||
{
|
||||
ints_t ints(new std::vector<int>());
|
||||
|
||||
|
||||
ints->push_back(0);
|
||||
ints->push_back(1);
|
||||
ints->push_back(2);
|
||||
ints->push_back(3);
|
||||
ints->push_back(4);
|
||||
ints->push_back(5);
|
||||
|
||||
|
||||
print_range_nl(boost::make_shared_container_iterator(ints->begin(),ints),
|
||||
boost::make_shared_container_iterator(ints->end(),ints));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -200,18 +201,18 @@ named. The output from this example is the same as the previous.
|
||||
|
||||
In the following example, a range of values is returned as a pair of shared_container_iterator objects.
|
||||
|
||||
[@../../../libs/utility/shared_iterator_example3.cpp `shared_iterator_example3.cpp`]:
|
||||
[example_link shared_iterator_example3.cpp..`shared_iterator_example3.cpp`]:
|
||||
|
||||
#include "shared_container_iterator.hpp"
|
||||
#include "boost/shared_ptr.hpp"
|
||||
#include "boost/tuple/tuple.hpp" // for boost::tie
|
||||
#include <algorithm> // for std::copy
|
||||
#include <iostream>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
|
||||
typedef boost::shared_container_iterator< std::vector<int> > iterator;
|
||||
|
||||
|
||||
|
||||
typedef boost::shared_container_iterator< std::vector<int> > iterator;
|
||||
|
||||
std::pair<iterator,iterator>
|
||||
return_range() {
|
||||
boost::shared_ptr< std::vector<int> > range(new std::vector<int>());
|
||||
@ -223,18 +224,18 @@ In the following example, a range of values is returned as a pair of shared_cont
|
||||
range->push_back(5);
|
||||
return boost::make_shared_container_range(range);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
int main() {
|
||||
|
||||
|
||||
|
||||
|
||||
iterator i,end;
|
||||
|
||||
|
||||
boost::tie(i,end) = return_range();
|
||||
|
||||
|
||||
std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
|
||||
std::cout.put('\n');
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -245,4 +246,4 @@ the same as the previous two.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
[section:specialized Specialized Adaptors]
|
||||
|
||||
[include ./counting_iterator.qbk]
|
||||
@ -19,4 +18,4 @@
|
||||
|
||||
[include ./zip_iterator.qbk]
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
@ -1,4 +1,3 @@
|
||||
|
||||
[section:transform Transform Iterator]
|
||||
|
||||
The transform iterator adapts an iterator by modifying the
|
||||
@ -14,37 +13,38 @@ generate iterators that multiply (or add to) the value returned by
|
||||
dereferencing the iterator. It would be cooler to use lambda library
|
||||
in this example.
|
||||
|
||||
int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
|
||||
const int N = sizeof(x)/sizeof(int);
|
||||
|
||||
typedef boost::binder1st< std::multiplies<int> > Function;
|
||||
typedef boost::transform_iterator<Function, int*> doubling_iterator;
|
||||
|
||||
doubling_iterator i(x, boost::bind1st(std::multiplies<int>(), 2)),
|
||||
i_end(x + N, boost::bind1st(std::multiplies<int>(), 2));
|
||||
|
||||
std::cout << "multiplying the array by 2:" << std::endl;
|
||||
while (i != i_end)
|
||||
std::cout << *i++ << " ";
|
||||
std::cout << std::endl;
|
||||
|
||||
std::cout << "adding 4 to each element in the array:" << std::endl;
|
||||
std::copy(boost::make_transform_iterator(x, boost::bind1st(std::plus<int>(), 4)),
|
||||
boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
|
||||
std::ostream_iterator<int>(std::cout, " "));
|
||||
std::cout << std::endl;
|
||||
int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
|
||||
const int N = sizeof(x)/sizeof(int);
|
||||
|
||||
typedef boost::binder1st< std::multiplies<int> > Function;
|
||||
typedef boost::transform_iterator<Function, int*> doubling_iterator;
|
||||
|
||||
doubling_iterator i(x, boost::bind1st(std::multiplies<int>(), 2)),
|
||||
i_end(x + N, boost::bind1st(std::multiplies<int>(), 2));
|
||||
|
||||
std::cout << "multiplying the array by 2:" << std::endl;
|
||||
while (i != i_end)
|
||||
std::cout << *i++ << " ";
|
||||
std::cout << std::endl;
|
||||
|
||||
std::cout << "adding 4 to each element in the array:" << std::endl;
|
||||
std::copy(boost::make_transform_iterator(x, boost::bind1st(std::plus<int>(), 4)),
|
||||
boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
|
||||
std::ostream_iterator<int>(std::cout, " "));
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
The output is:
|
||||
|
||||
multiplying the array by 2:
|
||||
2 4 6 8 10 12 14 16
|
||||
adding 4 to each element in the array:
|
||||
5 6 7 8 9 10 11 12
|
||||
[pre
|
||||
multiplying the array by 2:
|
||||
2 4 6 8 10 12 14 16
|
||||
adding 4 to each element in the array:
|
||||
5 6 7 8 9 10 11 12
|
||||
]
|
||||
|
||||
|
||||
The source code for this example can be found
|
||||
[@../example/transform_iterator_example.cpp here].
|
||||
The source code for this example can be found
|
||||
[example_link transform_iterator_example.cpp..here].
|
||||
|
||||
[h2 Reference]
|
||||
|
||||
@ -52,8 +52,8 @@ The source code for this example can be found
|
||||
[h3 Synopsis]
|
||||
|
||||
template <class UnaryFunction,
|
||||
class Iterator,
|
||||
class Reference = use_default,
|
||||
class Iterator,
|
||||
class Reference = use_default,
|
||||
class Value = use_default>
|
||||
class transform_iterator
|
||||
{
|
||||
@ -86,7 +86,7 @@ The source code for this example can be found
|
||||
|
||||
If `Reference` is `use_default` then the `reference` member of
|
||||
`transform_iterator` is[br]
|
||||
`result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type`.
|
||||
`result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type`.
|
||||
Otherwise, `reference` is `Reference`.
|
||||
|
||||
|
||||
@ -110,13 +110,13 @@ convertible to `input_iterator_tag`.
|
||||
|
||||
|
||||
The type `UnaryFunction` must be Assignable, Copy Constructible, and
|
||||
the expression `f(*i)` must be valid where `f` is an object of
|
||||
the expression `f(*i)` must be valid where `f` is a const object of
|
||||
type `UnaryFunction`, `i` is an object of type `Iterator`, and
|
||||
where the type of `f(*i)` must be
|
||||
`result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type`.
|
||||
`result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type`.
|
||||
|
||||
|
||||
The argument `Iterator` shall model Readable Iterator.
|
||||
The argument `Iterator` shall model Readable Iterator.
|
||||
|
||||
|
||||
[h3 Concepts]
|
||||
@ -126,11 +126,11 @@ The resulting `transform_iterator` models the most refined of the
|
||||
following that is also modeled by `Iterator`.
|
||||
|
||||
|
||||
* Writable Lvalue Iterator if `transform_iterator::reference` is a non-const reference.
|
||||
* Writable Lvalue Iterator if `transform_iterator::reference` is a non-const reference.
|
||||
|
||||
* Readable Lvalue Iterator if `transform_iterator::reference` is a const reference.
|
||||
|
||||
* Readable Iterator otherwise.
|
||||
* Readable Iterator otherwise.
|
||||
|
||||
|
||||
The `transform_iterator` models the most refined standard traversal
|
||||
@ -143,11 +143,11 @@ the `Iterator` argument models.
|
||||
|
||||
|
||||
[table Category
|
||||
[[If `Iterator` models][then `transform_iterator` models]]
|
||||
[[Single Pass Iterator][Input Iterator]]
|
||||
[[Forward Traversal Iterator][Forward Iterator]]
|
||||
[[Bidirectional Traversal Iterator][Bidirectional Iterator]]
|
||||
[[Random Access Traversal Iterator][Random Access Iterator]]
|
||||
[[If `Iterator` models][then `transform_iterator` models]]
|
||||
[[Single Pass Iterator][Input Iterator]]
|
||||
[[Forward Traversal Iterator][Forward Iterator]]
|
||||
[[Bidirectional Traversal Iterator][Bidirectional Iterator]]
|
||||
[[Random Access Traversal Iterator][Random Access Iterator]]
|
||||
]
|
||||
|
||||
If `transform_iterator` models Writable Lvalue Iterator then it is a
|
||||
@ -177,7 +177,7 @@ operations:
|
||||
template<class F2, class I2, class R2, class V2>
|
||||
transform_iterator(
|
||||
transform_iterator<F2, I2, R2, V2> const& t
|
||||
, typename enable_if_convertible<I2, Iterator>::type* = 0 // exposition only
|
||||
, typename enable_if_convertible<I2, Iterator>::type* = 0 // exposition only
|
||||
, typename enable_if_convertible<F2, UnaryFunction>::type* = 0 // exposition only
|
||||
);
|
||||
|
||||
|
@ -1,7 +1,4 @@
|
||||
|
||||
[section:utilities Iterator Utilities]
|
||||
|
||||
[section:utilities_traits Traits]
|
||||
[section:traits Type Traits]
|
||||
|
||||
[h2 Overview]
|
||||
|
||||
@ -212,113 +209,3 @@ Otherwise, `type` is defined to the closest iterator traversal tag matching `C`.
|
||||
[*Requires:] `Iterator` shall be an iterator.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:utilities_testing Testing and Concept Checking]
|
||||
|
||||
The iterator concept checking classes provide a mechanism for a
|
||||
template to report better error messages when a user instantiates
|
||||
the template with a type that does not meet the requirements of the
|
||||
template.
|
||||
|
||||
For an introduction to using concept checking classes, see
|
||||
the documentation for the
|
||||
[@../../concept_check/index.html `boost::concept_check`] library.
|
||||
|
||||
|
||||
[h2 Reference]
|
||||
|
||||
[h3 Iterator Access Concepts]
|
||||
|
||||
* |Readable|_
|
||||
* |Writable|_
|
||||
* |Swappable|_
|
||||
* |Lvalue|_
|
||||
|
||||
[/ .. |Readable| replace:: *Readable Iterator* ]
|
||||
[/ .. _Readable: ReadableIterator.html ]
|
||||
[/ ]
|
||||
[/ .. |Writable| replace:: *Writable Iterator* ]
|
||||
[/ .. _Writable: WritableIterator.html ]
|
||||
[/ ]
|
||||
[/ .. |Swappable| replace:: *Swappable Iterator* ]
|
||||
[/ .. _Swappable: SwappableIterator.html ]
|
||||
[/ ]
|
||||
[/ .. |Lvalue| replace:: *Lvalue Iterator* ]
|
||||
[/ .. _Lvalue: LvalueIterator.html ]
|
||||
|
||||
|
||||
Iterator Traversal Concepts
|
||||
...........................
|
||||
|
||||
* |Incrementable|_
|
||||
* |SinglePass|_
|
||||
* |Forward|_
|
||||
* |Bidir|_
|
||||
* |Random|_
|
||||
|
||||
|
||||
[/ .. |Incrementable| replace:: *Incrementable Iterator* ]
|
||||
[/ .. _Incrementable: IncrementableIterator.html ]
|
||||
[/ ]
|
||||
[/ .. |SinglePass| replace:: *Single Pass Iterator* ]
|
||||
[/ .. _SinglePass: SinglePassIterator.html ]
|
||||
[/ ]
|
||||
[/ .. |Forward| replace:: *Forward Traversal* ]
|
||||
[/ .. _Forward: ForwardTraversal.html ]
|
||||
[/ ]
|
||||
[/ .. |Bidir| replace:: *Bidirectional Traversal* ]
|
||||
[/ .. _Bidir: BidirectionalTraversal.html ]
|
||||
[/ ]
|
||||
[/ .. |Random| replace:: *Random Access Traversal* ]
|
||||
[/ .. _Random: RandomAccessTraversal.html ]
|
||||
|
||||
|
||||
|
||||
[h3 `iterator_concepts.hpp` Synopsis]
|
||||
|
||||
namespace boost_concepts {
|
||||
|
||||
// Iterator Access Concepts
|
||||
|
||||
template <typename Iterator>
|
||||
class ReadableIteratorConcept;
|
||||
|
||||
template <
|
||||
typename Iterator
|
||||
, typename ValueType = std::iterator_traits<Iterator>::value_type
|
||||
>
|
||||
class WritableIteratorConcept;
|
||||
|
||||
template <typename Iterator>
|
||||
class SwappableIteratorConcept;
|
||||
|
||||
template <typename Iterator>
|
||||
class LvalueIteratorConcept;
|
||||
|
||||
// Iterator Traversal Concepts
|
||||
|
||||
template <typename Iterator>
|
||||
class IncrementableIteratorConcept;
|
||||
|
||||
template <typename Iterator>
|
||||
class SinglePassIteratorConcept;
|
||||
|
||||
template <typename Iterator>
|
||||
class ForwardTraversalConcept;
|
||||
|
||||
template <typename Iterator>
|
||||
class BidirectionalTraversalConcept;
|
||||
|
||||
template <typename Iterator>
|
||||
class RandomAccessTraversalConcept;
|
||||
|
||||
// Interoperability
|
||||
|
||||
template <typename Iterator, typename ConstIterator>
|
||||
class InteroperableIteratorConcept;
|
||||
|
||||
}
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
@ -1,17 +1,16 @@
|
||||
|
||||
[section:zip Zip Iterator]
|
||||
|
||||
The zip iterator provides the ability to parallel-iterate
|
||||
over several controlled sequences simultaneously. A zip
|
||||
over several controlled sequences simultaneously. A zip
|
||||
iterator is constructed from a tuple of iterators. Moving
|
||||
the zip iterator moves all the iterators in parallel.
|
||||
Dereferencing the zip iterator returns a tuple that contains
|
||||
the results of dereferencing the individual iterators.
|
||||
the results of dereferencing the individual iterators.
|
||||
|
||||
The tuple of iterators is now implemented in terms of a Boost fusion sequence.
|
||||
The tuple of iterators is now implemented in terms of a Boost fusion sequence.
|
||||
Because of this the 'tuple' may be any Boost fusion sequence and, for backwards
|
||||
compatibility through a Boost fusion sequence adapter, a Boost tuple. Because the
|
||||
'tuple' may be any boost::fusion sequence the 'tuple' may also be any type for which a
|
||||
compatibility through a Boost fusion sequence adapter, a Boost tuple. Because the
|
||||
'tuple' may be any boost::fusion sequence the 'tuple' may also be any type for which a
|
||||
Boost fusion adapter exists. This includes, among others, a std::tuple and a std::pair.
|
||||
Just remember to include the appropriate Boost fusion adapter header files for these
|
||||
other Boost fusion adapters. The zip_iterator header file already includes the
|
||||
@ -22,9 +21,9 @@ to use a Boost tuple as your 'tuple'.
|
||||
|
||||
There are two main types of applications of the `zip_iterator`. The first
|
||||
one concerns runtime efficiency: If one has several controlled sequences
|
||||
of the same length that must be somehow processed, e.g., with the
|
||||
of the same length that must be somehow processed, e.g., with the
|
||||
`for_each` algorithm, then it is more efficient to perform just
|
||||
one parallel-iteration rather than several individual iterations. For an
|
||||
one parallel-iteration rather than several individual iterations. For an
|
||||
example, assume that `vect_of_doubles` and `vect_of_ints`
|
||||
are two vectors of equal length containing doubles and ints, respectively,
|
||||
and consider the following two iterations:
|
||||
@ -53,7 +52,7 @@ These two iterations can now be replaced with a single one as follows:
|
||||
A non-generic implementation of `zip_func` could look as follows:
|
||||
|
||||
|
||||
struct zip_func :
|
||||
struct zip_func :
|
||||
public std::unary_function<const boost::tuple<const double&, const int&>&, void>
|
||||
{
|
||||
void operator()(const boost::tuple<const double&, const int&>& t) const
|
||||
@ -72,16 +71,16 @@ to make combining iterators. A combining iterator is an iterator
|
||||
that parallel-iterates over several controlled sequences and, upon
|
||||
dereferencing, returns the result of applying a functor to the values of the
|
||||
sequences at the respective positions. This can now be achieved by using the
|
||||
`zip_iterator` in conjunction with the `transform_iterator`.
|
||||
`zip_iterator` in conjunction with the `transform_iterator`.
|
||||
|
||||
Suppose, for example, that you have two vectors of doubles, say
|
||||
Suppose, for example, that you have two vectors of doubles, say
|
||||
`vect_1` and `vect_2`, and you need to expose to a client
|
||||
a controlled sequence containing the products of the elements of
|
||||
a controlled sequence containing the products of the elements of
|
||||
`vect_1` and `vect_2`. Rather than placing these products
|
||||
in a third vector, you can use a combining iterator that calculates the
|
||||
products on the fly. Let us assume that `tuple_multiplies` is a
|
||||
functor that works like `std::multiplies`, except that it takes
|
||||
its two arguments packaged in a tuple. Then the two iterators
|
||||
its two arguments packaged in a tuple. Then the two iterators
|
||||
`it_begin` and `it_end` defined below delimit a controlled
|
||||
sequence containing the products of the elements of `vect_1` and
|
||||
`vect_2`:
|
||||
@ -128,7 +127,7 @@ sequence containing the products of the elements of `vect_1` and
|
||||
|
||||
template<typename IteratorTuple>
|
||||
class zip_iterator
|
||||
{
|
||||
{
|
||||
|
||||
public:
|
||||
typedef /* see below */ reference;
|
||||
@ -154,8 +153,8 @@ sequence containing the products of the elements of `vect_1` and
|
||||
IteratorTuple m_iterator_tuple; // exposition only
|
||||
};
|
||||
|
||||
template<typename IteratorTuple>
|
||||
zip_iterator<IteratorTuple>
|
||||
template<typename IteratorTuple>
|
||||
zip_iterator<IteratorTuple>
|
||||
make_zip_iterator(IteratorTuple t);
|
||||
|
||||
The `reference` member of `zip_iterator` is the type of the tuple
|
||||
@ -168,23 +167,23 @@ of the first of the iterator types in the `IteratorTuple` argument.
|
||||
The `iterator_category` member of `zip_iterator` is convertible to the
|
||||
minimum of the traversal categories of the iterator types in the `IteratorTuple`
|
||||
argument. For example, if the `zip_iterator` holds only vector
|
||||
iterators, then `iterator_category` is convertible to
|
||||
iterators, then `iterator_category` is convertible to
|
||||
`boost::random_access_traversal_tag`. If you add a list iterator, then
|
||||
`iterator_category` will be convertible to `boost::bidirectional_traversal_tag`,
|
||||
but no longer to `boost::random_access_traversal_tag`.
|
||||
|
||||
[h2 Requirements]
|
||||
|
||||
All iterator types in the argument `IteratorTuple` shall model Readable Iterator.
|
||||
All iterator types in the argument `IteratorTuple` shall model Readable Iterator.
|
||||
|
||||
[h2 Concepts]
|
||||
|
||||
The resulting `zip_iterator` models Readable Iterator.
|
||||
|
||||
The fact that the `zip_iterator` models only Readable Iterator does not
|
||||
The fact that the `zip_iterator` models only Readable Iterator does not
|
||||
prevent you from modifying the values that the individual iterators point
|
||||
to. The tuple returned by the `zip_iterator`'s `operator*` is a tuple
|
||||
constructed from the reference types of the individual iterators, not
|
||||
to. The tuple returned by the `zip_iterator`'s `operator*` is a tuple
|
||||
constructed from the reference types of the individual iterators, not
|
||||
their value types. For example, if `zip_it` is a `zip_iterator` whose
|
||||
first member iterator is an `std::vector<double>::iterator`, then the
|
||||
following line will modify the value which the first member iterator of
|
||||
@ -195,7 +194,7 @@ following line will modify the value which the first member iterator of
|
||||
|
||||
Consider the set of standard traversal concepts obtained by taking
|
||||
the most refined standard traversal concept modeled by each individual
|
||||
iterator type in the `IteratorTuple` argument.The `zip_iterator`
|
||||
iterator type in the `IteratorTuple` argument.The `zip_iterator`
|
||||
models the least refined standard traversal concept in this set.
|
||||
|
||||
`zip_iterator<IteratorTuple1>` is interoperable with
|
||||
@ -254,8 +253,8 @@ operations.
|
||||
[*Effects:] Decrements each iterator in `m_iterator_tuple`.[br]
|
||||
[*Returns:] `*this`
|
||||
|
||||
template<typename IteratorTuple>
|
||||
zip_iterator<IteratorTuple>
|
||||
template<typename IteratorTuple>
|
||||
zip_iterator<IteratorTuple>
|
||||
make_zip_iterator(IteratorTuple t);
|
||||
|
||||
[*Returns:] An instance of `zip_iterator<IteratorTuple>` with `m_iterator_tuple`
|
||||
@ -263,4 +262,4 @@ operations.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
[endsect]
|
||||
|
@ -45,8 +45,7 @@ A non-generic implementation of ``zip_func`` could look as follows:
|
||||
::
|
||||
|
||||
|
||||
struct zip_func :
|
||||
public std::unary_function<const boost::tuple<const double&, const int&>&, void>
|
||||
struct zip_func
|
||||
{
|
||||
void operator()(const boost::tuple<const double&, const int&>& t) const
|
||||
{
|
||||
|
@ -41,12 +41,12 @@ int main(int, char*[])
|
||||
|
||||
// Use indirect iterator to print out numbers by accessing
|
||||
// them through the array of pointers.
|
||||
std::cout << "indirectly printing out the numbers from 0 to "
|
||||
std::cout << "indirectly printing out the numbers from 0 to "
|
||||
<< N << std::endl;
|
||||
std::copy(boost::make_indirect_iterator(pointers.begin()),
|
||||
boost::make_indirect_iterator(pointers.end()),
|
||||
std::ostream_iterator<int>(std::cout, " "));
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
return boost::exit_success;
|
||||
}
|
||||
|
@ -8,6 +8,7 @@
|
||||
#include <functional>
|
||||
#include <iostream>
|
||||
#include <boost/iterator/filter_iterator.hpp>
|
||||
#include <boost/bind/bind.hpp>
|
||||
#include <boost/cstdlib.hpp> // for exit_success
|
||||
|
||||
struct is_positive_number {
|
||||
@ -18,10 +19,10 @@ int main()
|
||||
{
|
||||
int numbers_[] = { 0, -1, 4, -3, 5, 8, -2 };
|
||||
const int N = sizeof(numbers_)/sizeof(int);
|
||||
|
||||
|
||||
typedef int* base_iterator;
|
||||
base_iterator numbers(numbers_);
|
||||
|
||||
|
||||
// Example using make_filter_iterator()
|
||||
std::copy(boost::make_filter_iterator<is_positive_number>(numbers, numbers + N),
|
||||
boost::make_filter_iterator<is_positive_number>(numbers + N, numbers + N),
|
||||
@ -31,7 +32,7 @@ int main()
|
||||
// Example using filter_iterator
|
||||
typedef boost::filter_iterator<is_positive_number, base_iterator>
|
||||
FilterIter;
|
||||
|
||||
|
||||
is_positive_number predicate;
|
||||
FilterIter filter_iter_first(predicate, numbers, numbers + N);
|
||||
FilterIter filter_iter_last(predicate, numbers + N, numbers + N);
|
||||
@ -42,17 +43,17 @@ int main()
|
||||
// Another example using make_filter_iterator()
|
||||
std::copy(
|
||||
boost::make_filter_iterator(
|
||||
std::bind2nd(std::greater<int>(), -2)
|
||||
boost::bind(std::greater<int>(), boost::placeholders::_1, -2)
|
||||
, numbers, numbers + N)
|
||||
|
||||
|
||||
, boost::make_filter_iterator(
|
||||
std::bind2nd(std::greater<int>(), -2)
|
||||
boost::bind(std::greater<int>(), boost::placeholders::_1, -2)
|
||||
, numbers + N, numbers + N)
|
||||
|
||||
|
||||
, std::ostream_iterator<int>(std::cout, " ")
|
||||
);
|
||||
|
||||
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
return boost::exit_success;
|
||||
}
|
||||
|
@ -12,14 +12,14 @@
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/function_output_iterator.hpp>
|
||||
#include <boost/iterator/function_output_iterator.hpp>
|
||||
|
||||
struct string_appender
|
||||
{
|
||||
string_appender(std::string& s)
|
||||
: m_str(&s)
|
||||
{}
|
||||
|
||||
|
||||
void operator()(const std::string& x) const
|
||||
{
|
||||
*m_str += x;
|
||||
@ -37,9 +37,9 @@ int main(int, char*[])
|
||||
x.push_back("!");
|
||||
|
||||
std::string s = "";
|
||||
std::copy(x.begin(), x.end(),
|
||||
std::copy(x.begin(), x.end(),
|
||||
boost::make_function_output_iterator(string_appender(s)));
|
||||
|
||||
|
||||
std::cout << s << std::endl;
|
||||
|
||||
return 0;
|
||||
|
@ -9,6 +9,7 @@
|
||||
#include <iterator>
|
||||
#include <functional>
|
||||
#include <algorithm>
|
||||
#include <boost/bind/bind.hpp>
|
||||
#include <boost/iterator/indirect_iterator.hpp>
|
||||
|
||||
int main(int, char*[])
|
||||
@ -20,13 +21,13 @@ int main(int, char*[])
|
||||
pointers_to_chars[i] = &characters[i];
|
||||
|
||||
// Example of using indirect_iterator
|
||||
|
||||
|
||||
boost::indirect_iterator<char**, char>
|
||||
indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);
|
||||
|
||||
std::copy(indirect_first, indirect_last, std::ostream_iterator<char>(std::cout, ","));
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
|
||||
// Example of making mutable and constant indirect iterators
|
||||
|
||||
@ -41,19 +42,19 @@ int main(int, char*[])
|
||||
const_indirect_last(pointers_to_chars + N);
|
||||
|
||||
std::transform(const_indirect_first, const_indirect_last,
|
||||
mutable_indirect_first, std::bind1st(std::plus<char>(), 1));
|
||||
mutable_indirect_first, boost::bind(std::plus<char>(), 1, boost::placeholders::_1));
|
||||
|
||||
std::copy(mutable_indirect_first, mutable_indirect_last,
|
||||
std::ostream_iterator<char>(std::cout, ","));
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
|
||||
// Example of using make_indirect_iterator()
|
||||
|
||||
std::copy(boost::make_indirect_iterator(pointers_to_chars),
|
||||
std::copy(boost::make_indirect_iterator(pointers_to_chars),
|
||||
boost::make_indirect_iterator(pointers_to_chars + N),
|
||||
std::ostream_iterator<char>(std::cout, ","));
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -11,7 +11,17 @@
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
#if defined(BOOST_NO_CXX11_SMART_PTR)
|
||||
|
||||
std::auto_ptr<node<int> > nodes(new node<int>(42));
|
||||
|
||||
#else
|
||||
|
||||
std::unique_ptr<node<int> > nodes(new node<int>(42));
|
||||
|
||||
#endif
|
||||
|
||||
nodes->append(new node<std::string>(" is greater than "));
|
||||
nodes->append(new node<int>(13));
|
||||
|
||||
@ -20,7 +30,7 @@ int main()
|
||||
, std::ostream_iterator<node_base>(std::cout, " ")
|
||||
);
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
std::for_each(
|
||||
node_iterator(nodes.get()), node_iterator()
|
||||
, std::mem_fun_ref(&node_base::double_me)
|
||||
|
@ -12,23 +12,33 @@
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
#if defined(BOOST_NO_CXX11_SMART_PTR)
|
||||
|
||||
std::auto_ptr<node<int> > nodes(new node<int>(42));
|
||||
|
||||
#else
|
||||
|
||||
std::unique_ptr<node<int> > nodes(new node<int>(42));
|
||||
|
||||
#endif
|
||||
|
||||
nodes->append(new node<std::string>(" is greater than "));
|
||||
nodes->append(new node<int>(13));
|
||||
|
||||
// Check interoperability
|
||||
assert(node_iterator(nodes.get()) == node_const_iterator(nodes.get()));
|
||||
assert(node_const_iterator(nodes.get()) == node_iterator(nodes.get()));
|
||||
|
||||
|
||||
assert(node_iterator(nodes.get()) != node_const_iterator());
|
||||
assert(node_const_iterator(nodes.get()) != node_iterator());
|
||||
|
||||
|
||||
std::copy(
|
||||
node_iterator(nodes.get()), node_iterator()
|
||||
, std::ostream_iterator<node_base>(std::cout, " ")
|
||||
);
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
std::for_each(
|
||||
node_iterator(nodes.get()), node_iterator()
|
||||
, boost::mem_fn(&node_base::double_me)
|
||||
|
@ -12,23 +12,33 @@
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
#if defined(BOOST_NO_CXX11_SMART_PTR)
|
||||
|
||||
std::auto_ptr<node<int> > nodes(new node<int>(42));
|
||||
|
||||
#else
|
||||
|
||||
std::unique_ptr<node<int> > nodes(new node<int>(42));
|
||||
|
||||
#endif
|
||||
|
||||
nodes->append(new node<std::string>(" is greater than "));
|
||||
nodes->append(new node<int>(13));
|
||||
|
||||
// Check interoperability
|
||||
assert(node_iterator(nodes.get()) == node_const_iterator(nodes.get()));
|
||||
assert(node_const_iterator(nodes.get()) == node_iterator(nodes.get()));
|
||||
|
||||
|
||||
assert(node_iterator(nodes.get()) != node_const_iterator());
|
||||
assert(node_const_iterator(nodes.get()) != node_iterator());
|
||||
|
||||
|
||||
std::copy(
|
||||
node_iterator(nodes.get()), node_iterator()
|
||||
, std::ostream_iterator<node_base>(std::cout, " ")
|
||||
);
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
std::for_each(
|
||||
node_iterator(nodes.get()), node_iterator()
|
||||
, boost::mem_fn(&node_base::double_me)
|
||||
|
@ -27,7 +27,7 @@ int main() {
|
||||
*el_it = std::distance(elements.begin(), el_it);
|
||||
|
||||
index_type indices( index_size );
|
||||
for(index_type::iterator i_it = indices.begin() ; i_it != indices.end() ; ++i_it )
|
||||
for(index_type::iterator i_it = indices.begin() ; i_it != indices.end() ; ++i_it )
|
||||
*i_it = element_range_size - index_size + std::distance(indices.begin(), i_it);
|
||||
std::reverse( indices.begin(), indices.end() );
|
||||
|
||||
|
@ -15,13 +15,13 @@ int main(int, char*[])
|
||||
const int N = sizeof(letters_)/sizeof(char) - 1;
|
||||
typedef char* base_iterator;
|
||||
base_iterator letters(letters_);
|
||||
|
||||
|
||||
std::cout << "original sequence of letters:\t\t\t"
|
||||
<< letters_ << std::endl;
|
||||
|
||||
// Use reverse_iterator to print a sequence of letters in reverse
|
||||
// order.
|
||||
|
||||
|
||||
boost::reverse_iterator<base_iterator>
|
||||
reverse_letters_first(letters + N),
|
||||
reverse_letters_last(letters);
|
||||
|
42
example/shared_iterator_example1.cpp
Normal file
42
example/shared_iterator_example1.cpp
Normal file
@ -0,0 +1,42 @@
|
||||
// Copyright 2003 The Trustees of Indiana University.
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include "boost/shared_container_iterator.hpp"
|
||||
#include "boost/shared_ptr.hpp"
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
typedef boost::shared_container_iterator< std::vector<int> > iterator;
|
||||
|
||||
|
||||
void set_range(iterator& i, iterator& end) {
|
||||
|
||||
boost::shared_ptr< std::vector<int> > ints(new std::vector<int>());
|
||||
|
||||
ints->push_back(0);
|
||||
ints->push_back(1);
|
||||
ints->push_back(2);
|
||||
ints->push_back(3);
|
||||
ints->push_back(4);
|
||||
ints->push_back(5);
|
||||
|
||||
i = iterator(ints->begin(),ints);
|
||||
end = iterator(ints->end(),ints);
|
||||
}
|
||||
|
||||
|
||||
int main() {
|
||||
|
||||
iterator i,end;
|
||||
|
||||
set_range(i,end);
|
||||
|
||||
std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
|
||||
std::cout.put('\n');
|
||||
|
||||
return 0;
|
||||
}
|
43
example/shared_iterator_example2.cpp
Normal file
43
example/shared_iterator_example2.cpp
Normal file
@ -0,0 +1,43 @@
|
||||
// Copyright 2003 The Trustees of Indiana University.
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include "boost/shared_container_iterator.hpp"
|
||||
#include "boost/shared_ptr.hpp"
|
||||
#include <algorithm>
|
||||
#include <iterator>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
|
||||
template <typename Iterator>
|
||||
void print_range_nl (Iterator begin, Iterator end) {
|
||||
typedef typename std::iterator_traits<Iterator>::value_type val;
|
||||
std::copy(begin,end,std::ostream_iterator<val>(std::cout,","));
|
||||
std::cout.put('\n');
|
||||
}
|
||||
|
||||
|
||||
int main() {
|
||||
|
||||
typedef boost::shared_ptr< std::vector<int> > ints_t;
|
||||
{
|
||||
ints_t ints(new std::vector<int>());
|
||||
|
||||
ints->push_back(0);
|
||||
ints->push_back(1);
|
||||
ints->push_back(2);
|
||||
ints->push_back(3);
|
||||
ints->push_back(4);
|
||||
ints->push_back(5);
|
||||
|
||||
print_range_nl(boost::make_shared_container_iterator(ints->begin(),ints),
|
||||
boost::make_shared_container_iterator(ints->end(),ints));
|
||||
}
|
||||
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
41
example/shared_iterator_example3.cpp
Normal file
41
example/shared_iterator_example3.cpp
Normal file
@ -0,0 +1,41 @@
|
||||
// Copyright 2003 The Trustees of Indiana University.
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include "boost/shared_container_iterator.hpp"
|
||||
#include "boost/shared_ptr.hpp"
|
||||
#include "boost/tuple/tuple.hpp" // for boost::tie
|
||||
#include <algorithm> // for std::copy
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
|
||||
typedef boost::shared_container_iterator< std::vector<int> > iterator;
|
||||
|
||||
std::pair<iterator,iterator>
|
||||
return_range() {
|
||||
boost::shared_ptr< std::vector<int> > range(new std::vector<int>());
|
||||
range->push_back(0);
|
||||
range->push_back(1);
|
||||
range->push_back(2);
|
||||
range->push_back(3);
|
||||
range->push_back(4);
|
||||
range->push_back(5);
|
||||
return boost::make_shared_container_range(range);
|
||||
}
|
||||
|
||||
|
||||
int main() {
|
||||
|
||||
|
||||
iterator i,end;
|
||||
|
||||
boost::tie(i,end) = return_range();
|
||||
|
||||
std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
|
||||
std::cout.put('\n');
|
||||
|
||||
return 0;
|
||||
}
|
@ -1,4 +1,4 @@
|
||||
// (C) Copyright Jeremy Siek 2000-2004.
|
||||
// (C) Copyright Jeremy Siek 2000-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)
|
||||
@ -15,10 +15,11 @@
|
||||
|
||||
namespace boost {
|
||||
|
||||
template <class Operation>
|
||||
class binder1st
|
||||
: public std::unary_function<typename Operation::second_argument_type,
|
||||
typename Operation::result_type> {
|
||||
template <class Operation>
|
||||
class binder1st {
|
||||
public:
|
||||
typedef typename Operation::result_type result_type;
|
||||
typedef typename Operation::second_argument_type argument_type;
|
||||
protected:
|
||||
Operation op;
|
||||
typename Operation::first_argument_type value;
|
||||
@ -29,7 +30,7 @@ namespace boost {
|
||||
: op(x), value(y) {}
|
||||
typename Operation::result_type
|
||||
operator()(const typename Operation::second_argument_type& x) const {
|
||||
return op(value, x);
|
||||
return op(value, x);
|
||||
}
|
||||
};
|
||||
|
||||
@ -69,8 +70,6 @@ main(int, char*[])
|
||||
boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
|
||||
std::ostream_iterator<int>(std::cout, " "));
|
||||
std::cout << std::endl;
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
@ -1,62 +1,18 @@
|
||||
// (C) Copyright Jeremy Siek 2001.
|
||||
// (C) Copyright Andrey Semashev 2017.
|
||||
// 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)
|
||||
|
||||
// Revision History:
|
||||
|
||||
// 27 Feb 2001 Jeremy Siek
|
||||
// Initial checkin.
|
||||
|
||||
#ifndef BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
|
||||
#define BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
|
||||
|
||||
#include <iterator>
|
||||
// This is a deprecated header left for backward compatibility.
|
||||
// Use boost/iterator/function_output_iterator.hpp instead.
|
||||
|
||||
namespace boost {
|
||||
namespace iterators {
|
||||
#include <boost/config/header_deprecated.hpp>
|
||||
|
||||
template <class UnaryFunction>
|
||||
class function_output_iterator {
|
||||
typedef function_output_iterator self;
|
||||
public:
|
||||
typedef std::output_iterator_tag iterator_category;
|
||||
typedef void value_type;
|
||||
typedef void difference_type;
|
||||
typedef void pointer;
|
||||
typedef void reference;
|
||||
BOOST_HEADER_DEPRECATED("<boost/iterator/function_output_iterator.hpp>")
|
||||
|
||||
explicit function_output_iterator() {}
|
||||
|
||||
explicit function_output_iterator(const UnaryFunction& f)
|
||||
: m_f(f) {}
|
||||
|
||||
struct output_proxy {
|
||||
output_proxy(UnaryFunction& f) : m_f(f) { }
|
||||
template <class T> output_proxy& operator=(const T& value) {
|
||||
m_f(value);
|
||||
return *this;
|
||||
}
|
||||
UnaryFunction& m_f;
|
||||
};
|
||||
output_proxy operator*() { return output_proxy(m_f); }
|
||||
self& operator++() { return *this; }
|
||||
self& operator++(int) { return *this; }
|
||||
private:
|
||||
UnaryFunction m_f;
|
||||
};
|
||||
|
||||
template <class UnaryFunction>
|
||||
inline function_output_iterator<UnaryFunction>
|
||||
make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
|
||||
return function_output_iterator<UnaryFunction>(f);
|
||||
}
|
||||
|
||||
} // namespace iterators
|
||||
|
||||
using iterators::function_output_iterator;
|
||||
using iterators::make_function_output_iterator;
|
||||
|
||||
} // namespace boost
|
||||
#include <boost/iterator/function_output_iterator.hpp>
|
||||
|
||||
#endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
|
||||
|
@ -77,7 +77,7 @@ namespace iterators {
|
||||
|
||||
} // namespace iterators
|
||||
|
||||
using iterators::advance;
|
||||
using namespace iterators::advance_adl_barrier;
|
||||
|
||||
} // namespace boost
|
||||
|
||||
|
@ -38,7 +38,7 @@ namespace detail
|
||||
|
||||
# else
|
||||
|
||||
# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
|
||||
# if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value = (
|
||||
boost::is_convertible<int,T>::value
|
||||
|
@ -27,7 +27,7 @@
|
||||
// because the operator-> return is improperly deduced as a non-const
|
||||
// pointer.
|
||||
#if 1 || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|
||||
|| BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))
|
||||
|| BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x531))
|
||||
|
||||
// Recall that in general, compilers without partial specialization
|
||||
// can't strip constness. Consider counting_iterator, which normally
|
||||
@ -46,7 +46,7 @@
|
||||
|
||||
#endif
|
||||
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0)) \
|
||||
#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x5A0)) \
|
||||
|| (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
|
||||
|| BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) \
|
||||
|| BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
|
||||
@ -88,7 +88,7 @@
|
||||
#endif
|
||||
|
||||
#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__) \
|
||||
|| BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
|
||||
|| BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
|
||||
# define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
|
||||
|
||||
# if 0 // test code
|
||||
@ -114,7 +114,7 @@
|
||||
# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
|
||||
#endif
|
||||
|
||||
# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
|
||||
# if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
|
||||
|
||||
// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
|
||||
// operators in convertibility checks, causing premature errors.
|
||||
|
@ -4,6 +4,8 @@
|
||||
#ifndef FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
|
||||
# define FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
|
||||
|
||||
# include <boost/core/use_default.hpp>
|
||||
|
||||
# include <boost/iterator/iterator_categories.hpp>
|
||||
|
||||
# include <boost/mpl/or.hpp> // used in iterator_tag inheritance logic
|
||||
@ -33,8 +35,7 @@
|
||||
namespace boost {
|
||||
namespace iterators {
|
||||
|
||||
// forward declaration
|
||||
struct use_default;
|
||||
using boost::use_default;
|
||||
|
||||
namespace detail {
|
||||
|
||||
|
@ -58,7 +58,7 @@ namespace iterators {
|
||||
|
||||
} // namespace iterators
|
||||
|
||||
using iterators::distance;
|
||||
using namespace iterators::distance_adl_barrier;
|
||||
|
||||
} // namespace boost
|
||||
|
||||
|
@ -7,7 +7,6 @@
|
||||
#ifndef BOOST_FILTER_ITERATOR_23022003THW_HPP
|
||||
#define BOOST_FILTER_ITERATOR_23022003THW_HPP
|
||||
|
||||
#include <boost/iterator.hpp>
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
#include <boost/iterator/iterator_categories.hpp>
|
||||
|
||||
|
@ -11,34 +11,53 @@
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/core/addressof.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/function_types/is_function_pointer.hpp>
|
||||
#include <boost/function_types/is_function_reference.hpp>
|
||||
#include <boost/function_types/result_type.hpp>
|
||||
#include <boost/iterator/iterator_facade.hpp>
|
||||
#include <boost/none.hpp>
|
||||
#include <boost/optional/optional.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
|
||||
#ifdef BOOST_RESULT_OF_USE_TR1
|
||||
#include <boost/type_traits/is_function.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace iterators {
|
||||
|
||||
namespace impl {
|
||||
|
||||
// Computes the return type of an lvalue-call with an empty argument,
|
||||
// i.e. decltype(declval<F&>()()). F should be a nullary lvalue-callable
|
||||
// or function.
|
||||
template <class F>
|
||||
struct result_of_nullary_lvalue_call
|
||||
{
|
||||
typedef typename result_of<
|
||||
#ifdef BOOST_RESULT_OF_USE_TR1
|
||||
typename mpl::if_<is_function<F>, F&, F>::type()
|
||||
#else
|
||||
F&()
|
||||
#endif
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template <class Function, class Input>
|
||||
class function_input_iterator
|
||||
: public iterator_facade<
|
||||
function_input_iterator<Function, Input>,
|
||||
BOOST_DEDUCED_TYPENAME result_of<Function ()>::type,
|
||||
typename result_of_nullary_lvalue_call<Function>::type,
|
||||
single_pass_traversal_tag,
|
||||
BOOST_DEDUCED_TYPENAME result_of<Function ()>::type const &
|
||||
typename result_of_nullary_lvalue_call<Function>::type const &
|
||||
>
|
||||
{
|
||||
public:
|
||||
function_input_iterator() {}
|
||||
function_input_iterator(Function & f_, Input state_ = Input())
|
||||
: f(&f_), state(state_) {}
|
||||
: f(boost::addressof(f_)), state(state_) {}
|
||||
|
||||
void increment() {
|
||||
if(value)
|
||||
@ -48,7 +67,7 @@ namespace iterators {
|
||||
++state;
|
||||
}
|
||||
|
||||
BOOST_DEDUCED_TYPENAME result_of<Function ()>::type const &
|
||||
typename result_of_nullary_lvalue_call<Function>::type const &
|
||||
dereference() const {
|
||||
return (value ? value : value = (*f)()).get();
|
||||
}
|
||||
@ -60,7 +79,7 @@ namespace iterators {
|
||||
private:
|
||||
Function * f;
|
||||
Input state;
|
||||
mutable optional<BOOST_DEDUCED_TYPENAME result_of<Function ()>::type> value;
|
||||
mutable optional<typename result_of_nullary_lvalue_call<Function>::type> value;
|
||||
};
|
||||
|
||||
template <class Function, class Input>
|
||||
@ -100,16 +119,6 @@ namespace iterators {
|
||||
mutable optional<typename function_types::result_type<Function>::type> value;
|
||||
};
|
||||
|
||||
template <class Function, class Input>
|
||||
class function_reference_input_iterator
|
||||
: public function_pointer_input_iterator<Function*,Input>
|
||||
{
|
||||
public:
|
||||
function_reference_input_iterator(Function & f_, Input state_ = Input())
|
||||
: function_pointer_input_iterator<Function*,Input>(&f_, state_)
|
||||
{}
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
template <class Function, class Input>
|
||||
@ -117,21 +126,13 @@ namespace iterators {
|
||||
: public mpl::if_<
|
||||
function_types::is_function_pointer<Function>,
|
||||
impl::function_pointer_input_iterator<Function,Input>,
|
||||
typename mpl::if_<
|
||||
function_types::is_function_reference<Function>,
|
||||
impl::function_reference_input_iterator<Function,Input>,
|
||||
impl::function_input_iterator<Function,Input>
|
||||
>::type
|
||||
impl::function_input_iterator<Function,Input>
|
||||
>::type
|
||||
{
|
||||
typedef typename mpl::if_<
|
||||
function_types::is_function_pointer<Function>,
|
||||
impl::function_pointer_input_iterator<Function,Input>,
|
||||
typename mpl::if_<
|
||||
function_types::is_function_reference<Function>,
|
||||
impl::function_reference_input_iterator<Function,Input>,
|
||||
impl::function_input_iterator<Function,Input>
|
||||
>::type
|
||||
impl::function_input_iterator<Function,Input>
|
||||
>::type base_type;
|
||||
public:
|
||||
function_input_iterator(Function & f, Input i)
|
||||
|
62
include/boost/iterator/function_output_iterator.hpp
Normal file
62
include/boost/iterator/function_output_iterator.hpp
Normal file
@ -0,0 +1,62 @@
|
||||
// (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)
|
||||
|
||||
// Revision History:
|
||||
|
||||
// 27 Feb 2001 Jeremy Siek
|
||||
// Initial checkin.
|
||||
|
||||
#ifndef BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
|
||||
#define BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
|
||||
|
||||
#include <iterator>
|
||||
|
||||
namespace boost {
|
||||
namespace iterators {
|
||||
|
||||
template <class UnaryFunction>
|
||||
class function_output_iterator {
|
||||
typedef function_output_iterator self;
|
||||
public:
|
||||
typedef std::output_iterator_tag iterator_category;
|
||||
typedef void value_type;
|
||||
typedef void difference_type;
|
||||
typedef void pointer;
|
||||
typedef void reference;
|
||||
|
||||
explicit function_output_iterator() {}
|
||||
|
||||
explicit function_output_iterator(const UnaryFunction& f)
|
||||
: m_f(f) {}
|
||||
|
||||
struct output_proxy {
|
||||
output_proxy(UnaryFunction& f) : m_f(f) { }
|
||||
template <class T> output_proxy& operator=(const T& value) {
|
||||
m_f(value);
|
||||
return *this;
|
||||
}
|
||||
UnaryFunction& m_f;
|
||||
};
|
||||
output_proxy operator*() { return output_proxy(m_f); }
|
||||
self& operator++() { return *this; }
|
||||
self& operator++(int) { return *this; }
|
||||
private:
|
||||
UnaryFunction m_f;
|
||||
};
|
||||
|
||||
template <class UnaryFunction>
|
||||
inline function_output_iterator<UnaryFunction>
|
||||
make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
|
||||
return function_output_iterator<UnaryFunction>(f);
|
||||
}
|
||||
|
||||
} // namespace iterators
|
||||
|
||||
using iterators::function_output_iterator;
|
||||
using iterators::make_function_output_iterator;
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP
|
@ -7,12 +7,10 @@
|
||||
#ifndef BOOST_INDIRECT_ITERATOR_23022003THW_HPP
|
||||
#define BOOST_INDIRECT_ITERATOR_23022003THW_HPP
|
||||
|
||||
#include <boost/iterator.hpp>
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
|
||||
#include <boost/pointee.hpp>
|
||||
#include <boost/indirect_reference.hpp>
|
||||
#include <boost/detail/iterator.hpp>
|
||||
|
||||
#include <boost/detail/indirect_traits.hpp>
|
||||
|
||||
@ -25,6 +23,8 @@
|
||||
#include <boost/mpl/not.hpp>
|
||||
#include <boost/mpl/has_xxx.hpp>
|
||||
|
||||
#include <iterator>
|
||||
|
||||
#ifdef BOOST_MPL_CFG_NO_HAS_XXX
|
||||
# include <boost/shared_ptr.hpp>
|
||||
# include <boost/scoped_ptr.hpp>
|
||||
@ -45,7 +45,7 @@ namespace iterators {
|
||||
template <class Iter, class Value, class Category, class Reference, class Difference>
|
||||
struct indirect_base
|
||||
{
|
||||
typedef typename boost::detail::iterator_traits<Iter>::value_type dereferenceable;
|
||||
typedef typename std::iterator_traits<Iter>::value_type dereferenceable;
|
||||
|
||||
typedef iterator_adaptor<
|
||||
indirect_iterator<Iter, Value, Category, Reference, Difference>
|
||||
@ -111,7 +111,7 @@ namespace iterators {
|
||||
private:
|
||||
typename super_t::reference dereference() const
|
||||
{
|
||||
# if BOOST_WORKAROUND(__BORLANDC__, < 0x5A0 )
|
||||
# if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x5A0 )
|
||||
return const_cast<super_t::reference>(**this->base());
|
||||
# else
|
||||
return **this->base();
|
||||
|
@ -4,16 +4,15 @@
|
||||
#ifndef IS_LVALUE_ITERATOR_DWA2003112_HPP
|
||||
# define IS_LVALUE_ITERATOR_DWA2003112_HPP
|
||||
|
||||
#include <boost/iterator.hpp>
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/detail/iterator.hpp>
|
||||
|
||||
#include <boost/type_traits/add_lvalue_reference.hpp>
|
||||
#include <boost/iterator/detail/any_conversion_eater.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/aux_/lambda_support.hpp>
|
||||
|
||||
#include <iterator>
|
||||
|
||||
// should be the last #includes
|
||||
#include <boost/type_traits/integral_constant.hpp>
|
||||
#include <boost/iterator/detail/config_def.hpp>
|
||||
@ -125,14 +124,14 @@ namespace detail
|
||||
template <class It>
|
||||
struct is_readable_lvalue_iterator_impl
|
||||
: is_lvalue_iterator_impl<
|
||||
BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<It>::value_type const
|
||||
BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type const
|
||||
>::template rebind<It>
|
||||
{};
|
||||
|
||||
template <class It>
|
||||
struct is_non_const_lvalue_iterator_impl
|
||||
: is_lvalue_iterator_impl<
|
||||
BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<It>::value_type
|
||||
BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type
|
||||
>::template rebind<It>
|
||||
{};
|
||||
} // namespace detail
|
||||
|
@ -6,11 +6,12 @@
|
||||
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/aux_/lambda_support.hpp>
|
||||
#include <boost/detail/iterator.hpp>
|
||||
#include <boost/type_traits/add_lvalue_reference.hpp>
|
||||
|
||||
#include <boost/iterator/detail/any_conversion_eater.hpp>
|
||||
|
||||
#include <iterator>
|
||||
|
||||
// should be the last #include
|
||||
#include <boost/type_traits/integral_constant.hpp>
|
||||
#include <boost/iterator/detail/config_def.hpp>
|
||||
@ -93,7 +94,7 @@ namespace detail
|
||||
template <class It>
|
||||
struct is_readable_iterator_impl2
|
||||
: is_readable_iterator_impl<
|
||||
BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<It>::value_type const
|
||||
BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type const
|
||||
>::template rebind<It>
|
||||
{};
|
||||
} // namespace detail
|
||||
|
@ -8,8 +8,8 @@
|
||||
#define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
|
||||
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/iterator.hpp>
|
||||
#include <boost/detail/iterator.hpp>
|
||||
|
||||
#include <boost/core/use_default.hpp>
|
||||
|
||||
#include <boost/iterator/iterator_categories.hpp>
|
||||
#include <boost/iterator/iterator_facade.hpp>
|
||||
@ -37,12 +37,10 @@ namespace iterators {
|
||||
// Used as a default template argument internally, merely to
|
||||
// indicate "use the default", this can also be passed by users
|
||||
// explicitly in order to specify that the default should be used.
|
||||
struct use_default;
|
||||
using boost::use_default;
|
||||
|
||||
} // namespace iterators
|
||||
|
||||
using iterators::use_default;
|
||||
|
||||
// the incompleteness of use_default causes massive problems for
|
||||
// is_convertible (naturally). This workaround is fortunately not
|
||||
// needed for vc6/vc7.
|
||||
|
@ -9,7 +9,6 @@
|
||||
#include <boost/iterator/iterator_categories.hpp>
|
||||
#include <boost/operators.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/iterator.hpp>
|
||||
|
||||
#include <boost/iterator/detail/facade_iterator_category.hpp>
|
||||
|
||||
@ -427,15 +426,16 @@ namespace detail
|
||||
>::type iterator_category;
|
||||
|
||||
// Needed for some broken libraries (see below)
|
||||
typedef boost::iterator<
|
||||
iterator_category
|
||||
, Value
|
||||
, typename traversal_archetype_base<
|
||||
struct workaround_iterator_base
|
||||
{
|
||||
typedef typename iterator_archetype_base::iterator_category iterator_category;
|
||||
typedef Value value_type;
|
||||
typedef typename traversal_archetype_base<
|
||||
Value, AccessCategory, TraversalCategory
|
||||
>::difference_type
|
||||
, typename access::pointer
|
||||
, typename access::reference
|
||||
> workaround_iterator_base;
|
||||
>::difference_type difference_type;
|
||||
typedef typename access::pointer pointer;
|
||||
typedef typename access::reference reference;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -7,7 +7,6 @@
|
||||
# define BOOST_ITERATOR_CATEGORIES_HPP
|
||||
|
||||
# include <boost/config.hpp>
|
||||
# include <boost/detail/iterator.hpp>
|
||||
# include <boost/iterator/detail/config_def.hpp>
|
||||
|
||||
# include <boost/detail/workaround.hpp>
|
||||
@ -21,6 +20,8 @@
|
||||
|
||||
# include <boost/static_assert.hpp>
|
||||
|
||||
#include <iterator>
|
||||
|
||||
namespace boost {
|
||||
namespace iterators {
|
||||
|
||||
@ -116,7 +117,7 @@ struct iterator_category_to_traversal
|
||||
template <class Iterator = mpl::_1>
|
||||
struct iterator_traversal
|
||||
: iterator_category_to_traversal<
|
||||
typename boost::detail::iterator_traits<Iterator>::iterator_category
|
||||
typename std::iterator_traits<Iterator>::iterator_category
|
||||
>
|
||||
{};
|
||||
|
||||
|
@ -9,9 +9,6 @@
|
||||
#include <boost/concept_check.hpp>
|
||||
#include <boost/iterator/iterator_categories.hpp>
|
||||
|
||||
// Use boost::detail::iterator_traits to work around some MSVC/Dinkumware problems.
|
||||
#include <boost/detail/iterator.hpp>
|
||||
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/type_traits/is_integral.hpp>
|
||||
|
||||
@ -27,6 +24,7 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
#include <iterator>
|
||||
|
||||
#include <boost/concept/detail/concept_def.hpp>
|
||||
|
||||
@ -44,8 +42,8 @@ namespace boost_concepts
|
||||
, boost::CopyConstructible<Iterator>
|
||||
|
||||
{
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type value_type;
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference reference;
|
||||
typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type value_type;
|
||||
typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference reference;
|
||||
|
||||
BOOST_CONCEPT_USAGE(ReadableIterator)
|
||||
{
|
||||
@ -59,7 +57,7 @@ namespace boost_concepts
|
||||
|
||||
template <
|
||||
typename Iterator
|
||||
, typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
|
||||
, typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type
|
||||
>
|
||||
struct WritableIterator
|
||||
: boost::CopyConstructible<Iterator>
|
||||
@ -75,7 +73,7 @@ namespace boost_concepts
|
||||
|
||||
template <
|
||||
typename Iterator
|
||||
, typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
|
||||
, typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type
|
||||
>
|
||||
struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
|
||||
|
||||
@ -92,7 +90,7 @@ namespace boost_concepts
|
||||
|
||||
BOOST_concept(LvalueIterator,(Iterator))
|
||||
{
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
|
||||
typedef typename std::iterator_traits<Iterator>::value_type value_type;
|
||||
|
||||
BOOST_CONCEPT_USAGE(LvalueIterator)
|
||||
{
|
||||
@ -144,7 +142,7 @@ namespace boost_concepts
|
||||
: SinglePassIterator<Iterator>
|
||||
, boost::DefaultConstructible<Iterator>
|
||||
{
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
|
||||
typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
|
||||
|
||||
BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
|
||||
BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
|
||||
@ -221,7 +219,7 @@ namespace boost_concepts
|
||||
boost::random_access_traversal_tag, boost::random_access_traversal_tag)
|
||||
{
|
||||
bool b;
|
||||
typename boost::detail::iterator_traits<Iterator2>::difference_type n;
|
||||
typename std::iterator_traits<Iterator2>::difference_type n;
|
||||
b = i1 < i2;
|
||||
b = i1 <= i2;
|
||||
b = i1 > i2;
|
||||
|
@ -8,7 +8,6 @@
|
||||
#define BOOST_ITERATOR_FACADE_23022003THW_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/iterator.hpp>
|
||||
#include <boost/iterator/interoperable.hpp>
|
||||
#include <boost/iterator/iterator_traits.hpp>
|
||||
#include <boost/iterator/iterator_categories.hpp>
|
||||
@ -17,7 +16,7 @@
|
||||
#include <boost/iterator/detail/enable_if.hpp>
|
||||
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/utility/addressof.hpp>
|
||||
#include <boost/core/addressof.hpp>
|
||||
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/type_traits/add_const.hpp>
|
||||
@ -37,6 +36,8 @@
|
||||
#include <boost/mpl/apply.hpp>
|
||||
#include <boost/mpl/identity.hpp>
|
||||
|
||||
#include <cstddef>
|
||||
|
||||
#include <boost/iterator/detail/config_def.hpp> // this goes last
|
||||
|
||||
namespace boost {
|
||||
|
@ -5,9 +5,10 @@
|
||||
#ifndef ITERATOR_TRAITS_DWA200347_HPP
|
||||
# define ITERATOR_TRAITS_DWA200347_HPP
|
||||
|
||||
# include <boost/detail/iterator.hpp>
|
||||
# include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <iterator>
|
||||
|
||||
namespace boost {
|
||||
namespace iterators {
|
||||
|
||||
@ -19,32 +20,32 @@ namespace iterators {
|
||||
template <class Iterator>
|
||||
struct iterator_value
|
||||
{
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::value_type type;
|
||||
typedef typename std::iterator_traits<Iterator>::value_type type;
|
||||
};
|
||||
|
||||
template <class Iterator>
|
||||
struct iterator_reference
|
||||
{
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::reference type;
|
||||
typedef typename std::iterator_traits<Iterator>::reference type;
|
||||
};
|
||||
|
||||
|
||||
template <class Iterator>
|
||||
struct iterator_pointer
|
||||
{
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::pointer type;
|
||||
typedef typename std::iterator_traits<Iterator>::pointer type;
|
||||
};
|
||||
|
||||
template <class Iterator>
|
||||
struct iterator_difference
|
||||
{
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::difference_type type;
|
||||
typedef typename std::iterator_traits<Iterator>::difference_type type;
|
||||
};
|
||||
|
||||
template <class Iterator>
|
||||
struct iterator_category
|
||||
{
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::iterator_category type;
|
||||
typedef typename std::iterator_traits<Iterator>::iterator_category type;
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
|
@ -29,17 +29,18 @@
|
||||
// (David Abrahams)
|
||||
|
||||
# include <iterator>
|
||||
# include <boost/type_traits.hpp>
|
||||
# include <boost/static_assert.hpp>
|
||||
# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
|
||||
# include <boost/detail/iterator.hpp>
|
||||
# include <boost/pending/iterator_tests.hpp>
|
||||
# include <boost/iterator/is_readable_iterator.hpp>
|
||||
# include <boost/iterator/is_lvalue_iterator.hpp>
|
||||
# include <boost/type_traits/is_same.hpp>
|
||||
# include <boost/mpl/bool.hpp>
|
||||
# include <boost/mpl/and.hpp>
|
||||
|
||||
# include <boost/iterator/detail/config_def.hpp>
|
||||
# include <boost/detail/is_incrementable.hpp>
|
||||
# include <boost/detail/lightweight_test.hpp>
|
||||
# include <boost/core/lightweight_test.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
@ -76,7 +77,7 @@ template <class Iterator, class T>
|
||||
void readable_iterator_test(const Iterator i1, T v)
|
||||
{
|
||||
Iterator i2(i1); // Copy Constructible
|
||||
typedef typename detail::iterator_traits<Iterator>::reference ref_t;
|
||||
typedef typename std::iterator_traits<Iterator>::reference ref_t;
|
||||
ref_t r1 = *i1;
|
||||
ref_t r2 = *i2;
|
||||
T v1 = r1;
|
||||
@ -112,9 +113,9 @@ template <class Iterator>
|
||||
void swappable_iterator_test(Iterator i, Iterator j)
|
||||
{
|
||||
Iterator i2(i), j2(j);
|
||||
typename detail::iterator_traits<Iterator>::value_type bi = *i, bj = *j;
|
||||
typename std::iterator_traits<Iterator>::value_type bi = *i, bj = *j;
|
||||
iter_swap(i2, j2);
|
||||
typename detail::iterator_traits<Iterator>::value_type ai = *i, aj = *j;
|
||||
typename std::iterator_traits<Iterator>::value_type ai = *i, aj = *j;
|
||||
BOOST_TEST(bi == aj && bj == ai);
|
||||
}
|
||||
|
||||
@ -122,8 +123,8 @@ template <class Iterator, class T>
|
||||
void constant_lvalue_iterator_test(Iterator i, T v1)
|
||||
{
|
||||
Iterator i2(i);
|
||||
typedef typename detail::iterator_traits<Iterator>::value_type value_type;
|
||||
typedef typename detail::iterator_traits<Iterator>::reference reference;
|
||||
typedef typename std::iterator_traits<Iterator>::value_type value_type;
|
||||
typedef typename std::iterator_traits<Iterator>::reference reference;
|
||||
BOOST_STATIC_ASSERT((is_same<const value_type&, reference>::value));
|
||||
const T& v2 = *i2;
|
||||
BOOST_TEST(v1 == v2);
|
||||
@ -137,8 +138,8 @@ template <class Iterator, class T>
|
||||
void non_const_lvalue_iterator_test(Iterator i, T v1, T v2)
|
||||
{
|
||||
Iterator i2(i);
|
||||
typedef typename detail::iterator_traits<Iterator>::value_type value_type;
|
||||
typedef typename detail::iterator_traits<Iterator>::reference reference;
|
||||
typedef typename std::iterator_traits<Iterator>::value_type value_type;
|
||||
typedef typename std::iterator_traits<Iterator>::reference reference;
|
||||
BOOST_STATIC_ASSERT((is_same<value_type&, reference>::value));
|
||||
T& v3 = *i2;
|
||||
BOOST_TEST(v1 == v3);
|
||||
@ -229,7 +230,7 @@ void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals)
|
||||
{
|
||||
BOOST_TEST(i == j + c);
|
||||
BOOST_TEST(*i == vals[c]);
|
||||
typename detail::iterator_traits<Iterator>::value_type x = j[c];
|
||||
typename std::iterator_traits<Iterator>::value_type x = j[c];
|
||||
BOOST_TEST(*i == x);
|
||||
BOOST_TEST(*i == *(j + c));
|
||||
BOOST_TEST(*i == *(c + j));
|
||||
@ -245,7 +246,7 @@ void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals)
|
||||
{
|
||||
BOOST_TEST(i == k - c);
|
||||
BOOST_TEST(*i == vals[N - 1 - c]);
|
||||
typename detail::iterator_traits<Iterator>::value_type x = j[N - 1 - c];
|
||||
typename std::iterator_traits<Iterator>::value_type x = j[N - 1 - c];
|
||||
BOOST_TEST(*i == x);
|
||||
Iterator q = k - c;
|
||||
BOOST_TEST(*i == *q);
|
||||
|
@ -21,13 +21,13 @@ template< class ElementIterator
|
||||
class permutation_iterator
|
||||
: public iterator_adaptor<
|
||||
permutation_iterator<ElementIterator, IndexIterator>
|
||||
, IndexIterator, typename boost::detail::iterator_traits<ElementIterator>::value_type
|
||||
, use_default, typename boost::detail::iterator_traits<ElementIterator>::reference>
|
||||
, IndexIterator, typename std::iterator_traits<ElementIterator>::value_type
|
||||
, use_default, typename std::iterator_traits<ElementIterator>::reference>
|
||||
{
|
||||
typedef iterator_adaptor<
|
||||
permutation_iterator<ElementIterator, IndexIterator>
|
||||
, IndexIterator, typename boost::detail::iterator_traits<ElementIterator>::value_type
|
||||
, use_default, typename boost::detail::iterator_traits<ElementIterator>::reference> super_t;
|
||||
, IndexIterator, typename std::iterator_traits<ElementIterator>::value_type
|
||||
, use_default, typename std::iterator_traits<ElementIterator>::reference> super_t;
|
||||
|
||||
friend class iterator_core_access;
|
||||
|
||||
|
@ -7,7 +7,6 @@
|
||||
#ifndef BOOST_REVERSE_ITERATOR_23022003THW_HPP
|
||||
#define BOOST_REVERSE_ITERATOR_23022003THW_HPP
|
||||
|
||||
#include <boost/iterator.hpp>
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
@ -7,7 +7,6 @@
|
||||
#ifndef BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
|
||||
#define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
|
||||
|
||||
#include <boost/iterator.hpp>
|
||||
#include <boost/iterator/detail/enable_if.hpp>
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
#include <boost/iterator/iterator_categories.hpp>
|
||||
@ -22,11 +21,12 @@
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
|
||||
#include <iterator>
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
|
||||
# include <boost/type_traits/is_base_and_derived.hpp>
|
||||
|
||||
#endif
|
||||
|
||||
#include <boost/iterator/detail/config_def.hpp>
|
||||
|
||||
|
||||
@ -47,7 +47,11 @@ namespace iterators {
|
||||
// the function.
|
||||
typedef typename ia_dflt_help<
|
||||
Reference
|
||||
#ifdef BOOST_RESULT_OF_USE_TR1
|
||||
, result_of<const UnaryFunc(typename std::iterator_traits<Iterator>::reference)>
|
||||
#else
|
||||
, result_of<const UnaryFunc&(typename std::iterator_traits<Iterator>::reference)>
|
||||
#endif
|
||||
>::type reference;
|
||||
|
||||
// To get the default for Value: remove any reference on the
|
||||
|
@ -9,7 +9,6 @@
|
||||
# define BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
|
||||
|
||||
#include <stddef.h>
|
||||
#include <boost/iterator.hpp>
|
||||
#include <boost/iterator/iterator_traits.hpp>
|
||||
#include <boost/iterator/iterator_facade.hpp>
|
||||
#include <boost/iterator/iterator_adaptor.hpp> // for enable_if_convertible
|
||||
|
195
include/boost/next_prior.hpp
Normal file
195
include/boost/next_prior.hpp
Normal file
@ -0,0 +1,195 @@
|
||||
// Boost next_prior.hpp header file ---------------------------------------//
|
||||
|
||||
// (C) Copyright Dave Abrahams and Daniel Walker 1999-2003.
|
||||
// Copyright (c) Andrey Semashev 2017
|
||||
//
|
||||
// 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/utility for documentation.
|
||||
|
||||
// Revision History
|
||||
// 13 Dec 2003 Added next(x, n) and prior(x, n) (Daniel Walker)
|
||||
|
||||
#ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
|
||||
#define BOOST_NEXT_PRIOR_HPP_INCLUDED
|
||||
|
||||
#include <iterator>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/core/enable_if.hpp>
|
||||
#include <boost/type_traits/has_plus.hpp>
|
||||
#include <boost/type_traits/has_plus_assign.hpp>
|
||||
#include <boost/type_traits/has_minus.hpp>
|
||||
#include <boost/type_traits/has_minus_assign.hpp>
|
||||
#include <boost/iterator/advance.hpp>
|
||||
#include <boost/iterator/reverse_iterator.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
// Helper functions for classes like bidirectional iterators not supporting
|
||||
// operator+ and operator-
|
||||
//
|
||||
// Usage:
|
||||
// const std::list<T>::iterator p = get_some_iterator();
|
||||
// const std::list<T>::iterator prev = boost::prior(p);
|
||||
// const std::list<T>::iterator next = boost::next(prev, 2);
|
||||
|
||||
// Contributed by Dave Abrahams
|
||||
|
||||
namespace next_prior_detail {
|
||||
|
||||
// The trait attempts to detect if the T type is an iterator. Class-type iterators are assumed
|
||||
// to have the nested type iterator_category. Strictly speaking, this is not required to be the
|
||||
// case (e.g. a user can specialize iterator_traits for T without defining T::iterator_category).
|
||||
// Still, this is a good heuristic in practice, and we can't do anything better anyway.
|
||||
// Since C++17 we can test for iterator_traits<T>::iterator_category presence instead as it is
|
||||
// required to be only present for iterators.
|
||||
template< typename T, typename Void = void >
|
||||
struct is_iterator_class
|
||||
{
|
||||
static BOOST_CONSTEXPR_OR_CONST bool value = false;
|
||||
};
|
||||
|
||||
template< typename T >
|
||||
struct is_iterator_class<
|
||||
T,
|
||||
typename enable_if_has_type<
|
||||
#if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
|
||||
typename std::iterator_traits< T >::iterator_category
|
||||
#else
|
||||
typename T::iterator_category
|
||||
#endif
|
||||
>::type
|
||||
>
|
||||
{
|
||||
static BOOST_CONSTEXPR_OR_CONST bool value = true;
|
||||
};
|
||||
|
||||
template< typename T >
|
||||
struct is_iterator :
|
||||
public is_iterator_class< T >
|
||||
{
|
||||
};
|
||||
|
||||
template< typename T >
|
||||
struct is_iterator< T* >
|
||||
{
|
||||
static BOOST_CONSTEXPR_OR_CONST bool value = true;
|
||||
};
|
||||
|
||||
|
||||
template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
|
||||
struct next_plus_impl;
|
||||
|
||||
template< typename T, typename Distance >
|
||||
struct next_plus_impl< T, Distance, true >
|
||||
{
|
||||
static T call(T x, Distance n)
|
||||
{
|
||||
return x + n;
|
||||
}
|
||||
};
|
||||
|
||||
template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value >
|
||||
struct next_plus_assign_impl :
|
||||
public next_plus_impl< T, Distance >
|
||||
{
|
||||
};
|
||||
|
||||
template< typename T, typename Distance >
|
||||
struct next_plus_assign_impl< T, Distance, true >
|
||||
{
|
||||
static T call(T x, Distance n)
|
||||
{
|
||||
x += n;
|
||||
return x;
|
||||
}
|
||||
};
|
||||
|
||||
template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
|
||||
struct next_advance_impl :
|
||||
public next_plus_assign_impl< T, Distance >
|
||||
{
|
||||
};
|
||||
|
||||
template< typename T, typename Distance >
|
||||
struct next_advance_impl< T, Distance, true >
|
||||
{
|
||||
static T call(T x, Distance n)
|
||||
{
|
||||
boost::iterators::advance(x, n);
|
||||
return x;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value >
|
||||
struct prior_minus_impl;
|
||||
|
||||
template< typename T, typename Distance >
|
||||
struct prior_minus_impl< T, Distance, true >
|
||||
{
|
||||
static T call(T x, Distance n)
|
||||
{
|
||||
return x - n;
|
||||
}
|
||||
};
|
||||
|
||||
template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value >
|
||||
struct prior_minus_assign_impl :
|
||||
public prior_minus_impl< T, Distance >
|
||||
{
|
||||
};
|
||||
|
||||
template< typename T, typename Distance >
|
||||
struct prior_minus_assign_impl< T, Distance, true >
|
||||
{
|
||||
static T call(T x, Distance n)
|
||||
{
|
||||
x -= n;
|
||||
return x;
|
||||
}
|
||||
};
|
||||
|
||||
template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
|
||||
struct prior_advance_impl :
|
||||
public prior_minus_assign_impl< T, Distance >
|
||||
{
|
||||
};
|
||||
|
||||
template< typename T, typename Distance >
|
||||
struct prior_advance_impl< T, Distance, true >
|
||||
{
|
||||
static T call(T x, Distance n)
|
||||
{
|
||||
// Avoid negating n to sidestep possible integer overflow
|
||||
boost::iterators::reverse_iterator< T > rx(x);
|
||||
boost::iterators::advance(rx, n);
|
||||
return rx.base();
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace next_prior_detail
|
||||
|
||||
template <class T>
|
||||
inline T next(T x) { return ++x; }
|
||||
|
||||
template <class T, class Distance>
|
||||
inline T next(T x, Distance n)
|
||||
{
|
||||
return next_prior_detail::next_advance_impl< T, Distance >::call(x, n);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T prior(T x) { return --x; }
|
||||
|
||||
template <class T, class Distance>
|
||||
inline T prior(T x, Distance n)
|
||||
{
|
||||
return next_prior_detail::prior_advance_impl< T, Distance >::call(x, n);
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NEXT_PRIOR_HPP_INCLUDED
|
@ -6,11 +6,12 @@
|
||||
#ifndef BOOST_INT_ITERATOR_H
|
||||
#define BOOST_INT_ITERATOR_H
|
||||
|
||||
#include <boost/iterator.hpp>
|
||||
#if !defined BOOST_MSVC
|
||||
#include <boost/operators.hpp>
|
||||
#endif
|
||||
#include <iostream>
|
||||
#include <iterator>
|
||||
#include <cstddef>
|
||||
//using namespace std;
|
||||
|
||||
#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
|
||||
|
@ -20,11 +20,14 @@
|
||||
// (David Abrahams)
|
||||
|
||||
# include <iterator>
|
||||
# include <assert.h>
|
||||
# include <boost/type_traits.hpp>
|
||||
# include <boost/static_assert.hpp>
|
||||
# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
|
||||
# include <boost/implicit_cast.hpp>
|
||||
# include <boost/core/ignore_unused.hpp>
|
||||
# include <boost/core/lightweight_test.hpp>
|
||||
# include <boost/type_traits/is_same.hpp>
|
||||
# include <boost/type_traits/is_pointer.hpp>
|
||||
# include <boost/type_traits/is_reference.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
@ -50,27 +53,29 @@ template <class Iterator, class T>
|
||||
void trivial_iterator_test(const Iterator i, const Iterator j, T val)
|
||||
{
|
||||
Iterator k;
|
||||
assert(i == i);
|
||||
assert(j == j);
|
||||
assert(i != j);
|
||||
BOOST_TEST(i == i);
|
||||
BOOST_TEST(j == j);
|
||||
BOOST_TEST(i != j);
|
||||
#ifdef BOOST_NO_STD_ITERATOR_TRAITS
|
||||
T v = *i;
|
||||
#else
|
||||
typename std::iterator_traits<Iterator>::value_type v = *i;
|
||||
#endif
|
||||
assert(v == val);
|
||||
BOOST_TEST(v == val);
|
||||
boost::ignore_unused(v);
|
||||
#if 0
|
||||
// hmm, this will give a warning for transform_iterator... perhaps
|
||||
// this should be separated out into a stand-alone test since there
|
||||
// are several situations where it can't be used, like for
|
||||
// integer_range::iterator.
|
||||
assert(v == i->foo());
|
||||
BOOST_TEST(v == i->foo());
|
||||
#endif
|
||||
k = i;
|
||||
assert(k == k);
|
||||
assert(k == i);
|
||||
assert(k != j);
|
||||
assert(*k == val);
|
||||
BOOST_TEST(k == k);
|
||||
BOOST_TEST(k == i);
|
||||
BOOST_TEST(k != j);
|
||||
BOOST_TEST(*k == val);
|
||||
boost::ignore_unused(k);
|
||||
}
|
||||
|
||||
|
||||
@ -89,8 +94,8 @@ void input_iterator_test(Iterator i, T v1, T v2)
|
||||
{
|
||||
Iterator i1(i);
|
||||
|
||||
assert(i == i1);
|
||||
assert(!(i != i1));
|
||||
BOOST_TEST(i == i1);
|
||||
BOOST_TEST(!(i != i1));
|
||||
|
||||
// I can see no generic way to create an input iterator
|
||||
// that is in the domain of== of i and != i.
|
||||
@ -99,23 +104,25 @@ void input_iterator_test(Iterator i, T v1, T v2)
|
||||
//
|
||||
// Iterator i2;
|
||||
//
|
||||
// assert(i != i2);
|
||||
// assert(!(i == i2));
|
||||
// BOOST_TEST(i != i2);
|
||||
// BOOST_TEST(!(i == i2));
|
||||
|
||||
assert(*i1 == v1);
|
||||
assert(*i == v1);
|
||||
BOOST_TEST(*i1 == v1);
|
||||
BOOST_TEST(*i == v1);
|
||||
|
||||
// we cannot test for equivalence of (void)++i & (void)i++
|
||||
// as i is only guaranteed to be single pass.
|
||||
assert(*i++ == v1);
|
||||
BOOST_TEST(*i++ == v1);
|
||||
boost::ignore_unused(i1);
|
||||
|
||||
i1 = i;
|
||||
|
||||
assert(i == i1);
|
||||
assert(!(i != i1));
|
||||
BOOST_TEST(i == i1);
|
||||
BOOST_TEST(!(i != i1));
|
||||
|
||||
assert(*i1 == v2);
|
||||
assert(*i == v2);
|
||||
BOOST_TEST(*i1 == v2);
|
||||
BOOST_TEST(*i == v2);
|
||||
boost::ignore_unused(i1);
|
||||
|
||||
// i is dereferencable, so it must be incrementable.
|
||||
++i;
|
||||
@ -157,15 +164,15 @@ void forward_iterator_test(Iterator i, T v1, T v2)
|
||||
|
||||
Iterator i1 = i, i2 = i;
|
||||
|
||||
assert(i == i1++);
|
||||
assert(i != ++i2);
|
||||
BOOST_TEST(i == i1++);
|
||||
BOOST_TEST(i != ++i2);
|
||||
|
||||
trivial_iterator_test(i, i1, v1);
|
||||
trivial_iterator_test(i, i2, v1);
|
||||
|
||||
++i;
|
||||
assert(i == i1);
|
||||
assert(i == i2);
|
||||
BOOST_TEST(i == i1);
|
||||
BOOST_TEST(i == i2);
|
||||
++i1;
|
||||
++i2;
|
||||
|
||||
@ -173,7 +180,7 @@ void forward_iterator_test(Iterator i, T v1, T v2)
|
||||
trivial_iterator_test(i, i2, v2);
|
||||
|
||||
// borland doesn't allow non-type template parameters
|
||||
# if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
|
||||
# if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
|
||||
lvalue_test<(boost::is_pointer<Iterator>::value)>::check(i);
|
||||
#endif
|
||||
}
|
||||
@ -187,15 +194,15 @@ void bidirectional_iterator_test(Iterator i, T v1, T v2)
|
||||
|
||||
Iterator i1 = i, i2 = i;
|
||||
|
||||
assert(i == i1--);
|
||||
assert(i != --i2);
|
||||
BOOST_TEST(i == i1--);
|
||||
BOOST_TEST(i != --i2);
|
||||
|
||||
trivial_iterator_test(i, i1, v2);
|
||||
trivial_iterator_test(i, i2, v2);
|
||||
|
||||
--i;
|
||||
assert(i == i1);
|
||||
assert(i == i2);
|
||||
BOOST_TEST(i == i1);
|
||||
BOOST_TEST(i == i2);
|
||||
++i1;
|
||||
++i2;
|
||||
|
||||
@ -215,32 +222,34 @@ void random_access_iterator_test(Iterator i, int N, TrueVals vals)
|
||||
const Iterator j = i;
|
||||
int c;
|
||||
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
|
||||
typedef typename std::iterator_traits<Iterator>::value_type value_type;
|
||||
boost::ignore_unused<value_type>();
|
||||
|
||||
for (c = 0; c < N-1; ++c) {
|
||||
assert(i == j + c);
|
||||
assert(*i == vals[c]);
|
||||
assert(*i == boost::implicit_cast<value_type>(j[c]));
|
||||
assert(*i == *(j + c));
|
||||
assert(*i == *(c + j));
|
||||
BOOST_TEST(i == j + c);
|
||||
BOOST_TEST(*i == vals[c]);
|
||||
BOOST_TEST(*i == boost::implicit_cast<value_type>(j[c]));
|
||||
BOOST_TEST(*i == *(j + c));
|
||||
BOOST_TEST(*i == *(c + j));
|
||||
++i;
|
||||
assert(i > j);
|
||||
assert(i >= j);
|
||||
assert(j <= i);
|
||||
assert(j < i);
|
||||
BOOST_TEST(i > j);
|
||||
BOOST_TEST(i >= j);
|
||||
BOOST_TEST(j <= i);
|
||||
BOOST_TEST(j < i);
|
||||
}
|
||||
|
||||
Iterator k = j + N - 1;
|
||||
for (c = 0; c < N-1; ++c) {
|
||||
assert(i == k - c);
|
||||
assert(*i == vals[N - 1 - c]);
|
||||
assert(*i == boost::implicit_cast<value_type>(j[N - 1 - c]));
|
||||
BOOST_TEST(i == k - c);
|
||||
BOOST_TEST(*i == vals[N - 1 - c]);
|
||||
BOOST_TEST(*i == boost::implicit_cast<value_type>(j[N - 1 - c]));
|
||||
Iterator q = k - c;
|
||||
assert(*i == *q);
|
||||
assert(i > j);
|
||||
assert(i >= j);
|
||||
assert(j <= i);
|
||||
assert(j < i);
|
||||
boost::ignore_unused(q);
|
||||
BOOST_TEST(*i == *q);
|
||||
BOOST_TEST(i > j);
|
||||
BOOST_TEST(i >= j);
|
||||
BOOST_TEST(j <= i);
|
||||
BOOST_TEST(j < i);
|
||||
--i;
|
||||
}
|
||||
}
|
||||
@ -249,16 +258,17 @@ void random_access_iterator_test(Iterator i, int N, TrueVals vals)
|
||||
template <class Iterator, class ConstIterator>
|
||||
void const_nonconst_iterator_test(Iterator i, ConstIterator j)
|
||||
{
|
||||
assert(i != j);
|
||||
assert(j != i);
|
||||
BOOST_TEST(i != j);
|
||||
BOOST_TEST(j != i);
|
||||
|
||||
ConstIterator k(i);
|
||||
assert(k == i);
|
||||
assert(i == k);
|
||||
BOOST_TEST(k == i);
|
||||
BOOST_TEST(i == k);
|
||||
|
||||
k = i;
|
||||
assert(k == i);
|
||||
assert(i == k);
|
||||
BOOST_TEST(k == i);
|
||||
BOOST_TEST(i == k);
|
||||
boost::ignore_unused(k);
|
||||
}
|
||||
|
||||
} // namespace iterators
|
||||
|
@ -20,6 +20,8 @@
|
||||
# include <boost/mpl/if.hpp>
|
||||
# include <boost/mpl/eval_if.hpp>
|
||||
|
||||
#include <iterator>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace detail
|
||||
@ -33,7 +35,7 @@ namespace detail
|
||||
template <class Iterator>
|
||||
struct iterator_pointee
|
||||
{
|
||||
typedef typename iterator_traits<Iterator>::value_type value_type;
|
||||
typedef typename std::iterator_traits<Iterator>::value_type value_type;
|
||||
|
||||
struct impl
|
||||
{
|
||||
@ -48,7 +50,7 @@ namespace detail
|
||||
BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1);
|
||||
|
||||
typedef typename mpl::if_c<
|
||||
# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
|
||||
# if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
|
||||
::boost::detail::iterator_pointee<Iterator>::is_constant
|
||||
# else
|
||||
is_constant
|
||||
|
@ -5,8 +5,8 @@
|
||||
|
||||
// See http://www.boost.org/libs/utility/shared_container_iterator.html for documentation.
|
||||
|
||||
#ifndef SHARED_CONTAINER_ITERATOR_RG08102002_HPP
|
||||
#define SHARED_CONTAINER_ITERATOR_RG08102002_HPP
|
||||
#ifndef BOOST_SHARED_CONTAINER_ITERATOR_HPP
|
||||
#define BOOST_SHARED_CONTAINER_ITERATOR_HPP
|
||||
|
||||
#include "boost/iterator_adaptors.hpp"
|
||||
#include "boost/shared_ptr.hpp"
|
||||
@ -66,4 +66,4 @@ using iterators::make_shared_container_range;
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // SHARED_CONTAINER_ITERATOR_RG08102002_HPP
|
||||
#endif
|
||||
|
@ -56,6 +56,11 @@ test-suite iterator
|
||||
[ run minimum_category.cpp ]
|
||||
[ compile-fail minimum_category_compile_fail.cpp ]
|
||||
|
||||
[ run next_prior_test.cpp ]
|
||||
[ run advance_test.cpp ]
|
||||
[ run distance_test.cpp ]
|
||||
[ compile adl_test.cpp ]
|
||||
[ compile range_distance_compat_test.cpp ]
|
||||
|
||||
[ run shared_iterator_test.cpp ]
|
||||
;
|
||||
|
25
test/adl_test.cpp
Normal file
25
test/adl_test.cpp
Normal file
@ -0,0 +1,25 @@
|
||||
// Copyright (C) 2017 Michel Morin.
|
||||
//
|
||||
// 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 <vector>
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/iterator/advance.hpp>
|
||||
#include <boost/iterator/distance.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
// Test that boost::advance/distance are not found by ADL.
|
||||
// (https://github.com/boostorg/iterator/issues/43)
|
||||
|
||||
typedef boost::array<int, 1> boost_type;
|
||||
std::vector<boost_type> std_boost(2);
|
||||
std::vector<boost_type>::iterator it = std_boost.begin();
|
||||
|
||||
advance(it, 2);
|
||||
(void)distance(it, it);
|
||||
|
||||
return 0;
|
||||
}
|
@ -7,14 +7,22 @@
|
||||
#include <boost/iterator/iterator_categories.hpp>
|
||||
#include <boost/operators.hpp>
|
||||
|
||||
#include <iterator>
|
||||
#include <cstddef>
|
||||
|
||||
struct new_random_access
|
||||
: std::random_access_iterator_tag
|
||||
, boost::random_access_traversal_tag
|
||||
{};
|
||||
|
||||
struct new_iterator
|
||||
: public boost::iterator< new_random_access, int >
|
||||
{
|
||||
typedef new_random_access iterator_category;
|
||||
typedef int value_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef int* pointer;
|
||||
typedef int& reference;
|
||||
|
||||
int& operator*() const { return *m_x; }
|
||||
new_iterator& operator++() { return *this; }
|
||||
new_iterator operator++(int) { return *this; }
|
||||
@ -33,8 +41,13 @@ struct new_iterator
|
||||
new_iterator operator+(std::ptrdiff_t, new_iterator x) { return x; }
|
||||
|
||||
struct old_iterator
|
||||
: public boost::iterator<std::random_access_iterator_tag, int>
|
||||
{
|
||||
typedef std::random_access_iterator_tag iterator_category;
|
||||
typedef int value_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef int* pointer;
|
||||
typedef int& reference;
|
||||
|
||||
int& operator*() const { return *m_x; }
|
||||
old_iterator& operator++() { return *this; }
|
||||
old_iterator operator++(int) { return *this; }
|
||||
@ -58,7 +71,7 @@ main()
|
||||
boost::iterator_traversal<new_iterator>::type tc;
|
||||
boost::random_access_traversal_tag derived = tc;
|
||||
(void)derived;
|
||||
|
||||
|
||||
boost::function_requires<
|
||||
boost_concepts::WritableIteratorConcept<int*> >();
|
||||
boost::function_requires<
|
||||
|
@ -17,7 +17,7 @@
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#ifdef __BORLANDC__ // Borland mis-detects our custom iterators
|
||||
#ifdef BOOST_BORLANDC // Borland mis-detects our custom iterators
|
||||
# pragma warn -8091 // template argument ForwardIterator passed to '...' is a output iterator
|
||||
# pragma warn -8071 // Conversion may lose significant digits (due to counting_iterator<char> += n).
|
||||
#endif
|
||||
@ -26,13 +26,11 @@
|
||||
# pragma warning(disable:4786) // identifier truncated in debug info
|
||||
#endif
|
||||
|
||||
#include <boost/detail/iterator.hpp>
|
||||
#include <boost/iterator/counting_iterator.hpp>
|
||||
#include <boost/iterator/new_iterator_tests.hpp>
|
||||
|
||||
#include <boost/next_prior.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/detail/iterator.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
|
||||
@ -40,12 +38,12 @@
|
||||
#include <climits>
|
||||
#include <iterator>
|
||||
#include <stdlib.h>
|
||||
#ifndef __BORLANDC__
|
||||
#ifndef BOOST_BORLANDC
|
||||
# include <boost/tuple/tuple.hpp>
|
||||
#endif
|
||||
#endif
|
||||
#include <vector>
|
||||
#include <list>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#ifndef BOOST_NO_SLIST
|
||||
# ifdef BOOST_SLIST_HEADER
|
||||
# include BOOST_SLIST_HEADER
|
||||
@ -88,19 +86,19 @@ void category_test(
|
||||
std::random_access_iterator_tag)
|
||||
{
|
||||
typedef typename
|
||||
boost::detail::iterator_traits<CountingIterator>::difference_type
|
||||
std::iterator_traits<CountingIterator>::difference_type
|
||||
difference_type;
|
||||
difference_type distance = boost::detail::distance(start, finish);
|
||||
difference_type distance = std::distance(start, finish);
|
||||
|
||||
// Pick a random position internal to the range
|
||||
difference_type offset = (unsigned)rand() % distance;
|
||||
|
||||
|
||||
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
BOOST_TEST(offset >= 0);
|
||||
#else
|
||||
#else
|
||||
assert_nonnegative<difference_type>::test(offset);
|
||||
#endif
|
||||
|
||||
|
||||
CountingIterator internal = start;
|
||||
std::advance(internal, offset);
|
||||
|
||||
@ -111,8 +109,8 @@ void category_test(
|
||||
std::pair<CountingIterator,CountingIterator> xy(
|
||||
std::equal_range(start, finish, *internal));
|
||||
CountingIterator x = xy.first, y = xy.second;
|
||||
|
||||
BOOST_TEST(boost::detail::distance(x, y) == 1);
|
||||
|
||||
BOOST_TEST(std::distance(x, y) == 1);
|
||||
|
||||
// Show that values outside the range can't be found
|
||||
BOOST_TEST(!std::binary_search(start, boost::prior(finish), *finish));
|
||||
@ -122,7 +120,7 @@ void category_test(
|
||||
std::vector<value_type> v;
|
||||
for (value_type z = *start; !(z == *finish); ++z)
|
||||
v.push_back(z);
|
||||
|
||||
|
||||
// Note that this test requires a that the first argument is
|
||||
// dereferenceable /and/ a valid iterator prior to the first argument
|
||||
boost::random_access_iterator_test(start, v.size(), v.begin());
|
||||
@ -153,7 +151,6 @@ template <class CountingIterator, class Value>
|
||||
void test_aux(CountingIterator start, CountingIterator finish, Value v1)
|
||||
{
|
||||
typedef typename CountingIterator::iterator_category category;
|
||||
typedef typename CountingIterator::value_type value_type;
|
||||
|
||||
// If it's a RandomAccessIterator we can do a few delicate tests
|
||||
category_test(start, finish, v1, category());
|
||||
@ -201,11 +198,11 @@ void test_container(Container* = 0) // default arg works around MSVC bug
|
||||
Container c(1 + (unsigned)rand() % 1673);
|
||||
|
||||
const typename Container::iterator start = c.begin();
|
||||
|
||||
|
||||
// back off by 1 to leave room for dereferenceable value at the end
|
||||
typename Container::iterator finish = start;
|
||||
std::advance(finish, c.size() - 1);
|
||||
|
||||
|
||||
test(start, finish);
|
||||
|
||||
typedef typename Container::const_iterator const_iterator;
|
||||
@ -284,14 +281,14 @@ int main()
|
||||
test_integer3<long, std::random_access_iterator_tag, int>();
|
||||
test_integer<my_int2>();
|
||||
test_integer<my_int3>();
|
||||
|
||||
|
||||
// Some tests on container iterators, to prove we handle a few different categories
|
||||
test_container<std::vector<int> >();
|
||||
test_container<std::list<int> >();
|
||||
# ifndef BOOST_NO_SLIST
|
||||
test_container<BOOST_STD_EXTENSION_NAMESPACE::slist<int> >();
|
||||
# endif
|
||||
|
||||
|
||||
// Also prove that we can handle raw pointers.
|
||||
int array[2000];
|
||||
test(boost::make_counting_iterator(array), boost::make_counting_iterator(array+2000-1));
|
||||
|
@ -6,7 +6,7 @@
|
||||
//
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <boost/assign/list_of.hpp>
|
||||
#include <boost/fusion/include/at.hpp>
|
||||
@ -62,7 +62,7 @@ int main()
|
||||
// Trac #12895
|
||||
boost::zip_iterator<
|
||||
TUPLE<int*, std::string*>
|
||||
> i(MAKE_TUPLE(vi.data(), vs.data()));
|
||||
> i(MAKE_TUPLE(&vi[0], &vs[0]));
|
||||
|
||||
BOOST_TEST(boost::fusion::at_c<0>(* i ) == 42);
|
||||
BOOST_TEST(boost::fusion::at_c<1>(* i ) == "kokoro");
|
||||
|
@ -1,4 +1,4 @@
|
||||
// Copyright David Abrahams 2003, Jeremy Siek 2004.
|
||||
// Copyright David Abrahams 2003, Jeremy Siek 2004.
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
@ -18,7 +18,7 @@
|
||||
#include <iostream>
|
||||
|
||||
using boost::dummyT;
|
||||
|
||||
|
||||
struct one_or_four
|
||||
{
|
||||
bool operator()(dummyT x) const
|
||||
@ -116,7 +116,7 @@ int main()
|
||||
boost::function_requires< boost_concepts::WritableIteratorConcept<Iter> >();
|
||||
boost::function_requires< boost_concepts::SinglePassIteratorConcept<Iter> >();
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
typedef boost::iterator_archetype<
|
||||
const dummyT
|
||||
@ -128,7 +128,7 @@ int main()
|
||||
boost::function_requires< boost_concepts::ReadableIteratorConcept<Iter> >();
|
||||
boost::function_requires< boost_concepts::ForwardTraversalConcept<Iter> >();
|
||||
}
|
||||
|
||||
|
||||
#if !BOOST_WORKAROUND(BOOST_MSVC, == 1200) // Causes Internal Error in linker.
|
||||
{
|
||||
typedef boost::iterator_archetype<
|
||||
@ -165,7 +165,7 @@ int main()
|
||||
boost::function_requires< boost_concepts::LvalueIteratorConcept<Iter> >();
|
||||
boost::function_requires< boost_concepts::ForwardTraversalConcept<Iter> >();
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
{
|
||||
typedef boost::iterator_archetype<
|
||||
@ -178,7 +178,7 @@ int main()
|
||||
boost::function_requires< boost_concepts::ReadableIteratorConcept<Iter> >();
|
||||
boost::function_requires< boost_concepts::BidirectionalTraversalConcept<Iter> >();
|
||||
}
|
||||
|
||||
|
||||
#if !BOOST_WORKAROUND(BOOST_MSVC, == 1200) // Causes Internal Error in linker.
|
||||
{
|
||||
typedef boost::iterator_archetype<
|
||||
@ -215,11 +215,11 @@ int main()
|
||||
boost::function_requires< boost_concepts::LvalueIteratorConcept<Iter> >();
|
||||
boost::function_requires< boost_concepts::BidirectionalTraversalConcept<Iter> >();
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Run-time tests
|
||||
|
||||
dummyT array[] = { dummyT(0), dummyT(1), dummyT(2),
|
||||
dummyT array[] = { dummyT(0), dummyT(1), dummyT(2),
|
||||
dummyT(3), dummyT(4), dummyT(5) };
|
||||
const int N = sizeof(array)/sizeof(dummyT);
|
||||
|
||||
@ -235,9 +235,9 @@ int main()
|
||||
, boost::random_access_traversal_tag
|
||||
>::value
|
||||
));
|
||||
|
||||
|
||||
//# endif
|
||||
|
||||
|
||||
// On compilers not supporting partial specialization, we can do more type
|
||||
// deduction with deque iterators than with pointers... unless the library
|
||||
// is broken ;-(
|
||||
@ -258,7 +258,7 @@ int main()
|
||||
, boost::make_reverse_iterator(array2.begin())
|
||||
),
|
||||
dummyT(4), dummyT(1));
|
||||
|
||||
|
||||
boost::bidirectional_readable_iterator_test(
|
||||
filter_iter(array+0, array+N),
|
||||
dummyT(1), dummyT(4));
|
||||
|
@ -3,15 +3,24 @@
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <iterator>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
// Force boost::result_of use decltype, even on compilers that don't support N3276.
|
||||
// This enables this test to also verify if the iterator works with lambdas
|
||||
// on such compilers with this config macro. Note that without the macro result_of
|
||||
// (and consequently the iterator) is guaranteed to _not_ work, so this case is not
|
||||
// worth testing anyway.
|
||||
#define BOOST_RESULT_OF_USE_DECLTYPE
|
||||
#endif
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/iterator/function_input_iterator.hpp>
|
||||
|
||||
namespace {
|
||||
@ -40,13 +49,13 @@ struct counter {
|
||||
|
||||
using namespace std;
|
||||
|
||||
int main(int argc, char * argv[])
|
||||
int main()
|
||||
{
|
||||
// test the iterator with function objects
|
||||
ones ones_generator;
|
||||
vector<int> values(10);
|
||||
generate(values.begin(), values.end(), ones());
|
||||
|
||||
|
||||
vector<int> generated;
|
||||
copy(
|
||||
boost::make_function_input_iterator(ones_generator, 0),
|
||||
@ -54,9 +63,7 @@ int main(int argc, char * argv[])
|
||||
back_inserter(generated)
|
||||
);
|
||||
|
||||
assert(values.size() == generated.size());
|
||||
assert(equal(values.begin(), values.end(), generated.begin()));
|
||||
cout << "function iterator test with function objects successful." << endl;
|
||||
BOOST_TEST_ALL_EQ(values.begin(), values.end(), generated.begin(), generated.end());
|
||||
|
||||
// test the iterator with normal functions
|
||||
vector<int>().swap(generated);
|
||||
@ -66,9 +73,7 @@ int main(int argc, char * argv[])
|
||||
back_inserter(generated)
|
||||
);
|
||||
|
||||
assert(values.size() == generated.size());
|
||||
assert(equal(values.begin(), values.end(), generated.begin()));
|
||||
cout << "function iterator test with pointer to function successful." << endl;
|
||||
BOOST_TEST_ALL_EQ(values.begin(), values.end(), generated.begin(), generated.end());
|
||||
|
||||
// test the iterator with a reference to a function
|
||||
vector<int>().swap(generated);
|
||||
@ -78,9 +83,7 @@ int main(int argc, char * argv[])
|
||||
back_inserter(generated)
|
||||
);
|
||||
|
||||
assert(values.size() == generated.size());
|
||||
assert(equal(values.begin(), values.end(), generated.begin()));
|
||||
cout << "function iterator test with reference to function successful." << endl;
|
||||
BOOST_TEST_ALL_EQ(values.begin(), values.end(), generated.begin(), generated.end());
|
||||
|
||||
// test the iterator with a stateful function object
|
||||
counter counter_generator(42);
|
||||
@ -91,13 +94,13 @@ int main(int argc, char * argv[])
|
||||
back_inserter(generated)
|
||||
);
|
||||
|
||||
assert(generated.size() == 10);
|
||||
assert(counter_generator.n == 42 + 10);
|
||||
BOOST_TEST_EQ(generated.size(), 10u);
|
||||
BOOST_TEST_EQ(counter_generator.n, 42 + 10);
|
||||
for(std::size_t i = 0; i != 10; ++i)
|
||||
assert(generated[i] == 42 + i);
|
||||
cout << "function iterator test with stateful function object successful." << endl;
|
||||
BOOST_TEST_EQ(generated[i], static_cast<int>(42 + i));
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
|
||||
#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) \
|
||||
&& defined(BOOST_RESULT_OF_USE_DECLTYPE)
|
||||
// test the iterator with lambda expressions
|
||||
int num = 42;
|
||||
auto lambda_generator = [&num] { return num++; };
|
||||
@ -108,12 +111,10 @@ int main(int argc, char * argv[])
|
||||
back_inserter(generated)
|
||||
);
|
||||
|
||||
assert(generated.size() == 10);
|
||||
BOOST_TEST_EQ(generated.size(), 10u);
|
||||
for(std::size_t i = 0; i != 10; ++i)
|
||||
assert(generated[i] == 42 + i);
|
||||
cout << "function iterator test with lambda expressions successful." << endl;
|
||||
BOOST_TEST_EQ(generated[i], static_cast<int>(42 + i));
|
||||
#endif // BOOST_NO_CXX11_LAMBDAS
|
||||
|
||||
return 0;
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
|
@ -7,7 +7,7 @@
|
||||
//
|
||||
|
||||
#include <boost/generator_iterator.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <algorithm>
|
||||
|
||||
class X
|
||||
|
@ -30,16 +30,16 @@ struct my_ptr {
|
||||
|
||||
// Borland 5.6.4 and earlier drop const all over the place, so this
|
||||
// test will fail in the lines marked with (**)
|
||||
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
typedef boost::indirect_iterator<int**> Iter;
|
||||
STATIC_ASSERT_SAME(Iter::value_type, int);
|
||||
STATIC_ASSERT_SAME(Iter::reference, int&);
|
||||
STATIC_ASSERT_SAME(Iter::pointer, int*);
|
||||
STATIC_ASSERT_SAME(Iter::reference, int&);
|
||||
STATIC_ASSERT_SAME(Iter::pointer, int*);
|
||||
STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
|
||||
|
||||
|
||||
BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
|
||||
std::random_access_iterator_tag>::value));
|
||||
BOOST_STATIC_ASSERT((boost::is_convertible<boost::iterator_traversal<Iter>::type,
|
||||
@ -54,13 +54,13 @@ int main()
|
||||
{
|
||||
typedef boost::indirect_iterator<int**, int> Iter;
|
||||
STATIC_ASSERT_SAME(Iter::value_type, int);
|
||||
STATIC_ASSERT_SAME(Iter::reference, int&);
|
||||
STATIC_ASSERT_SAME(Iter::pointer, int*);
|
||||
STATIC_ASSERT_SAME(Iter::reference, int&);
|
||||
STATIC_ASSERT_SAME(Iter::pointer, int*);
|
||||
}
|
||||
{
|
||||
typedef boost::indirect_iterator<int**, const int> Iter;
|
||||
STATIC_ASSERT_SAME(Iter::value_type, int);
|
||||
STATIC_ASSERT_SAME(Iter::reference, const int&);
|
||||
STATIC_ASSERT_SAME(Iter::reference, const int&);
|
||||
STATIC_ASSERT_SAME(Iter::pointer, const int*); // (**)
|
||||
}
|
||||
{
|
||||
@ -68,9 +68,9 @@ int main()
|
||||
STATIC_ASSERT_SAME(Iter::value_type, zow);
|
||||
STATIC_ASSERT_SAME(Iter::reference, const zow&); // (**)
|
||||
STATIC_ASSERT_SAME(Iter::pointer, const zow*); // (**)
|
||||
|
||||
|
||||
STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
|
||||
|
||||
|
||||
BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
|
||||
std::random_access_iterator_tag>::value));
|
||||
BOOST_STATIC_ASSERT((boost::is_convertible<boost::iterator_traversal<Iter>::type,
|
||||
@ -79,9 +79,9 @@ int main()
|
||||
{
|
||||
typedef boost::indirect_iterator<char**, int, std::random_access_iterator_tag, long&, short> Iter;
|
||||
STATIC_ASSERT_SAME(Iter::value_type, int);
|
||||
STATIC_ASSERT_SAME(Iter::reference, long&);
|
||||
STATIC_ASSERT_SAME(Iter::pointer, int*);
|
||||
STATIC_ASSERT_SAME(Iter::difference_type, short);
|
||||
STATIC_ASSERT_SAME(Iter::reference, long&);
|
||||
STATIC_ASSERT_SAME(Iter::pointer, int*);
|
||||
STATIC_ASSERT_SAME(Iter::difference_type, short);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
@ -24,14 +24,16 @@
|
||||
#include <boost/concept_check.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/next_prior.hpp>
|
||||
|
||||
#include <boost/mpl/has_xxx.hpp>
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <vector>
|
||||
#include <stdlib.h>
|
||||
#include <set>
|
||||
#include <iterator>
|
||||
|
||||
#if !defined(__SGI_STL_PORT) \
|
||||
&& (defined(BOOST_MSVC_STD_ITERATOR) \
|
||||
@ -42,7 +44,7 @@
|
||||
// interoperability (but may support const/mutable interop).
|
||||
# define NO_MUTABLE_CONST_STD_SET_ITERATOR_INTEROPERABILITY
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
template <class T> struct see_type;
|
||||
@ -51,7 +53,7 @@ template <int I> struct see_val;
|
||||
struct my_iterator_tag : public std::random_access_iterator_tag { };
|
||||
|
||||
using boost::dummyT;
|
||||
|
||||
|
||||
typedef std::vector<int> storage;
|
||||
typedef std::vector<int*> pointer_ra_container;
|
||||
typedef std::set<storage::iterator> iterator_set;
|
||||
@ -60,7 +62,7 @@ template <class Container>
|
||||
struct indirect_iterator_pair_generator
|
||||
{
|
||||
typedef boost::indirect_iterator<typename Container::iterator> iterator;
|
||||
|
||||
|
||||
typedef boost::indirect_iterator<
|
||||
typename Container::iterator
|
||||
, typename iterator::value_type const
|
||||
@ -71,7 +73,7 @@ void more_indirect_iterator_tests()
|
||||
{
|
||||
storage store(1000);
|
||||
std::generate(store.begin(), store.end(), rand);
|
||||
|
||||
|
||||
pointer_ra_container ptr_ra_container;
|
||||
iterator_set iter_set;
|
||||
|
||||
@ -88,27 +90,27 @@ void more_indirect_iterator_tests()
|
||||
BOOST_TEST(static_cast<std::size_t>(de - db) == store.size());
|
||||
BOOST_TEST(db + store.size() == de);
|
||||
indirect_ra_container::const_iterator dci = db;
|
||||
|
||||
|
||||
BOOST_TEST(dci == db);
|
||||
|
||||
|
||||
#ifndef NO_MUTABLE_CONST_RA_ITERATOR_INTEROPERABILITY
|
||||
BOOST_TEST(db == dci);
|
||||
#endif
|
||||
|
||||
|
||||
BOOST_TEST(dci != de);
|
||||
BOOST_TEST(dci < de);
|
||||
BOOST_TEST(dci <= de);
|
||||
|
||||
|
||||
#ifndef NO_MUTABLE_CONST_RA_ITERATOR_INTEROPERABILITY
|
||||
BOOST_TEST(de >= dci);
|
||||
BOOST_TEST(de > dci);
|
||||
#endif
|
||||
|
||||
|
||||
dci = de;
|
||||
BOOST_TEST(dci == de);
|
||||
|
||||
boost::random_access_iterator_test(db + 1, store.size() - 1, boost::next(store.begin()));
|
||||
|
||||
|
||||
*db = 999;
|
||||
BOOST_TEST(store.front() == 999);
|
||||
|
||||
@ -123,15 +125,15 @@ void more_indirect_iterator_tests()
|
||||
indirect_set_iterator se(iter_set.end());
|
||||
const_indirect_set_iterator sci(iter_set.begin());
|
||||
BOOST_TEST(sci == sb);
|
||||
|
||||
|
||||
# ifndef NO_MUTABLE_CONST_STD_SET_ITERATOR_INTEROPERABILITY
|
||||
BOOST_TEST(se != sci);
|
||||
# endif
|
||||
|
||||
|
||||
BOOST_TEST(sci != se);
|
||||
sci = se;
|
||||
BOOST_TEST(sci == se);
|
||||
|
||||
|
||||
*boost::prior(se) = 888;
|
||||
BOOST_TEST(store.back() == 888);
|
||||
BOOST_TEST(std::equal(sb, se, store.begin()));
|
||||
@ -143,31 +145,31 @@ void more_indirect_iterator_tests()
|
||||
// element_type detector; defaults to true so the test passes when
|
||||
// has_xxx isn't implemented
|
||||
BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_element_type, element_type, true)
|
||||
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
dummyT array[] = { dummyT(0), dummyT(1), dummyT(2),
|
||||
dummyT array[] = { dummyT(0), dummyT(1), dummyT(2),
|
||||
dummyT(3), dummyT(4), dummyT(5) };
|
||||
const int N = sizeof(array)/sizeof(dummyT);
|
||||
|
||||
# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
|
||||
boost::shared_ptr<dummyT> zz((dummyT*)0); // Why? I don't know, but it suppresses a bad instantiation.
|
||||
# endif
|
||||
|
||||
|
||||
typedef std::vector<boost::shared_ptr<dummyT> > shared_t;
|
||||
shared_t shared;
|
||||
|
||||
|
||||
// Concept checks
|
||||
{
|
||||
typedef boost::indirect_iterator<shared_t::iterator> iter_t;
|
||||
|
||||
BOOST_STATIC_ASSERT(
|
||||
has_element_type<
|
||||
boost::detail::iterator_traits<shared_t::iterator>::value_type
|
||||
std::iterator_traits<shared_t::iterator>::value_type
|
||||
>::value
|
||||
);
|
||||
|
||||
|
||||
typedef boost::indirect_iterator<
|
||||
shared_t::iterator
|
||||
, boost::iterator_value<shared_t::iterator>::type const
|
||||
@ -175,14 +177,14 @@ main()
|
||||
|
||||
# ifndef NO_MUTABLE_CONST_RA_ITERATOR_INTEROPERABILITY
|
||||
boost::function_requires< boost_concepts::InteroperableIteratorConcept<iter_t, c_iter_t> >();
|
||||
# endif
|
||||
# endif
|
||||
}
|
||||
|
||||
// Test indirect_iterator_generator
|
||||
{
|
||||
for (int jj = 0; jj < N; ++jj)
|
||||
shared.push_back(boost::shared_ptr<dummyT>(new dummyT(jj)));
|
||||
|
||||
|
||||
dummyT* ptr[N];
|
||||
for (int k = 0; k < N; ++k)
|
||||
ptr[k] = array + k;
|
||||
@ -200,16 +202,16 @@ main()
|
||||
, N, array);
|
||||
|
||||
boost::random_access_iterator_test(boost::make_indirect_iterator(ptr), N, array);
|
||||
|
||||
|
||||
// check operator->
|
||||
assert((*i).m_x == i->foo());
|
||||
|
||||
const_indirect_iterator j(ptr);
|
||||
boost::random_access_iterator_test(j, N, array);
|
||||
|
||||
|
||||
dummyT const*const* const_ptr = ptr;
|
||||
boost::random_access_iterator_test(boost::make_indirect_iterator(const_ptr), N, array);
|
||||
|
||||
|
||||
boost::const_nonconst_iterator_test(i, ++j);
|
||||
|
||||
more_indirect_iterator_tests();
|
||||
|
@ -4,16 +4,16 @@
|
||||
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
#include <boost/pending/iterator_tests.hpp>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cassert>
|
||||
|
||||
struct mutable_it : boost::iterator_adaptor<mutable_it,int*>
|
||||
{
|
||||
typedef boost::iterator_adaptor<mutable_it,int*> super_t;
|
||||
|
||||
|
||||
mutable_it();
|
||||
explicit mutable_it(int* p) : super_t(p) {}
|
||||
|
||||
|
||||
bool equal(mutable_it const& rhs) const
|
||||
{
|
||||
return this->base() == rhs.base();
|
||||
@ -23,7 +23,7 @@ struct mutable_it : boost::iterator_adaptor<mutable_it,int*>
|
||||
struct constant_it : boost::iterator_adaptor<constant_it,int const*>
|
||||
{
|
||||
typedef boost::iterator_adaptor<constant_it,int const*> super_t;
|
||||
|
||||
|
||||
constant_it();
|
||||
explicit constant_it(int* p) : super_t(p) {}
|
||||
constant_it(mutable_it const& x) : super_t(x.base()) {}
|
||||
@ -37,7 +37,7 @@ struct constant_it : boost::iterator_adaptor<constant_it,int const*>
|
||||
int main()
|
||||
{
|
||||
int data[] = { 49, 77 };
|
||||
|
||||
|
||||
mutable_it i(data);
|
||||
constant_it j(data + 1);
|
||||
BOOST_TEST(i < j);
|
||||
@ -46,7 +46,7 @@ int main()
|
||||
BOOST_TEST(j >= i);
|
||||
BOOST_TEST(j - i == 1);
|
||||
BOOST_TEST(i - j == -1);
|
||||
|
||||
|
||||
constant_it k = i;
|
||||
|
||||
BOOST_TEST(!(i < k));
|
||||
@ -55,6 +55,6 @@ int main()
|
||||
BOOST_TEST(k >= i);
|
||||
BOOST_TEST(k - i == 0);
|
||||
BOOST_TEST(i - k == 0);
|
||||
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
@ -5,10 +5,10 @@
|
||||
#include <deque>
|
||||
#include <iterator>
|
||||
#include <iostream>
|
||||
#include <cstddef> // std::ptrdiff_t
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/iterator/is_lvalue_iterator.hpp>
|
||||
#include <boost/iterator.hpp>
|
||||
|
||||
// Last, for BOOST_NO_LVALUE_RETURN_DETECTION
|
||||
#include <boost/iterator/detail/config_def.hpp>
|
||||
@ -20,36 +20,43 @@ struct v
|
||||
};
|
||||
|
||||
|
||||
struct value_iterator : boost::iterator<std::input_iterator_tag,v>
|
||||
struct value_iterator
|
||||
{
|
||||
typedef std::input_iterator_tag iterator_category;
|
||||
typedef v value_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef v* pointer;
|
||||
typedef v& reference;
|
||||
|
||||
v operator*() const;
|
||||
};
|
||||
|
||||
struct noncopyable_iterator : boost::iterator<std::forward_iterator_tag,boost::noncopyable>
|
||||
struct noncopyable_iterator
|
||||
{
|
||||
typedef std::forward_iterator_tag iterator_category;
|
||||
typedef boost::noncopyable value_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef boost::noncopyable* pointer;
|
||||
typedef boost::noncopyable& reference;
|
||||
|
||||
boost::noncopyable const& operator*() const;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct proxy_iterator
|
||||
: boost::iterator<std::output_iterator_tag,T>
|
||||
{
|
||||
typedef T value_type;
|
||||
|
||||
#if BOOST_WORKAROUND(__GNUC__, == 2)
|
||||
typedef boost::iterator<std::input_iterator_tag,value_type> base;
|
||||
typedef base::iterator_category iterator_category;
|
||||
typedef base::difference_type difference_type;
|
||||
typedef base::pointer pointer;
|
||||
typedef base::reference reference;
|
||||
#endif
|
||||
|
||||
typedef std::output_iterator_tag iterator_category;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef T* pointer;
|
||||
typedef T& reference;
|
||||
|
||||
struct proxy
|
||||
{
|
||||
operator value_type&() const;
|
||||
proxy& operator=(value_type) const;
|
||||
};
|
||||
|
||||
|
||||
proxy operator*() const;
|
||||
};
|
||||
|
||||
@ -104,14 +111,14 @@ int main()
|
||||
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<char*> >::value);
|
||||
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<float> >::value);
|
||||
|
||||
|
||||
|
||||
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<v> >::value);
|
||||
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<int> >::value);
|
||||
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<char*> >::value);
|
||||
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<float> >::value);
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<v*>::value);
|
||||
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<v const*>::value);
|
||||
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<std::deque<v>::iterator>::value);
|
||||
@ -124,18 +131,18 @@ int main()
|
||||
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<value_iterator>::value);
|
||||
#endif
|
||||
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<noncopyable_iterator>::value);
|
||||
|
||||
|
||||
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<v> >::value);
|
||||
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
|
||||
#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
|
||||
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<int> >::value);
|
||||
#endif
|
||||
#endif
|
||||
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<char*> >::value);
|
||||
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<float> >::value);
|
||||
|
||||
|
||||
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<v> >::value);
|
||||
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<int> >::value);
|
||||
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<char*> >::value);
|
||||
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<float> >::value);
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -5,10 +5,10 @@
|
||||
#include <deque>
|
||||
#include <iterator>
|
||||
#include <iostream>
|
||||
#include <cstddef> // std::ptrdiff_t
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/iterator/is_readable_iterator.hpp>
|
||||
#include <boost/iterator.hpp>
|
||||
|
||||
// Last, for BOOST_NO_LVALUE_RETURN_DETECTION
|
||||
#include <boost/iterator/detail/config_def.hpp>
|
||||
@ -20,52 +20,58 @@ struct v
|
||||
};
|
||||
|
||||
|
||||
struct value_iterator : boost::iterator<std::input_iterator_tag,v>
|
||||
struct value_iterator
|
||||
{
|
||||
typedef std::input_iterator_tag iterator_category;
|
||||
typedef v value_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef v* pointer;
|
||||
typedef v& reference;
|
||||
|
||||
v operator*() const;
|
||||
};
|
||||
|
||||
struct noncopyable_iterator : boost::iterator<std::forward_iterator_tag,boost::noncopyable>
|
||||
struct noncopyable_iterator
|
||||
{
|
||||
typedef std::forward_iterator_tag iterator_category;
|
||||
typedef boost::noncopyable value_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef boost::noncopyable* pointer;
|
||||
typedef boost::noncopyable& reference;
|
||||
|
||||
boost::noncopyable const& operator*() const;
|
||||
};
|
||||
|
||||
struct proxy_iterator : boost::iterator<std::output_iterator_tag,v>
|
||||
struct proxy_iterator
|
||||
{
|
||||
#if BOOST_WORKAROUND(__GNUC__, == 2)
|
||||
typedef boost::iterator<std::input_iterator_tag,v> base;
|
||||
typedef base::iterator_category iterator_category;
|
||||
typedef base::value_type value_type;
|
||||
typedef base::difference_type difference_type;
|
||||
typedef base::pointer pointer;
|
||||
typedef base::reference reference;
|
||||
#endif
|
||||
|
||||
typedef std::output_iterator_tag iterator_category;
|
||||
typedef v value_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef v* pointer;
|
||||
typedef v& reference;
|
||||
|
||||
struct proxy
|
||||
{
|
||||
operator v&();
|
||||
proxy& operator=(v) const;
|
||||
};
|
||||
|
||||
|
||||
proxy operator*() const;
|
||||
};
|
||||
|
||||
struct proxy_iterator2 : boost::iterator<std::output_iterator_tag,v>
|
||||
struct proxy_iterator2
|
||||
{
|
||||
#if BOOST_WORKAROUND(__GNUC__, == 2)
|
||||
typedef boost::iterator<std::input_iterator_tag,v> base;
|
||||
typedef base::iterator_category iterator_category;
|
||||
typedef base::value_type value_type;
|
||||
typedef base::difference_type difference_type;
|
||||
typedef base::pointer pointer;
|
||||
typedef base::reference reference;
|
||||
#endif
|
||||
|
||||
typedef std::output_iterator_tag iterator_category;
|
||||
typedef v value_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef v* pointer;
|
||||
typedef v& reference;
|
||||
|
||||
struct proxy
|
||||
{
|
||||
proxy& operator=(v) const;
|
||||
};
|
||||
|
||||
|
||||
proxy operator*() const;
|
||||
};
|
||||
|
||||
@ -81,10 +87,10 @@ int main()
|
||||
BOOST_STATIC_ASSERT(boost::is_readable_iterator<proxy_iterator>::value);
|
||||
BOOST_STATIC_ASSERT(!boost::is_readable_iterator<proxy_iterator2>::value);
|
||||
BOOST_STATIC_ASSERT(boost::is_readable_iterator<value_iterator>::value);
|
||||
|
||||
|
||||
// Make sure inaccessible copy constructor doesn't prevent
|
||||
// readability
|
||||
BOOST_STATIC_ASSERT(boost::is_readable_iterator<noncopyable_iterator>::value);
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -27,7 +27,7 @@ int main()
|
||||
#if defined(__SGI_STL_PORT) \
|
||||
|| !BOOST_WORKAROUND(__GNUC__, <= 2) \
|
||||
&& !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 1)) \
|
||||
&& !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) \
|
||||
&& !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551)) \
|
||||
&& !BOOST_WORKAROUND(__LIBCOMO_VERSION__, BOOST_TESTED_AT(29)) \
|
||||
&& !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 1)
|
||||
{
|
||||
@ -41,6 +41,6 @@ int main()
|
||||
boost::function_requires< boost_concepts::InteroperableIteratorConcept<rev_iter, c_rev_iter> >();
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
return boost::exit_success;
|
||||
}
|
||||
|
@ -16,10 +16,10 @@
|
||||
#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
|
||||
# include <boost/iterator/is_readable_iterator.hpp>
|
||||
# include <boost/iterator/is_lvalue_iterator.hpp>
|
||||
#endif
|
||||
#endif
|
||||
#include <boost/pending/iterator_tests.hpp>
|
||||
|
||||
# include <boost/detail/lightweight_test.hpp>
|
||||
# include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <vector>
|
||||
@ -56,9 +56,9 @@ struct ptr_iterator
|
||||
, V*
|
||||
, V
|
||||
, boost::random_access_traversal_tag
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
|
||||
#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
|
||||
, V&
|
||||
#endif
|
||||
#endif
|
||||
>
|
||||
{
|
||||
private:
|
||||
@ -67,11 +67,11 @@ private:
|
||||
, V*
|
||||
, V
|
||||
, boost::random_access_traversal_tag
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
|
||||
#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
|
||||
, V&
|
||||
#endif
|
||||
#endif
|
||||
> super_t;
|
||||
|
||||
|
||||
public:
|
||||
ptr_iterator() { }
|
||||
ptr_iterator(V* d) : super_t(d) { }
|
||||
@ -95,7 +95,7 @@ struct modify_traversal
|
||||
, Traversal
|
||||
>
|
||||
{};
|
||||
|
||||
|
||||
template <class T>
|
||||
struct fwd_iterator
|
||||
: boost::iterator_adaptor<
|
||||
@ -108,7 +108,7 @@ private:
|
||||
fwd_iterator<T>
|
||||
, boost::forward_iterator_archetype<T>
|
||||
> super_t;
|
||||
|
||||
|
||||
public:
|
||||
fwd_iterator() { }
|
||||
fwd_iterator(boost::forward_iterator_archetype<T> d) : super_t(d) { }
|
||||
@ -126,7 +126,7 @@ private:
|
||||
in_iterator<T>
|
||||
, boost::input_iterator_archetype_no_proxy<T>
|
||||
> super_t;
|
||||
|
||||
|
||||
public:
|
||||
in_iterator() { }
|
||||
in_iterator(boost::input_iterator_archetype_no_proxy<T> d) : super_t(d) { }
|
||||
@ -145,7 +145,7 @@ struct constant_iterator
|
||||
, Iter
|
||||
, typename std::iterator_traits<Iter>::value_type const
|
||||
> base_t;
|
||||
|
||||
|
||||
constant_iterator() {}
|
||||
constant_iterator(Iter it)
|
||||
: base_t(it) {}
|
||||
@ -181,7 +181,7 @@ int static_assert_traversal(Iter* = 0, Trav* = 0)
|
||||
int
|
||||
main()
|
||||
{
|
||||
dummyT array[] = { dummyT(0), dummyT(1), dummyT(2),
|
||||
dummyT array[] = { dummyT(0), dummyT(1), dummyT(2),
|
||||
dummyT(3), dummyT(4), dummyT(5) };
|
||||
const int N = sizeof(array)/sizeof(dummyT);
|
||||
|
||||
@ -192,7 +192,7 @@ main()
|
||||
{
|
||||
ptr_iterator<dummyT> i(array);
|
||||
boost::random_access_iterator_test(i, N, array);
|
||||
|
||||
|
||||
ptr_iterator<const dummyT> j(array);
|
||||
boost::random_access_iterator_test(j, N, array);
|
||||
boost::const_nonconst_iterator_test(i, ++j);
|
||||
@ -210,25 +210,25 @@ main()
|
||||
test = static_assert_same<Iter1::difference_type, std::ptrdiff_t>::value;
|
||||
#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
|
||||
BOOST_STATIC_ASSERT((boost::is_convertible<Iter1::iterator_category, std::random_access_iterator_tag>::value));
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
{
|
||||
|
||||
{
|
||||
// Test computation of default when the Value is const
|
||||
typedef ptr_iterator<int const> Iter1;
|
||||
test = static_assert_same<Iter1::value_type, int>::value;
|
||||
test = static_assert_same<Iter1::reference, const int&>::value;
|
||||
|
||||
|
||||
#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
|
||||
BOOST_STATIC_ASSERT(boost::is_readable_iterator<Iter1>::value);
|
||||
# ifndef BOOST_NO_LVALUE_RETURN_DETECTION
|
||||
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<Iter1>::value);
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) // borland drops constness
|
||||
#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) // borland drops constness
|
||||
test = static_assert_same<Iter1::pointer, int const*>::value;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
{
|
||||
@ -238,26 +238,26 @@ main()
|
||||
|
||||
test = static_assert_same<Iter::value_type, int>::value;
|
||||
test = static_assert_same<Iter::reference, int const&>::value;
|
||||
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) // borland drops constness
|
||||
#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) // borland drops constness
|
||||
test = static_assert_same<Iter::pointer, int const*>::value;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_LVALUE_RETURN_DETECTION
|
||||
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<BaseIter>::value);
|
||||
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<Iter>::value);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
typedef modify_traversal<BaseIter, boost::incrementable_traversal_tag> IncrementableIter;
|
||||
|
||||
static_assert_traversal<BaseIter,boost::random_access_traversal_tag>();
|
||||
static_assert_traversal<IncrementableIter,boost::incrementable_traversal_tag>();
|
||||
}
|
||||
|
||||
|
||||
// Test the iterator_adaptor
|
||||
{
|
||||
ptr_iterator<dummyT> i(array);
|
||||
boost::random_access_iterator_test(i, N, array);
|
||||
|
||||
|
||||
ptr_iterator<const dummyT> j(array);
|
||||
boost::random_access_iterator_test(j, N, array);
|
||||
boost::const_nonconst_iterator_test(i, ++j);
|
||||
@ -272,9 +272,9 @@ main()
|
||||
adaptor_type i(forward_iter);
|
||||
int zero = 0;
|
||||
if (zero) // don't do this, just make sure it compiles
|
||||
BOOST_TEST((*i).m_x == i->foo());
|
||||
BOOST_TEST((*i).m_x == i->foo());
|
||||
}
|
||||
|
||||
|
||||
// check operator-> with an input iterator
|
||||
{
|
||||
boost::input_iterator_archetype_no_proxy<dummyT> input_iter;
|
||||
@ -282,7 +282,7 @@ main()
|
||||
adaptor_type i(input_iter);
|
||||
int zero = 0;
|
||||
if (zero) // don't do this, just make sure it compiles
|
||||
BOOST_TEST((*i).m_x == i->foo());
|
||||
BOOST_TEST((*i).m_x == i->foo());
|
||||
}
|
||||
|
||||
// check that base_type is correct
|
||||
|
@ -21,7 +21,7 @@ int main()
|
||||
|
||||
boost::function_requires< boost_concepts::ReadableIteratorConcept<iter> >();
|
||||
boost::function_requires< boost_concepts::RandomAccessTraversalConcept<iter> >();
|
||||
}
|
||||
}
|
||||
{
|
||||
typedef boost::iterator_archetype<
|
||||
int
|
||||
@ -32,7 +32,7 @@ int main()
|
||||
boost::function_requires< boost_concepts::ReadableIteratorConcept<iter> >();
|
||||
boost::function_requires< boost_concepts::WritableIteratorConcept<iter> >();
|
||||
boost::function_requires< boost_concepts::RandomAccessTraversalConcept<iter> >();
|
||||
}
|
||||
}
|
||||
{
|
||||
typedef boost::iterator_archetype<
|
||||
const int // I don't like adding const to Value. It is redundant. -JGS
|
||||
@ -43,7 +43,7 @@ int main()
|
||||
boost::function_requires< boost_concepts::ReadableIteratorConcept<iter> >();
|
||||
boost::function_requires< boost_concepts::LvalueIteratorConcept<iter> >();
|
||||
boost::function_requires< boost_concepts::RandomAccessTraversalConcept<iter> >();
|
||||
}
|
||||
}
|
||||
{
|
||||
typedef boost::iterator_archetype<
|
||||
int
|
||||
@ -54,7 +54,7 @@ int main()
|
||||
boost::function_requires< boost_concepts::WritableIteratorConcept<iter> >();
|
||||
boost::function_requires< boost_concepts::LvalueIteratorConcept<iter> >();
|
||||
boost::function_requires< boost_concepts::RandomAccessTraversalConcept<iter> >();
|
||||
}
|
||||
}
|
||||
|
||||
return boost::exit_success;
|
||||
}
|
||||
|
@ -86,7 +86,7 @@ struct input_iter
|
||||
return value();
|
||||
}
|
||||
|
||||
bool equal(input_iter const& y) const
|
||||
bool equal(input_iter const&) const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -20,14 +20,14 @@
|
||||
// reference type from operator* (David Abrahams)
|
||||
// 19 Jan 2001 Initial version with iterator operators (David Abrahams)
|
||||
|
||||
#include <boost/detail/iterator.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/operators.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <iterator>
|
||||
#include <vector>
|
||||
#include <list>
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <iostream>
|
||||
|
||||
// A UDT for which we can specialize std::iterator_traits<element*> on
|
||||
@ -40,7 +40,7 @@ struct my_iterator1
|
||||
: boost::forward_iterator_helper<my_iterator1, char, long, const char*, const char&>
|
||||
{
|
||||
my_iterator1(const char* p) : m_p(p) {}
|
||||
|
||||
|
||||
bool operator==(const my_iterator1& rhs) const
|
||||
{ return this->m_p == rhs.m_p; }
|
||||
|
||||
@ -63,9 +63,9 @@ struct my_iterator2
|
||||
typedef const char* pointer;
|
||||
typedef const char& reference;
|
||||
typedef std::forward_iterator_tag iterator_category;
|
||||
|
||||
|
||||
my_iterator2(const char* p) : m_p(p) {}
|
||||
|
||||
|
||||
bool operator==(const my_iterator2& rhs) const
|
||||
{ return this->m_p == rhs.m_p; }
|
||||
|
||||
@ -77,7 +77,7 @@ struct my_iterator2
|
||||
|
||||
// Used to prove that we're not overly confused by the existence of
|
||||
// std::iterator<> in the hierarchy under MSVC6 - we should find that
|
||||
// boost::detail::iterator_traits<my_iterator3>::difference_type is int.
|
||||
// std::iterator_traits<my_iterator3>::difference_type is int.
|
||||
struct my_iterator3 : my_iterator1
|
||||
{
|
||||
typedef int difference_type;
|
||||
@ -108,8 +108,8 @@ template <class Iterator,
|
||||
class value_type, class difference_type, class pointer, class reference, class category>
|
||||
struct non_portable_tests
|
||||
{
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::pointer test_pt;
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::reference test_rt;
|
||||
typedef typename std::iterator_traits<Iterator>::pointer test_pt;
|
||||
typedef typename std::iterator_traits<Iterator>::reference test_rt;
|
||||
typedef typename assert_same<test_pt, pointer>::type a1;
|
||||
typedef typename assert_same<test_rt, reference>::type a2;
|
||||
};
|
||||
@ -118,8 +118,8 @@ template <class Iterator,
|
||||
class value_type, class difference_type, class pointer, class reference, class category>
|
||||
struct portable_tests
|
||||
{
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::difference_type test_dt;
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::iterator_category test_cat;
|
||||
typedef typename std::iterator_traits<Iterator>::difference_type test_dt;
|
||||
typedef typename std::iterator_traits<Iterator>::iterator_category test_cat;
|
||||
typedef typename assert_same<test_dt, difference_type>::type a1;
|
||||
typedef typename assert_same<test_cat, category>::type a2;
|
||||
};
|
||||
@ -130,7 +130,7 @@ template <class Iterator,
|
||||
struct input_iterator_test
|
||||
: portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
|
||||
{
|
||||
typedef typename boost::detail::iterator_traits<Iterator>::value_type test_vt;
|
||||
typedef typename std::iterator_traits<Iterator>::value_type test_vt;
|
||||
typedef typename assert_same<test_vt, value_type>::type a1;
|
||||
};
|
||||
|
||||
@ -153,7 +153,16 @@ struct maybe_pointer_test
|
||||
input_iterator_test<std::istream_iterator<int>, int, std::ptrdiff_t, int*, int&, std::input_iterator_tag>
|
||||
istream_iterator_test;
|
||||
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, <= 0x564) && !defined(__SGI_STL_PORT)
|
||||
// C++20 changed ostream_iterator::difference_type to ptrdiff_t.
|
||||
// Note: gcc 10.1 defines __cplusplus to a value less than 202002L, but greater than 201703L in C++20 mode.
|
||||
#if __cplusplus > 201703L && (\
|
||||
(defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION >= 100100) \
|
||||
) || \
|
||||
defined(_MSVC_LANG) && _MSVC_LANG > 201703L && _MSVC_STL_UPDATE >= 202010L
|
||||
#define BOOST_ITERATOR_CXX20_OSTREAM_ITERATOR
|
||||
#endif
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_BORLANDC, <= 0x564) && !defined(__SGI_STL_PORT)
|
||||
typedef ::std::char_traits<char>::off_type distance;
|
||||
non_pointer_test<std::ostream_iterator<int>,int,
|
||||
distance,int*,int&,std::output_iterator_tag> ostream_iterator_test;
|
||||
@ -165,6 +174,10 @@ non_pointer_test<std::ostream_iterator<int>,
|
||||
non_pointer_test<std::ostream_iterator<int>,
|
||||
int, long, int*, int&, std::output_iterator_tag>
|
||||
ostream_iterator_test;
|
||||
#elif defined(BOOST_ITERATOR_CXX20_OSTREAM_ITERATOR)
|
||||
non_pointer_test<std::ostream_iterator<int>,
|
||||
void, std::ptrdiff_t, void, void, std::output_iterator_tag>
|
||||
ostream_iterator_test;
|
||||
#else
|
||||
non_pointer_test<std::ostream_iterator<int>,
|
||||
void, void, void, void, std::output_iterator_tag>
|
||||
@ -189,7 +202,7 @@ maybe_pointer_test<int*, int, std::ptrdiff_t, int*, int&, std::random_access_ite
|
||||
|
||||
non_pointer_test<my_iterator1, char, long, const char*, const char&, std::forward_iterator_tag>
|
||||
my_iterator1_test;
|
||||
|
||||
|
||||
non_pointer_test<my_iterator2, char, long, const char*, const char&, std::forward_iterator_tag>
|
||||
my_iterator2_test;
|
||||
|
||||
@ -204,15 +217,15 @@ int main()
|
||||
for (int length = 3; length < 100; length += length / 3)
|
||||
{
|
||||
std::list<int> l(length);
|
||||
BOOST_TEST(boost::detail::distance(l.begin(), l.end()) == length);
|
||||
|
||||
std::vector<int> v(length);
|
||||
BOOST_TEST(boost::detail::distance(v.begin(), v.end()) == length);
|
||||
BOOST_TEST(std::distance(l.begin(), l.end()) == length);
|
||||
|
||||
BOOST_TEST(boost::detail::distance(&ints[0], ints + length) == length);
|
||||
BOOST_TEST(boost::detail::distance(my_iterator1(chars), my_iterator1(chars + length)) == length);
|
||||
BOOST_TEST(boost::detail::distance(my_iterator2(chars), my_iterator2(chars + length)) == length);
|
||||
BOOST_TEST(boost::detail::distance(my_iterator3(chars), my_iterator3(chars + length)) == length);
|
||||
std::vector<int> v(length);
|
||||
BOOST_TEST(std::distance(v.begin(), v.end()) == length);
|
||||
|
||||
BOOST_TEST(std::distance(&ints[0], ints + length) == length);
|
||||
BOOST_TEST(std::distance(my_iterator1(chars), my_iterator1(chars + length)) == length);
|
||||
BOOST_TEST(std::distance(my_iterator2(chars), my_iterator2(chars + length)) == length);
|
||||
BOOST_TEST(std::distance(my_iterator3(chars), my_iterator3(chars + length)) == length);
|
||||
}
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
112
test/next_prior_test.cpp
Normal file
112
test/next_prior_test.cpp
Normal file
@ -0,0 +1,112 @@
|
||||
// Boost test program for next() and prior() utilities.
|
||||
|
||||
// Copyright 2003 Daniel Walker. Use, modification, and distribution
|
||||
// are subject to the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or a copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt.)
|
||||
|
||||
// See http://www.boost.org/libs/utility for documentation.
|
||||
|
||||
// Revision History 13 Dec 2003 Initial Version (Daniel Walker)
|
||||
|
||||
// next() and prior() are replacements for operator+ and operator- for
|
||||
// non-random-access iterators. The semantics of these operators are
|
||||
// such that after executing j = i + n, std::distance(i, j) equals
|
||||
// n. Tests are provided to ensure next() has the same
|
||||
// result. Parallel tests are provided for prior(). The tests call
|
||||
// next() and prior() several times. next() and prior() are very
|
||||
// simple functions, though, and it would be very strange if these
|
||||
// tests were to fail.
|
||||
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
#include <list>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/next_prior.hpp>
|
||||
|
||||
template<class RandomAccessIterator, class ForwardIterator>
|
||||
bool plus_one_test(RandomAccessIterator first, RandomAccessIterator last, ForwardIterator first2)
|
||||
{
|
||||
RandomAccessIterator i = first;
|
||||
ForwardIterator j = first2;
|
||||
while(i != last)
|
||||
i = i + 1, j = boost::next(j);
|
||||
return std::distance(first, i) == std::distance(first2, j);
|
||||
}
|
||||
|
||||
template<class RandomAccessIterator, class ForwardIterator>
|
||||
bool plus_n_test(RandomAccessIterator first, RandomAccessIterator last, ForwardIterator first2)
|
||||
{
|
||||
RandomAccessIterator i = first;
|
||||
ForwardIterator j = first2;
|
||||
for(int n = 0; i != last; ++n)
|
||||
i = first + n, j = boost::next(first2, n);
|
||||
return std::distance(first, i) == std::distance(first2, j);
|
||||
}
|
||||
|
||||
template<class RandomAccessIterator, class BidirectionalIterator>
|
||||
bool minus_one_test(RandomAccessIterator first, RandomAccessIterator last, BidirectionalIterator last2)
|
||||
{
|
||||
RandomAccessIterator i = last;
|
||||
BidirectionalIterator j = last2;
|
||||
while(i != first)
|
||||
i = i - 1, j = boost::prior(j);
|
||||
return std::distance(i, last) == std::distance(j, last2);
|
||||
}
|
||||
|
||||
template<class RandomAccessIterator, class BidirectionalIterator>
|
||||
bool minus_n_test(RandomAccessIterator first, RandomAccessIterator last, BidirectionalIterator last2)
|
||||
{
|
||||
RandomAccessIterator i = last;
|
||||
BidirectionalIterator j = last2;
|
||||
for(int n = 0; i != first; ++n)
|
||||
i = last - n, j = boost::prior(last2, n);
|
||||
return std::distance(i, last) == std::distance(j, last2);
|
||||
}
|
||||
|
||||
template<class Iterator, class Distance>
|
||||
bool minus_n_unsigned_test(Iterator first, Iterator last, Distance size)
|
||||
{
|
||||
Iterator i = boost::prior(last, size);
|
||||
return i == first;
|
||||
}
|
||||
|
||||
int main(int, char*[])
|
||||
{
|
||||
std::vector<int> x(8);
|
||||
std::list<int> y(x.begin(), x.end());
|
||||
|
||||
// Tests with iterators
|
||||
BOOST_TEST(plus_one_test(x.begin(), x.end(), y.begin()));
|
||||
BOOST_TEST(plus_n_test(x.begin(), x.end(), y.begin()));
|
||||
BOOST_TEST(minus_one_test(x.begin(), x.end(), y.end()));
|
||||
BOOST_TEST(minus_n_test(x.begin(), x.end(), y.end()));
|
||||
BOOST_TEST(minus_n_unsigned_test(x.begin(), x.end(), x.size()));
|
||||
BOOST_TEST(minus_n_unsigned_test(y.begin(), y.end(), y.size()));
|
||||
|
||||
BOOST_TEST(plus_one_test(x.rbegin(), x.rend(), y.begin()));
|
||||
BOOST_TEST(plus_n_test(x.rbegin(), x.rend(), y.begin()));
|
||||
BOOST_TEST(minus_one_test(x.rbegin(), x.rend(), y.end()));
|
||||
BOOST_TEST(minus_n_test(x.rbegin(), x.rend(), y.end()));
|
||||
BOOST_TEST(minus_n_unsigned_test(x.rbegin(), x.rend(), x.size()));
|
||||
BOOST_TEST(minus_n_unsigned_test(x.rbegin(), x.rend(), y.size()));
|
||||
|
||||
// Test with pointers
|
||||
std::vector<int> z(x.size());
|
||||
int* p = &z[0];
|
||||
BOOST_TEST(plus_one_test(x.begin(), x.end(), p));
|
||||
BOOST_TEST(plus_n_test(x.begin(), x.end(), p));
|
||||
BOOST_TEST(minus_one_test(x.begin(), x.end(), p + z.size()));
|
||||
BOOST_TEST(minus_n_test(x.begin(), x.end(), p + z.size()));
|
||||
BOOST_TEST(minus_n_unsigned_test(p, p + z.size(), z.size()));
|
||||
|
||||
// Tests with integers
|
||||
BOOST_TEST(boost::next(5) == 6);
|
||||
BOOST_TEST(boost::next(5, 7) == 12);
|
||||
BOOST_TEST(boost::prior(5) == 4);
|
||||
BOOST_TEST(boost::prior(5, 7) == -2);
|
||||
BOOST_TEST(boost::prior(5, 7u) == -2);
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
@ -27,7 +27,7 @@ void iterop_test()
|
||||
{
|
||||
typedef boost::permutation_iterator< double*, int const* > permutation_type;
|
||||
typedef boost::permutation_iterator< double const*, int const* > permutation_const_type;
|
||||
|
||||
|
||||
BOOST_CONCEPT_ASSERT((
|
||||
boost_concepts::InteroperableIteratorConcept<
|
||||
permutation_type
|
||||
@ -58,7 +58,7 @@ void permutation_test()
|
||||
permutation_type begin = boost::make_permutation_iterator( elements.begin(), indices.begin() );
|
||||
permutation_type it = begin;
|
||||
permutation_type end = boost::make_permutation_iterator( elements.begin(), indices.end() );
|
||||
|
||||
|
||||
BOOST_CHECK( it == begin );
|
||||
BOOST_CHECK( it != end );
|
||||
|
||||
@ -70,7 +70,7 @@ void permutation_test()
|
||||
}
|
||||
|
||||
it = begin;
|
||||
for( int i1 = 0; i1 < index_size - 1 ; ++++i1, ++++it )
|
||||
for( int i1 = 0; i1 < index_size - 1 ; ++++i1, ++++it )
|
||||
{
|
||||
index_type::iterator i_it2 = indices.begin();
|
||||
std::advance( i_it2, i1 );
|
||||
@ -79,14 +79,14 @@ void permutation_test()
|
||||
|
||||
it = begin;
|
||||
std::advance(it, index_size);
|
||||
for( index_type::iterator i_it3 = indices.end(); it != begin; )
|
||||
for( index_type::iterator i_it3 = indices.end(); it != begin; )
|
||||
{
|
||||
BOOST_CHECK( *--it == elements[ *--i_it3 ] );
|
||||
}
|
||||
|
||||
|
||||
it = begin;
|
||||
std::advance(it, index_size);
|
||||
for( int i2 = 0; i2 < index_size - 1; i2+=2, --it )
|
||||
for( int i2 = 0; i2 < index_size - 1; i2+=2, --it )
|
||||
{
|
||||
index_type::iterator i_it4 = --indices.end();
|
||||
std::advance( i_it4, -i2 );
|
||||
|
@ -35,7 +35,7 @@ struct X {
|
||||
template <class T> operator T&() const;
|
||||
};
|
||||
|
||||
|
||||
|
||||
int main()
|
||||
{
|
||||
STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<int> >::type, int);
|
||||
@ -43,16 +43,16 @@ int main()
|
||||
|
||||
STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<int const> >::type, int const);
|
||||
STATIC_ASSERT_SAME(boost::pointee<proxy_ref_ptr<X const> >::type, X const);
|
||||
|
||||
|
||||
STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<int> >::type, int const);
|
||||
STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<X> >::type, X const);
|
||||
|
||||
|
||||
STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<int const> >::type, int const);
|
||||
STATIC_ASSERT_SAME(boost::pointee<proxy_value_ptr<X const> >::type, X const);
|
||||
|
||||
STATIC_ASSERT_SAME(boost::pointee<int*>::type, int);
|
||||
STATIC_ASSERT_SAME(boost::pointee<int const*>::type, int const);
|
||||
|
||||
|
||||
STATIC_ASSERT_SAME(boost::pointee<X*>::type, X);
|
||||
STATIC_ASSERT_SAME(boost::pointee<X const*>::type, X const);
|
||||
|
||||
@ -60,7 +60,7 @@ int main()
|
||||
|
||||
STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<int> >::type, int);
|
||||
STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<X> >::type, X);
|
||||
|
||||
|
||||
STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<int const> >::type, int const);
|
||||
STATIC_ASSERT_SAME(boost::pointee<std::auto_ptr<X const> >::type, X const);
|
||||
|
||||
@ -68,7 +68,7 @@ int main()
|
||||
|
||||
STATIC_ASSERT_SAME(boost::pointee<std::unique_ptr<int> >::type, int);
|
||||
STATIC_ASSERT_SAME(boost::pointee<std::unique_ptr<X> >::type, X);
|
||||
|
||||
|
||||
STATIC_ASSERT_SAME(boost::pointee<std::unique_ptr<int const> >::type, int const);
|
||||
STATIC_ASSERT_SAME(boost::pointee<std::unique_ptr<X const> >::type, X const);
|
||||
|
||||
@ -76,7 +76,7 @@ int main()
|
||||
|
||||
STATIC_ASSERT_SAME(boost::pointee<std::list<int>::iterator >::type, int);
|
||||
STATIC_ASSERT_SAME(boost::pointee<std::list<X>::iterator >::type, X);
|
||||
|
||||
|
||||
STATIC_ASSERT_SAME(boost::pointee<std::list<int>::const_iterator >::type, int const);
|
||||
STATIC_ASSERT_SAME(boost::pointee<std::list<X>::const_iterator >::type, X const);
|
||||
return 0;
|
||||
|
22
test/range_distance_compat_test.cpp
Normal file
22
test/range_distance_compat_test.cpp
Normal file
@ -0,0 +1,22 @@
|
||||
// Copyright (C) 2018 Andrey Semashev
|
||||
//
|
||||
// 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/range/distance.hpp>
|
||||
#include <boost/range/iterator_range_core.hpp>
|
||||
#include <boost/iterator/distance.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
// Test that boost::distance from Boost.Range works with boost::distance from Boost.Iterator
|
||||
// (https://github.com/boostorg/iterator/commit/b844c8df530c474ec1856870b9b0de5f487b84d4#commitcomment-30603668)
|
||||
|
||||
typedef boost::iterator_range<const char*> range_type;
|
||||
range_type range;
|
||||
|
||||
(void)boost::distance(range);
|
||||
|
||||
return 0;
|
||||
}
|
@ -20,7 +20,7 @@ using boost::dummyT;
|
||||
// Test reverse iterator
|
||||
int main()
|
||||
{
|
||||
dummyT array[] = { dummyT(0), dummyT(1), dummyT(2),
|
||||
dummyT array[] = { dummyT(0), dummyT(1), dummyT(2),
|
||||
dummyT(3), dummyT(4), dummyT(5) };
|
||||
const int N = sizeof(array)/sizeof(dummyT);
|
||||
|
||||
@ -104,29 +104,29 @@ int main()
|
||||
boost::function_requires< boost_concepts::BidirectionalTraversalConcept<Iter> >();
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
// Test reverse_iterator
|
||||
{
|
||||
dummyT reversed[N];
|
||||
std::copy(array, array + N, reversed);
|
||||
std::reverse(reversed, reversed + N);
|
||||
|
||||
|
||||
typedef boost::reverse_iterator<dummyT*> reverse_iterator;
|
||||
|
||||
|
||||
reverse_iterator i(reversed + N);
|
||||
boost::random_access_iterator_test(i, N, array);
|
||||
|
||||
boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
|
||||
|
||||
typedef boost::reverse_iterator<const dummyT*> const_reverse_iterator;
|
||||
|
||||
|
||||
const_reverse_iterator j(reversed + N);
|
||||
boost::random_access_iterator_test(j, N, array);
|
||||
|
||||
const dummyT* const_reversed = reversed;
|
||||
|
||||
|
||||
boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
|
||||
|
||||
|
||||
boost::const_nonconst_iterator_test(i, ++j);
|
||||
}
|
||||
|
||||
@ -146,7 +146,7 @@ int main()
|
||||
// (e.g. "reversed + N") is used in the constructor below.
|
||||
const std::deque<dummyT>::iterator finish = reversed_container.end();
|
||||
reverse_iterator i(finish);
|
||||
|
||||
|
||||
boost::random_access_iterator_test(i, N, array);
|
||||
boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
|
||||
|
||||
@ -155,18 +155,18 @@ int main()
|
||||
|
||||
const std::deque<dummyT>::const_iterator const_reversed = reversed;
|
||||
boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
|
||||
|
||||
|
||||
// Many compilers' builtin deque iterators don't interoperate well, though
|
||||
// STLport fixes that problem.
|
||||
#if defined(__SGI_STL_PORT) \
|
||||
|| !BOOST_WORKAROUND(__GNUC__, <= 2) \
|
||||
&& !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 1)) \
|
||||
&& !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) \
|
||||
&& !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551)) \
|
||||
&& !BOOST_WORKAROUND(__LIBCOMO_VERSION__, BOOST_TESTED_AT(29)) \
|
||||
&& !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 1)
|
||||
|
||||
|
||||
boost::const_nonconst_iterator_test(i, ++j);
|
||||
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
|
64
test/shared_iterator_test.cpp
Normal file
64
test/shared_iterator_test.cpp
Normal file
@ -0,0 +1,64 @@
|
||||
// Copyright 2003 The Trustees of Indiana University.
|
||||
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// Shared container iterator adaptor
|
||||
// Author: Ronald Garcia
|
||||
// See http://boost.org/libs/utility/shared_container_iterator.html
|
||||
// for documentation.
|
||||
|
||||
//
|
||||
// shared_iterator_test.cpp - Regression tests for shared_container_iterator.
|
||||
//
|
||||
|
||||
|
||||
#include "boost/shared_container_iterator.hpp"
|
||||
#include "boost/shared_ptr.hpp"
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <vector>
|
||||
|
||||
struct resource {
|
||||
static int count;
|
||||
resource() { ++count; }
|
||||
resource(resource const&) { ++count; }
|
||||
~resource() { --count; }
|
||||
};
|
||||
int resource::count = 0;
|
||||
|
||||
typedef std::vector<resource> resources_t;
|
||||
|
||||
typedef boost::shared_container_iterator< resources_t > iterator;
|
||||
|
||||
|
||||
void set_range(iterator& i, iterator& end) {
|
||||
|
||||
boost::shared_ptr< resources_t > objs(new resources_t());
|
||||
|
||||
for (int j = 0; j != 6; ++j)
|
||||
objs->push_back(resource());
|
||||
|
||||
i = iterator(objs->begin(),objs);
|
||||
end = iterator(objs->end(),objs);
|
||||
BOOST_TEST_EQ(resource::count, 6);
|
||||
}
|
||||
|
||||
|
||||
int main() {
|
||||
|
||||
BOOST_TEST_EQ(resource::count, 0);
|
||||
|
||||
{
|
||||
iterator i;
|
||||
{
|
||||
iterator end;
|
||||
set_range(i,end);
|
||||
BOOST_TEST_EQ(resource::count, 6);
|
||||
}
|
||||
BOOST_TEST_EQ(resource::count, 6);
|
||||
}
|
||||
BOOST_TEST_EQ(resource::count, 0);
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
@ -19,7 +19,6 @@
|
||||
#include <boost/iterator/iterator_concepts.hpp>
|
||||
#include <boost/iterator/new_iterator_tests.hpp>
|
||||
#include <boost/pending/iterator_tests.hpp>
|
||||
#include <boost/bind.hpp>
|
||||
#include <boost/concept_check.hpp>
|
||||
|
||||
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
@ -43,7 +42,7 @@ struct mult_functor {
|
||||
int a;
|
||||
};
|
||||
|
||||
struct adaptable_mult_functor
|
||||
struct adaptable_mult_functor
|
||||
: mult_functor
|
||||
{
|
||||
typedef int result_type;
|
||||
@ -114,9 +113,9 @@ struct polymorphic_mult_functor
|
||||
template <class F, class T> struct result<F(T& )> {typedef void type;};
|
||||
template <class F, class T> struct result<F(const T&)> {typedef void type;};
|
||||
|
||||
template <class T>
|
||||
template <class T>
|
||||
T operator()(const T& _arg) const {return _arg*2;}
|
||||
template <class T>
|
||||
template <class T>
|
||||
void operator()(const T& _arg) { BOOST_ASSERT(0); }
|
||||
};
|
||||
|
||||
@ -139,15 +138,15 @@ main()
|
||||
for (int k = 0; k < N; ++k)
|
||||
x[k] = k;
|
||||
std::copy(x, x + N, y);
|
||||
|
||||
|
||||
for (int k2 = 0; k2 < N; ++k2)
|
||||
x[k2] = x[k2] * 2;
|
||||
|
||||
|
||||
typedef boost::transform_iterator<adaptable_mult_functor, int*> iter_t;
|
||||
iter_t i(y, adaptable_mult_functor(2));
|
||||
boost::input_iterator_test(i, x[0], x[1]);
|
||||
boost::input_iterator_test(iter_t(&y[0], adaptable_mult_functor(2)), x[0], x[1]);
|
||||
|
||||
|
||||
boost::random_access_readable_iterator_test(i, N, x);
|
||||
}
|
||||
|
||||
@ -157,15 +156,15 @@ main()
|
||||
for (int k = 0; k < N; ++k)
|
||||
x[k] = k;
|
||||
std::copy(x, x + N, y);
|
||||
|
||||
|
||||
for (int k2 = 0; k2 < N; ++k2)
|
||||
x[k2] = x[k2] * 2;
|
||||
|
||||
|
||||
typedef boost::transform_iterator<mult_functor, int*, int> iter_t;
|
||||
iter_t i(y, mult_functor(2));
|
||||
boost::input_iterator_test(i, x[0], x[1]);
|
||||
boost::input_iterator_test(iter_t(&y[0], mult_functor(2)), x[0], x[1]);
|
||||
|
||||
|
||||
boost::random_access_readable_iterator_test(i, N, x);
|
||||
}
|
||||
|
||||
@ -196,16 +195,16 @@ main()
|
||||
for (int k = 0; k < N; ++k)
|
||||
x[k] = k;
|
||||
std::copy(x, x + N, y);
|
||||
|
||||
|
||||
for (int k2 = 0; k2 < N; ++k2)
|
||||
x[k2] = x[k2] * 2;
|
||||
|
||||
|
||||
boost::input_iterator_test(
|
||||
boost::make_transform_iterator(y, mult_2), x[0], x[1]);
|
||||
|
||||
boost::input_iterator_test(
|
||||
boost::make_transform_iterator(&y[0], mult_2), x[0], x[1]);
|
||||
|
||||
|
||||
boost::random_access_readable_iterator_test(
|
||||
boost::make_transform_iterator(y, mult_2), N, x);
|
||||
|
||||
@ -250,7 +249,7 @@ main()
|
||||
);
|
||||
|
||||
boost::constant_lvalue_iterator_test(
|
||||
boost::make_transform_iterator((pair_t*)values, const_select_first()), x[0]);
|
||||
boost::make_transform_iterator((pair_t*)values, const_select_first()), x[0]);
|
||||
|
||||
boost::non_const_lvalue_iterator_test(
|
||||
boost::make_transform_iterator((pair_t*)values, select_first()), x[0], 17);
|
||||
@ -267,16 +266,16 @@ main()
|
||||
for (int k = 0; k < N; ++k)
|
||||
x[k] = k;
|
||||
std::copy(x, x + N, y);
|
||||
|
||||
|
||||
for (int k2 = 0; k2 < N; ++k2)
|
||||
x[k2] = x[k2] * 2;
|
||||
|
||||
|
||||
boost::input_iterator_test(
|
||||
boost::make_transform_iterator(y, polymorphic_mult_functor()), x[0], x[1]);
|
||||
|
||||
boost::input_iterator_test(
|
||||
boost::make_transform_iterator(&y[0], polymorphic_mult_functor()), x[0], x[1]);
|
||||
|
||||
|
||||
boost::random_access_readable_iterator_test(
|
||||
boost::make_transform_iterator(y, polymorphic_mult_functor()), N, x);
|
||||
}
|
||||
|
@ -6,6 +6,22 @@
|
||||
//
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1600)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Skipping test on msvc-9.0 and below")
|
||||
int main() {}
|
||||
|
||||
#elif defined(BOOST_GCC) && __cplusplus < 201100
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Skipping test on g++ in C++03 mode")
|
||||
int main() {}
|
||||
|
||||
#else
|
||||
|
||||
#include <utility>
|
||||
#include <boost/fusion/adapted/std_pair.hpp>
|
||||
|
||||
@ -14,3 +30,4 @@
|
||||
|
||||
#include "detail/zip_iterator_test.ipp"
|
||||
|
||||
#endif
|
||||
|
Reference in New Issue
Block a user