mirror of
https://github.com/boostorg/tuple.git
synced 2025-07-04 08:16:38 +02:00
Compare commits
2 Commits
boost-1.80
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
| 0afd261a71 | |||
| 28ce70832f |
287
.github/workflows/ci.yml
vendored
287
.github/workflows/ci.yml
vendored
@ -1,287 +0,0 @@
|
||||
name: GitHub Actions CI
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
push:
|
||||
branches:
|
||||
- master
|
||||
- develop
|
||||
- githubactions*
|
||||
- feature/**
|
||||
- fix/**
|
||||
- pr/**
|
||||
|
||||
jobs:
|
||||
posix:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- name: "TOOLSET=gcc COMPILER=g++ CXXSTD=03,11 Job 0"
|
||||
buildtype: "boost"
|
||||
packages: ""
|
||||
packages_to_remove: ""
|
||||
os: "ubuntu-20.04"
|
||||
container: "ubuntu:16.04"
|
||||
cxx: "g++"
|
||||
sources: ""
|
||||
llvm_os: ""
|
||||
llvm_ver: ""
|
||||
toolset: "gcc"
|
||||
compiler: "g++"
|
||||
cxxstd: "03,11"
|
||||
- name: "TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z Job 1"
|
||||
buildtype: "boost"
|
||||
packages: "g++-5"
|
||||
packages_to_remove: ""
|
||||
os: "ubuntu-20.04"
|
||||
container: "ubuntu:16.04"
|
||||
cxx: "g++-5"
|
||||
sources: ""
|
||||
llvm_os: ""
|
||||
llvm_ver: ""
|
||||
toolset: "gcc"
|
||||
compiler: "g++-5"
|
||||
cxxstd: "03,11,14,1z"
|
||||
- name: "TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z Job 2"
|
||||
buildtype: "boost"
|
||||
packages: "g++-6"
|
||||
packages_to_remove: ""
|
||||
os: "ubuntu-20.04"
|
||||
container: "ubuntu:16.04"
|
||||
cxx: "g++-6"
|
||||
sources: ""
|
||||
llvm_os: ""
|
||||
llvm_ver: ""
|
||||
toolset: "gcc"
|
||||
compiler: "g++-6"
|
||||
cxxstd: "03,11,14,1z"
|
||||
- name: "TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17 Job 3"
|
||||
buildtype: "boost"
|
||||
packages: "g++-7"
|
||||
packages_to_remove: ""
|
||||
os: "ubuntu-20.04"
|
||||
container: "ubuntu:16.04"
|
||||
cxx: "g++-7"
|
||||
sources: ""
|
||||
llvm_os: ""
|
||||
llvm_ver: ""
|
||||
toolset: "gcc"
|
||||
compiler: "g++-7"
|
||||
cxxstd: "03,11,14,17"
|
||||
- name: "TOOLSET=clang COMPILER=clang++ CXXSTD=03,11 Job 4"
|
||||
buildtype: "boost"
|
||||
packages: ""
|
||||
packages_to_remove: ""
|
||||
os: "ubuntu-18.04"
|
||||
cxx: "clang++"
|
||||
sources: ""
|
||||
llvm_os: ""
|
||||
llvm_ver: ""
|
||||
toolset: "clang"
|
||||
compiler: "clang++"
|
||||
cxxstd: "03,11"
|
||||
- name: "TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03, Job 5"
|
||||
buildtype: "boost"
|
||||
packages: "clang-4.0"
|
||||
packages_to_remove: ""
|
||||
os: "ubuntu-20.04"
|
||||
container: "ubuntu:16.04"
|
||||
cxx: "clang++-4.0"
|
||||
sources: ""
|
||||
llvm_os: "xenial"
|
||||
llvm_ver: "4.0"
|
||||
toolset: "clang"
|
||||
compiler: "clang++-4.0"
|
||||
cxxstd: "03,11,14"
|
||||
- name: "TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03, Job 6"
|
||||
buildtype: "boost"
|
||||
packages: "clang-5.0"
|
||||
packages_to_remove: ""
|
||||
os: "ubuntu-20.04"
|
||||
container: "ubuntu:16.04"
|
||||
cxx: "clang++-5.0"
|
||||
sources: ""
|
||||
llvm_os: "xenial"
|
||||
llvm_ver: "5.0"
|
||||
toolset: "clang"
|
||||
compiler: "clang++-5.0"
|
||||
cxxstd: "03,11,14,1z"
|
||||
|
||||
runs-on: ${{ matrix.os }}
|
||||
container: ${{ matrix.container }}
|
||||
|
||||
steps:
|
||||
- name: Check if running in container
|
||||
if: matrix.container != ''
|
||||
run: echo "GHA_CONTAINER=${{ matrix.container }}" >> $GITHUB_ENV
|
||||
- name: If running in container, upgrade packages
|
||||
if: matrix.container != ''
|
||||
run: |
|
||||
apt-get -o Acquire::Retries=3 update && DEBIAN_FRONTEND=noninteractive apt-get -y install tzdata && apt-get -o Acquire::Retries=3 install -y sudo software-properties-common wget curl apt-transport-https make apt-file sudo unzip libssl-dev build-essential autotools-dev autoconf automake g++ libc++-helpers python ruby cpio gcc-multilib g++-multilib pkgconf python3 ccache libpython-dev
|
||||
sudo apt-add-repository ppa:git-core/ppa
|
||||
sudo apt-get -o Acquire::Retries=3 update && apt-get -o Acquire::Retries=3 -y install git
|
||||
python_version=$(python3 -c 'import sys; print("{0.major}.{0.minor}".format(sys.version_info))')
|
||||
sudo wget https://bootstrap.pypa.io/pip/$python_version/get-pip.py
|
||||
sudo python3 get-pip.py
|
||||
sudo /usr/local/bin/pip install cmake
|
||||
|
||||
- uses: actions/checkout@v2
|
||||
|
||||
- name: linux
|
||||
shell: bash
|
||||
env:
|
||||
CXX: ${{ matrix.cxx }}
|
||||
SOURCES: ${{ matrix.sources }}
|
||||
LLVM_OS: ${{ matrix.llvm_os }}
|
||||
LLVM_VER: ${{ matrix.llvm_ver }}
|
||||
PACKAGES: ${{ matrix.packages }}
|
||||
PACKAGES_TO_REMOVE: ${{ matrix.packages_to_remove }}
|
||||
JOB_BUILDTYPE: ${{ matrix.buildtype }}
|
||||
TOOLSET: ${{ matrix.toolset }}
|
||||
COMPILER: ${{ matrix.compiler }}
|
||||
CXXSTD: ${{ matrix.cxxstd }}
|
||||
TRAVIS_BRANCH: ${{ github.base_ref }}
|
||||
TRAVIS_OS_NAME: "linux"
|
||||
run: |
|
||||
echo '==================================> SETUP'
|
||||
echo '==================================> PACKAGES'
|
||||
set -e
|
||||
if [ -n "$PACKAGES_TO_REMOVE" ]; then sudo apt-get purge -y $PACKAGES_TO_REMOVE; fi
|
||||
echo ">>>>> APT: REPO.."
|
||||
for i in {1..3}; do sudo -E apt-add-repository -y "ppa:ubuntu-toolchain-r/test" && break || sleep 2; done
|
||||
|
||||
if test -n "${LLVM_OS}" ; then
|
||||
wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
|
||||
if test -n "${LLVM_VER}" ; then
|
||||
sudo -E apt-add-repository "deb http://apt.llvm.org/${LLVM_OS}/ llvm-toolchain-${LLVM_OS}-${LLVM_VER} main"
|
||||
else
|
||||
# Snapshot (i.e. trunk) build of clang
|
||||
sudo -E apt-add-repository "deb http://apt.llvm.org/${LLVM_OS}/ llvm-toolchain-${LLVM_OS} main"
|
||||
fi
|
||||
fi
|
||||
echo ">>>>> APT: UPDATE.."
|
||||
sudo -E apt-get -o Acquire::Retries=3 update
|
||||
if test -n "${SOURCES}" ; then
|
||||
echo ">>>>> APT: INSTALL SOURCES.."
|
||||
for SOURCE in $SOURCES; do
|
||||
sudo -E apt-add-repository ppa:$SOURCE
|
||||
done
|
||||
fi
|
||||
echo ">>>>> APT: INSTALL ${PACKAGES}.."
|
||||
sudo -E DEBIAN_FRONTEND=noninteractive apt-get -o Acquire::Retries=3 -y --no-install-suggests --no-install-recommends install ${PACKAGES}
|
||||
|
||||
echo '==================================> INSTALL AND COMPILE'
|
||||
set -e
|
||||
export TRAVIS_BUILD_DIR=$(pwd)
|
||||
export TRAVIS_BRANCH=${TRAVIS_BRANCH:-$(echo $GITHUB_REF | awk 'BEGIN { FS = "/" } ; { print $3 }')}
|
||||
export VCS_COMMIT_ID=$GITHUB_SHA
|
||||
export GIT_COMMIT=$GITHUB_SHA
|
||||
export REPO_NAME=$(basename $GITHUB_REPOSITORY)
|
||||
export USER=$(whoami)
|
||||
export CC=${CC:-gcc}
|
||||
export PATH=~/.local/bin:/usr/local/bin:$PATH
|
||||
|
||||
if [ "$JOB_BUILDTYPE" == "boost" ]; then
|
||||
|
||||
echo '==================================> INSTALL'
|
||||
|
||||
BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
|
||||
cd ..
|
||||
git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
git submodule update --init tools/build
|
||||
git submodule update --init libs/config
|
||||
git submodule update --init tools/boostdep
|
||||
cp -r $TRAVIS_BUILD_DIR/* libs/tuple
|
||||
python tools/boostdep/depinst/depinst.py tuple
|
||||
./bootstrap.sh
|
||||
./b2 headers
|
||||
|
||||
echo '==================================> SCRIPT'
|
||||
|
||||
echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
|
||||
./b2 -j 3 libs/tuple/test toolset=$TOOLSET cxxstd=$CXXSTD
|
||||
|
||||
fi
|
||||
osx:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- name: "TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,1 Job 7"
|
||||
buildtype: "boost"
|
||||
packages: ""
|
||||
os: "macos-10.15"
|
||||
cxx: "clang++"
|
||||
sources: ""
|
||||
llvm_os: ""
|
||||
llvm_ver: ""
|
||||
xcode_version: 11.7
|
||||
toolset: "clang"
|
||||
compiler: "clang++"
|
||||
cxxstd: "03,11,14,1z"
|
||||
|
||||
runs-on: ${{ matrix.os }}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
|
||||
- name: Set DEVELOPER_DIR
|
||||
if: matrix.xcode_version != ''
|
||||
run: echo "DEVELOPER_DIR=/Applications/Xcode_${{ matrix.xcode_version }}.app/Contents/Developer" >> $GITHUB_ENV
|
||||
- name: Test DEVELOPER_DIR
|
||||
run: echo $DEVELOPER_DIR
|
||||
|
||||
- name: "osx"
|
||||
shell: bash
|
||||
env:
|
||||
CXX: ${{ matrix.cxx }}
|
||||
SOURCES: ${{ matrix.sources }}
|
||||
LLVM_OS: ${{ matrix.llvm_os }}
|
||||
LLVM_VER: ${{ matrix.llvm_ver }}
|
||||
PACKAGES: ${{ matrix.packages }}
|
||||
JOB_BUILDTYPE: ${{ matrix.buildtype }}
|
||||
TOOLSET: ${{ matrix.toolset }}
|
||||
COMPILER: ${{ matrix.compiler }}
|
||||
CXXSTD: ${{ matrix.cxxstd }}
|
||||
TRAVIS_BRANCH: ${{ github.base_ref }}
|
||||
TRAVIS_OS_NAME: "osx"
|
||||
run: |
|
||||
echo '==================================> SETUP'
|
||||
set -e
|
||||
sudo mv /Library/Developer/CommandLineTools /Library/Developer/CommandLineTools.bck
|
||||
echo '==================================> PACKAGES'
|
||||
echo '==================================> INSTALL AND COMPILE'
|
||||
set -e
|
||||
export TRAVIS_BUILD_DIR=$(pwd)
|
||||
export TRAVIS_BRANCH=${TRAVIS_BRANCH:-$(echo $GITHUB_REF | awk 'BEGIN { FS = "/" } ; { print $3 }')}
|
||||
export VCS_COMMIT_ID=$GITHUB_SHA
|
||||
export GIT_COMMIT=$GITHUB_SHA
|
||||
export REPO_NAME=$(basename $GITHUB_REPOSITORY)
|
||||
export USER=$(whoami)
|
||||
export CC=${CC:-gcc}
|
||||
export PATH=~/.local/bin:/usr/local/bin:$PATH
|
||||
|
||||
if [ "$JOB_BUILDTYPE" == "boost" ]; then
|
||||
|
||||
echo '==================================> INSTALL'
|
||||
|
||||
BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
|
||||
cd ..
|
||||
git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
git submodule update --init tools/build
|
||||
git submodule update --init libs/config
|
||||
git submodule update --init tools/boostdep
|
||||
cp -r $TRAVIS_BUILD_DIR/* libs/tuple
|
||||
python tools/boostdep/depinst/depinst.py tuple
|
||||
./bootstrap.sh
|
||||
./b2 headers
|
||||
|
||||
echo '==================================> SCRIPT'
|
||||
|
||||
echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
|
||||
./b2 -j 3 libs/tuple/test toolset=$TOOLSET cxxstd=$CXXSTD
|
||||
|
||||
fi
|
||||
111
.travis.yml
111
.travis.yml
@ -1,111 +0,0 @@
|
||||
# Copyright 2016, 2017 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
|
||||
language: cpp
|
||||
|
||||
sudo: false
|
||||
|
||||
python: "2.7"
|
||||
|
||||
branches:
|
||||
only:
|
||||
- master
|
||||
- develop
|
||||
- /feature\/.*/
|
||||
|
||||
env:
|
||||
matrix:
|
||||
- BOGUS_JOB=true
|
||||
|
||||
matrix:
|
||||
|
||||
exclude:
|
||||
- env: BOGUS_JOB=true
|
||||
|
||||
include:
|
||||
- os: linux
|
||||
compiler: g++
|
||||
env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
|
||||
|
||||
- os: linux
|
||||
compiler: g++-5
|
||||
env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-5
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-6
|
||||
env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-7
|
||||
env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: clang++
|
||||
env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-4.0
|
||||
env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-4.0
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-trusty-4.0
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-5.0
|
||||
env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-5.0
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-trusty-5.0
|
||||
|
||||
- os: osx
|
||||
compiler: clang++
|
||||
env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
|
||||
|
||||
install:
|
||||
- BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
|
||||
- cd ..
|
||||
- git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
|
||||
- cd boost-root
|
||||
- git submodule update --init tools/build
|
||||
- git submodule update --init libs/config
|
||||
- git submodule update --init tools/boostdep
|
||||
- cp -r $TRAVIS_BUILD_DIR/* libs/tuple
|
||||
- python tools/boostdep/depinst/depinst.py tuple
|
||||
- ./bootstrap.sh
|
||||
- ./b2 headers
|
||||
|
||||
script:
|
||||
- |-
|
||||
echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
|
||||
- ./b2 -j 3 libs/tuple/test toolset=$TOOLSET cxxstd=$CXXSTD
|
||||
|
||||
notifications:
|
||||
email:
|
||||
on_success: always
|
||||
@ -1,19 +0,0 @@
|
||||
# Copyright 2018 Mike Dev
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
cmake_minimum_required(VERSION 3.5...3.20)
|
||||
project(boost_tuple VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
|
||||
|
||||
add_library(boost_tuple INTERFACE)
|
||||
add_library(Boost::tuple ALIAS boost_tuple)
|
||||
|
||||
target_include_directories(boost_tuple INTERFACE include)
|
||||
|
||||
target_link_libraries(boost_tuple
|
||||
INTERFACE
|
||||
Boost::config
|
||||
Boost::core
|
||||
Boost::static_assert
|
||||
Boost::type_traits
|
||||
)
|
||||
@ -1,37 +0,0 @@
|
||||
# Copyright (c) 2001 Jaakko J<>rvi
|
||||
|
||||
# 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)
|
||||
|
||||
project doc/tuple ;
|
||||
|
||||
import boostbook ;
|
||||
import quickbook ;
|
||||
|
||||
xml tuple : tuple_users_guide.qbk ;
|
||||
|
||||
boostbook standalone_tuple
|
||||
:
|
||||
tuple
|
||||
:
|
||||
<xsl:param>boost.root=../../../..
|
||||
# File name of HTML output:
|
||||
<xsl:param>root.filename=tuple_users_guide
|
||||
# How far down we chunk nested sections, basically all of them:
|
||||
<xsl:param>chunk.section.depth=0
|
||||
# Don't put the first section on the same page as the TOC:
|
||||
<xsl:param>chunk.first.sections=0
|
||||
# How far down sections get TOC's
|
||||
<xsl:param>toc.section.depth=1
|
||||
# Max depth in each TOC:
|
||||
<xsl:param>toc.max.depth=1
|
||||
# How far down we go with TOC's
|
||||
<xsl:param>generate.section.toc.level=0
|
||||
;
|
||||
|
||||
###############################################################################
|
||||
alias boostdoc ;
|
||||
explicit boostdoc ;
|
||||
alias boostrelease : standalone_tuple ;
|
||||
explicit boostrelease ;
|
||||
153
doc/design_decisions_rationale.html
Normal file
153
doc/design_decisions_rationale.html
Normal file
@ -0,0 +1,153 @@
|
||||
<html>
|
||||
|
||||
<title>Design decisions rationale for Boost Tuple Library</title>
|
||||
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
|
||||
<IMG SRC="../../../boost.png"
|
||||
ALT="C++ Boost" width="277" height="86">
|
||||
|
||||
<h1>Tuple Library : design decisions rationale</h1>
|
||||
|
||||
<h2>About namespaces</h2>
|
||||
|
||||
<p>
|
||||
There was a discussion about whether tuples should be in a separate namespace or directly in the <code>boost</code> namespace.
|
||||
The common principle is that domain libraries (like <i>graph</i>, <i>python</i>) should be on a separate
|
||||
subnamespace, while utility like libraries directly in the <code>boost</code> namespace.
|
||||
Tuples are somewhere in between, as the tuple template is clearly a general utility, but the library introduces quite a lot of names in addition to just the tuple template.
|
||||
Tuples were originally under a subnamespace.
|
||||
As a result of the discussion, tuple definitions were moved directly under the <code>boost</code> namespace.
|
||||
As a result of a continued discussion, the subnamespace was reintroduced.
|
||||
The final (I truly hope so) solution is now to have all definitions in namespace <code>::boost::tuples</code>, and the most common names in the <code>::boost</code> namespace as well.
|
||||
This is accomplished with using declarations (suggested by Dave Abrahams):
|
||||
<code><pre>namespace boost {
|
||||
namespace tuples {
|
||||
...
|
||||
// All library code
|
||||
...
|
||||
}
|
||||
using tuples::tuple;
|
||||
using tuples::make_tuple;
|
||||
using tuples::tie;
|
||||
using tuples::get;
|
||||
}
|
||||
</pre></code>
|
||||
With this arrangement, tuple creation with direct constructor calls, <code>make_tuple</code> or <code>tie</code> functions do not need the namespace qualifier.
|
||||
Further, all functions that manipulate tuples are found with Koenig-lookup.
|
||||
The only exceptions are the <code>get<N></code> functions, which are always called with an explicitly qualified template argument, and thus Koenig-lookup does not apply.
|
||||
Therefore, get is lifted to <code>::boost</code> namespace with a using declaration.
|
||||
Hence, the interface for an application programmer is in practice under the namespace <code>::boost</code>.
|
||||
</p>
|
||||
<p>
|
||||
The other names, forming an interface for library writers (cons lists, metafunctions manipulating cons lists, ...) remain in the subnamespace <code>::boost::tuples</code>.
|
||||
Note, that the names <code>ignore</code>, <code>set_open</code>, <code>set_close</code> and <code>set_delimiter</code> are considered to be part of the application programmer's interface, but are still not under <code>boost</code> namespace.
|
||||
The reason being the danger for name clashes for these common names.
|
||||
Further, the usage of these features is probably not very frequent.
|
||||
</p>
|
||||
|
||||
<h4>For those who are really interested in namespaces</h4>
|
||||
|
||||
<p>
|
||||
The subnamespace name <i>tuples</i> raised some discussion.
|
||||
The rationale for not using the most natural name 'tuple' is to avoid having an identical name with the tuple template.
|
||||
Namespace names are, however, not generally in plural form in boost libraries.
|
||||
First, no real trouble was reported for using the same name for a namespace and a class and we considered changing the name 'tuples' to 'tuple'.
|
||||
But we found some trouble after all.
|
||||
Both gcc and edg compilers reject using declarations where the namespace and class names are identical:
|
||||
|
||||
<code><pre>namespace boost {
|
||||
namespace tuple {
|
||||
... tie(...);
|
||||
class tuple;
|
||||
...
|
||||
}
|
||||
using tuple::tie; // ok
|
||||
using tuple::tuple; // error
|
||||
...
|
||||
}
|
||||
</pre></code>
|
||||
|
||||
Note, however, that a corresponding using declaration in the global namespace seems to be ok:
|
||||
|
||||
<code><pre>
|
||||
using boost::tuple::tuple; // ok;
|
||||
</pre></code>
|
||||
|
||||
|
||||
<h2>The end mark of the cons list (nil, null_type, ...)</h2>
|
||||
|
||||
<p>
|
||||
Tuples are internally represented as <code>cons</code> lists:
|
||||
|
||||
<code><pre>tuple<int, int>
|
||||
</pre></code>
|
||||
inherits from
|
||||
<code><pre>cons<int, cons<int, null_type> >
|
||||
</code></pre>
|
||||
|
||||
<code>null_type</code> is the end mark of the list. Original proposition was <code>nil</code>, but the name is used in MacOS, and might have caused problems, so <code>null_type</code> was chosen instead.
|
||||
Other names considered were <i>null_t</i> and <i>unit</i> (the empty tuple type in SML).
|
||||
<p>
|
||||
Note that <code>null_type</code> is the internal representation of an empty tuple: <code>tuple<></code> inherits from <code>null_type</code>.
|
||||
</p>
|
||||
|
||||
<h2>Element indexing</h2>
|
||||
|
||||
<p>
|
||||
Whether to use 0- or 1-based indexing was discussed more than thoroughly, and the following observations were made:
|
||||
|
||||
<ul>
|
||||
<li> 0-based indexing is 'the C++ way' and used with arrays etc.</li>
|
||||
<li> 1-based 'name like' indexing exists as well, eg. <code>bind1st</code>, <code>bind2nd</code>, <code>pair::first</code>, etc.</li>
|
||||
</ul>
|
||||
Tuple access with the syntax <code>get<N>(a)</code>, or <code>a.get<N>()</code> (where <code>a</code> is a tuple and <code>N</code> an index), was considered to be of the first category, hence, the index of the first element in a tuple is 0.
|
||||
|
||||
<p>
|
||||
A suggestion to provide 1-based 'name like' indexing with constants like <code>_1st</code>, <code>_2nd</code>, <code>_3rd</code>, ... was made.
|
||||
By suitably chosen constant types, this would allow alternative syntaxes:
|
||||
|
||||
<code><pre>a.get<0>() == a.get(_1st) == a[_1st] == a(_1st);
|
||||
</pre></code>
|
||||
|
||||
We chose not to provide more than one indexing method for the following reasons:
|
||||
<ul>
|
||||
<li>0-based indexing might not please everyone, but once its fixed, it is less confusing than having two different methods (would anyone want such constants for arrays?).</li>
|
||||
<li>Adding the other indexing scheme doesn't really provide anything new (like a new feature) to the user of the library.</li>
|
||||
<li>C++ variable and constant naming rules don't give many possibilities for defining short and nice index constants (like <code>_1st</code>, ...).
|
||||
Let the binding and lambda libraries use these for a better purpose.</li>
|
||||
<li>The access syntax <code>a[_1st]</code> (or <code>a(_1st)</code>) is appealing, and almost made us add the index constants after all. However, 0-based subscripting is so deep in C++, that we had a fear for confusion.</li>
|
||||
<li>
|
||||
Such constants are easy to add.
|
||||
</li>
|
||||
</ul>
|
||||
|
||||
|
||||
<h2>Tuple comparison</h2>
|
||||
|
||||
The comparison operator implements lexicographical order.
|
||||
Other orderings were considered, mainly dominance (<i>a < b iff for each i a(i) < b(i)</i>).
|
||||
Our belief is, that lexicographical ordering, though not mathematically the most natural one, is the most frequently needed ordering in everyday programming.
|
||||
|
||||
<h2>Streaming</h2>
|
||||
|
||||
<p>
|
||||
The characters specified with tuple stream manipulators are stored within the space allocated by <code>ios_base::xalloc</code>, which allocates storage for <code>long</code> type objects.
|
||||
<code>static_cast</code> is used in casting between <code>long</code> and the stream's character type.
|
||||
Streams that have character types not convertible back and forth to long thus fail to compile.
|
||||
|
||||
This may be revisited at some point. The two possible solutions are:
|
||||
<ul>
|
||||
<li>Allow only plain <code>char</code> types as the tuple delimiters and use <code>widen</code> and <code>narrow</code> to convert between the real character type of the stream.
|
||||
This would always compile, but some calls to set manipulators might result in a different
|
||||
character than expected (some default character).</li>
|
||||
<li>Allocate enough space to hold the real character type of the stream.
|
||||
This means memory for holding the delimiter characters must be allocated separately, and that pointers to this memory are stored in the space allocated with <code>ios_base::xalloc</code>.
|
||||
Any volunteers?</li>
|
||||
</ul>
|
||||
|
||||
<A href="tuple_users_guide.html">Back to the user's guide</A>
|
||||
<hr><p>© Copyright Jaakko Järvi 2001.
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@ -1,190 +0,0 @@
|
||||
[/
|
||||
/ Copyright (c) 2001 Jaakko J<>rvi
|
||||
/
|
||||
/ 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)
|
||||
/]
|
||||
|
||||
[article Design decisions rationale
|
||||
[quickbook 1.6]
|
||||
[id design_decisions_rationale]
|
||||
[copyright 2001 Jaakko J\u00E4rvi]
|
||||
[license Distributed under the
|
||||
[@http://boost.org/LICENSE_1_0.txt Boost Software License,
|
||||
Version 1.0].
|
||||
]
|
||||
]
|
||||
|
||||
[template simplesect[title]
|
||||
[block '''<simplesect><title>'''[title]'''</title>''']]
|
||||
|
||||
[template endsimplesect[]
|
||||
[block '''</simplesect>''']]
|
||||
|
||||
[section About namespaces]
|
||||
|
||||
There was a discussion about whether tuples should be in a separate namespace
|
||||
or directly in the `boost` namespace. The common principle is that domain
|
||||
libraries (like /graph/, /python/) should be on a separate subnamespace, while
|
||||
utility like libraries directly in the boost namespace. Tuples are somewhere
|
||||
in between, as the tuple template is clearly a general utility, but the
|
||||
library introduces quite a lot of names in addition to just the tuple template.
|
||||
Tuples were originally under a subnamespace. As a result of the discussion,
|
||||
tuple definitions were moved directly under the `boost` namespace. As a result
|
||||
of a continued discussion, the subnamespace was reintroduced. The final (I
|
||||
truly hope so) solution is now to have all definitions in namespace
|
||||
`::boost::tuples`, and the most common names in the `::boost` namespace as well.
|
||||
This is accomplished with using declarations (suggested by Dave Abrahams):
|
||||
|
||||
namespace boost {
|
||||
namespace tuples {
|
||||
...
|
||||
// All library code
|
||||
...
|
||||
}
|
||||
using tuples::tuple;
|
||||
using tuples::make_tuple;
|
||||
using tuples::tie;
|
||||
using tuples::get;
|
||||
}
|
||||
|
||||
With this arrangement, tuple creation with direct constructor calls,
|
||||
`make_tuple` or `tie` functions do not need the namespace qualifier. Further,
|
||||
all functions that manipulate tuples are found with Koenig-lookup. The only
|
||||
exceptions are the `get<N>` functions, which are always called with an
|
||||
explicitly qualified template argument, and thus Koenig-lookup does not apply.
|
||||
Therefore, `get` is lifted to `::boost` namespace with a using declaration.
|
||||
Hence, the interface for an application programmer is in practice under the
|
||||
namespace `::boost`.
|
||||
|
||||
The other names, forming an interface for library writers (cons lists,
|
||||
metafunctions manipulating cons lists, ...) remain in the subnamespace
|
||||
`::boost::tuples`. Note, that the names `ignore`, `set_open`, `set_close` and
|
||||
`set_delimiter` are considered to be part of the application programmer's
|
||||
interface, but are still not under `boost` namespace. The reason being the
|
||||
danger for name clashes for these common names. Further, the usage of these
|
||||
features is probably not very frequent.
|
||||
|
||||
[section For those who are really interested in namespaces]
|
||||
|
||||
The subnamespace name /tuples/ raised some discussion. The rationale for not
|
||||
using the most natural name 'tuple' is to avoid having an identical name with
|
||||
the tuple template. Namespace names are, however, not generally in plural form
|
||||
in Boost libraries. First, no real trouble was reported for using the same
|
||||
name for a namespace and a class and we considered changing the name 'tuples'
|
||||
to 'tuple'. But we found some trouble after all. Both gcc and edg compilers
|
||||
reject using declarations where the namespace and class names are identical:
|
||||
|
||||
namespace boost {
|
||||
namespace tuple {
|
||||
... tie(...);
|
||||
class tuple;
|
||||
...
|
||||
}
|
||||
using tuple::tie; // ok
|
||||
using tuple::tuple; // error
|
||||
...
|
||||
}
|
||||
|
||||
Note, however, that a corresponding using declaration in the global namespace
|
||||
seems to be ok:
|
||||
|
||||
using boost::tuple::tuple; // ok;
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section The end mark of the cons list (`nil`, `null_type`, ...)]
|
||||
|
||||
Tuples are internally represented as cons lists:
|
||||
|
||||
tuple<int, int>
|
||||
|
||||
inherits from
|
||||
|
||||
cons<int, cons<int, null_type> >
|
||||
|
||||
`null_type` is the end mark of the list. Original proposition was `nil`, but
|
||||
the name is used in MacOS, and might have caused problems, so `null_type` was
|
||||
chosen instead. Other names considered were /null_t/ and /unit/ (the empty
|
||||
tuple type in SML).
|
||||
|
||||
Note that `null_type` is the internal representation of an empty tuple:
|
||||
`tuple<>` inherits from `null_type`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Element indexing]
|
||||
|
||||
Whether to use `0`- or `1`-based indexing was discussed more than thoroughly,
|
||||
and the following observations were made:
|
||||
|
||||
* `0`-based indexing is 'the C++ way' and used with arrays etc.
|
||||
|
||||
* `1`-based 'name like' indexing exists as well, eg. `bind1st`, `bind2nd`,
|
||||
`pair::first`, etc.
|
||||
|
||||
Tuple access with the syntax `get<N>(a)`, or `a.get<N>()` (where `a` is a
|
||||
tuple and `N` an index), was considered to be of the first category, hence,
|
||||
the index of the first element in a tuple is `0`.
|
||||
|
||||
A suggestion to provide `1`-based 'name like' indexing with constants like
|
||||
`_1st`, `_2nd`, `_3rd`, ... was made. By suitably chosen constant types, this
|
||||
would allow alternative syntaxes:
|
||||
|
||||
a.get<0>() == a.get(_1st) == a[_1st] == a(_1st);
|
||||
|
||||
We chose not to provide more than one indexing method for the following
|
||||
reasons:
|
||||
|
||||
* `0`-based indexing might not please everyone, but once its fixed, it is less
|
||||
confusing than having two different methods (would anyone want such
|
||||
constants for arrays?).
|
||||
|
||||
* Adding the other indexing scheme doesn't really provide anything new (like a
|
||||
new feature) to the user of the library.
|
||||
|
||||
* C++ variable and constant naming rules don't give many possibilities for
|
||||
defining short and nice index constants (like `_1st`, ...). Let the binding
|
||||
and lambda libraries use these for a better purpose.
|
||||
|
||||
* The access syntax a[_1st] (or a(_1st)) is appealing, and almost made us add
|
||||
the index constants after all. However, `0`-based subscripting is so deep in
|
||||
C++, that we had a fear for confusion.
|
||||
|
||||
* Such constants are easy to add.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Tuple comparison]
|
||||
|
||||
The comparison operator implements lexicographical order. Other orderings were
|
||||
considered, mainly dominance /(a < b iff for each i a(i) < b(i))/. Our belief
|
||||
is, that lexicographical ordering, though not mathematically the most natural
|
||||
one, is the most frequently needed ordering in everyday programming.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Streaming]
|
||||
|
||||
The characters specified with tuple stream manipulators are stored within the
|
||||
space allocated by `ios_base::xalloc`, which allocates storage for `long` type
|
||||
objects. `static_cast` is used in casting between `long` and the stream's
|
||||
character type. Streams that have character types not convertible back and
|
||||
forth to long thus fail to compile.
|
||||
|
||||
This may be revisited at some point. The two possible solutions are:
|
||||
|
||||
* Allow only plain `char` types as the tuple delimiters and use `widen` and
|
||||
`narrow` to convert between the real character type of the stream. This
|
||||
would always compile, but some calls to set manipulators might result in a
|
||||
different character than expected (some default character).
|
||||
|
||||
* Allocate enough space to hold the real character type of the stream. This
|
||||
means memory for holding the delimiter characters must be allocated
|
||||
separately, and that pointers to this memory are stored in the space
|
||||
allocated with `ios_base::xalloc`. Any volunteers?
|
||||
|
||||
[endsect]
|
||||
135
doc/tuple_advanced_interface.html
Normal file
135
doc/tuple_advanced_interface.html
Normal file
@ -0,0 +1,135 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
||||
<html>
|
||||
<head>
|
||||
<title>Tuple library advanced features</title>
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
|
||||
<IMG SRC="../../../boost.png"
|
||||
ALT="C++ Boost" width="277" height="86">
|
||||
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<h1>Tuple library advanced features</h1>
|
||||
|
||||
The advanced features described in this document are all under namespace <code>::boost::tuples</code>
|
||||
|
||||
<h2>Metafunctions for tuple types</h2>
|
||||
<p>
|
||||
Suppose <code>T</code> is a tuple type, and <code>N</code> is a constant integral expression.
|
||||
|
||||
<code><pre>element<N, T>::type</pre></code>
|
||||
|
||||
gives the type of the <code>N</code>th element in the tuple type <code>T</code>. If <code>T</code> is const, the resulting type is const qualified as well.
|
||||
Note that the constness of <code>T</code> does not affect reference type
|
||||
elements.
|
||||
</p>
|
||||
|
||||
<code><pre>length<T>::value</pre></code>
|
||||
|
||||
gives the length of the tuple type <code>T</code>.
|
||||
</p>
|
||||
|
||||
<h2>Cons lists</h2>
|
||||
|
||||
<p>
|
||||
Tuples are internally represented as <i>cons lists</i>.
|
||||
For example, the tuple
|
||||
|
||||
<code><pre>tuple<A, B, C, D></pre></code>
|
||||
|
||||
inherits from the type
|
||||
<code><pre>cons<A, cons<B, cons<C, cons<D, null_type> > > >
|
||||
</pre></code>
|
||||
|
||||
The tuple template provides the typedef <code>inherited</code> to access the cons list representation. E.g.:
|
||||
<code>tuple<A>::inherited</code> is the type <code>cons<A, null_type></code>.
|
||||
</p>
|
||||
|
||||
<h4>Empty tuple</h4>
|
||||
<p>
|
||||
The internal representation of the empty tuple <code>tuple<></code> is <code>null_type</code>.
|
||||
</p>
|
||||
|
||||
<h4>Head and tail</h4>
|
||||
<p>
|
||||
Both tuple template and the cons templates provide the typedefs <code>head_type</code> and <code>tail_type</code>.
|
||||
The <code>head_type</code> typedef gives the type of the first element of the tuple (or the cons list).
|
||||
The
|
||||
<code>tail_type</code> typedef gives the remaining cons list after removing the first element.
|
||||
The head element is stored in the member variable <code>head</code> and the tail list in the member variable <code>tail</code>.
|
||||
Cons lists provide the member function <code>get_head()</code> for getting a reference to the head of a cons list, and <code>get_tail()</code> for getting a reference to the tail.
|
||||
There are const and non-const versions of both functions.
|
||||
</p>
|
||||
<p>
|
||||
Note that in a one element tuple, <code>tail_type</code> equals <code>null_type</code> and the <code>get_tail()</code> function returns an object of type <code>null_type</code>.
|
||||
</p>
|
||||
<p>
|
||||
The empty tuple (<code>null_type</code>) has no head or tail, hence the <code>get_head</code> and <code>get_tail</code> functions are not provided.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Treating tuples as cons lists gives a convenient means to define generic functions to manipulate tuples. For example, the following pair of function templates assign 0 to each element of a tuple (obviously, the assignments must be valid operations for the element types):
|
||||
|
||||
<pre><code>inline void set_to_zero(const null_type&) {};
|
||||
|
||||
template <class H, class T>
|
||||
inline void set_to_zero(cons<H, T>& x) { x.get_head() = 0; set_to_zero(x.get_tail()); }
|
||||
</code></pre>
|
||||
<p>
|
||||
|
||||
<h4>Constructing cons lists</h4>
|
||||
|
||||
<p>
|
||||
A cons list can be default constructed provided that all its elements can be default constructed.
|
||||
</p>
|
||||
<p>
|
||||
A cons list can be constructed from its head and tail. The prototype of the constructor is:
|
||||
<pre><code>cons(typename access_traits<head_type>::parameter_type h,
|
||||
const tail_type& t)
|
||||
</code></pre>
|
||||
The traits template for the head parameter selects correct parameter types for different kinds of element types (for reference elements the parameter type equals the element type, for non-reference types the parameter type is a reference to const non-volatile element type).
|
||||
</p>
|
||||
<p>
|
||||
For a one-element cons list the tail argument (<code>null_type</code>) can be omitted.
|
||||
</p>
|
||||
|
||||
|
||||
<h2>Traits classes for tuple element types</h2>
|
||||
|
||||
<h4><code>access_traits</code></h4>
|
||||
<p>
|
||||
The template <code>access_traits</code> defines three type functions. Let <code>T</code> be a type of an element in a tuple:
|
||||
<ol>
|
||||
<li><code>access_traits<T>::non_const_type</code> maps <code>T</code> to the return type of the non-const access functions (nonmeber and member <code>get</code> functions, and the <code>get_head</code> function).</li>
|
||||
<li><code>access_traits<T>::const_type</code> maps <code>T</code> to the return type of the const access functions.</li>
|
||||
<li><code>access_traits<T>::parameter_type</code> maps <code>T</code> to the parameter type of the tuple constructor.</li>
|
||||
</ol>
|
||||
<h4><code>make_tuple_traits</code></h4>
|
||||
|
||||
The element types of the tuples that are created with the <code>make_tuple</code> functions are computed with the type function <code>make_tuple_traits</code>.
|
||||
The type function call <code>make_tuple_traits<T>::type</code> implements the following type mapping:
|
||||
<ul>
|
||||
<li><i>any reference type</i> -> <i>compile time error</i>
|
||||
</li>
|
||||
<li><i>any array type</i> -> <i>constant reference to the array type</i>
|
||||
</li>
|
||||
<li><code>reference_wrapper<T></code> -> <code>T&</code>
|
||||
</li>
|
||||
<li><code>T</code> -> <code>T</code>
|
||||
</li>
|
||||
</ul>
|
||||
|
||||
Objects of type <code>reference_wrapper</code> are created with the <code>ref</code> and <code>cref</code> functions (see <A href="tuple_users_guide.html#make_tuple">The <code>make_tuple</code> function</A>.)
|
||||
</p>
|
||||
|
||||
<p>Reference wrappers were originally part of the tuple library, but they are now a general utility of boost.
|
||||
The <code>reference_wrapper</code> template and the <code>ref</code> and <code>cref</code> functions are defined in a separate file <code>ref.hpp</code> in the main boost include directory; and directly in the <code>boost</code> namespace.
|
||||
</p>
|
||||
|
||||
<A href="tuple_users_guide.html">Back to the user's guide</A>
|
||||
<hr>
|
||||
|
||||
<p>© Copyright Jaakko Järvi 2001.</p>
|
||||
</body>
|
||||
</html>
|
||||
@ -1,159 +0,0 @@
|
||||
[/
|
||||
/ Copyright (c) 2001 Jaakko J<>rvi
|
||||
/
|
||||
/ 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)
|
||||
/]
|
||||
|
||||
[article Tuple library advanced features
|
||||
[quickbook 1.6]
|
||||
[id tuple_advanced_interface]
|
||||
[copyright 2001 Jaakko J\u00E4rvi]
|
||||
[license Distributed under the
|
||||
[@http://boost.org/LICENSE_1_0.txt Boost Software License,
|
||||
Version 1.0].
|
||||
]
|
||||
]
|
||||
|
||||
[template simplesect[title]
|
||||
[block '''<simplesect><title>'''[title]'''</title>''']]
|
||||
|
||||
[template endsimplesect[]
|
||||
[block '''</simplesect>''']]
|
||||
|
||||
The advanced features described in this document are all under namespace
|
||||
`::boost::tuples`
|
||||
|
||||
[section Metafunctions for tuple types]
|
||||
|
||||
Suppose `T` is a tuple type, and `N` is a constant integral expression.
|
||||
|
||||
element<N, T>::type
|
||||
|
||||
gives the type of the `N`-th element in the tuple type `T`. If `T` is `const`,
|
||||
the resulting type is `const` qualified as well. Note that the constness of `T`
|
||||
does not affect reference type elements.
|
||||
|
||||
length<T>::value
|
||||
|
||||
gives the length of the tuple type `T`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Cons lists]
|
||||
|
||||
Tuples are internally represented as /cons lists/. For example, the tuple
|
||||
|
||||
tuple<A, B, C, D>
|
||||
|
||||
inherits from the type
|
||||
|
||||
cons<A, cons<B, cons<C, cons<D, null_type> > > >
|
||||
|
||||
The tuple template provides the typedef inherited to access the cons list
|
||||
representation. E.g.: `tuple<A>::inherited` is the type `cons<A, null_type>`.
|
||||
|
||||
[section Empty tuple]
|
||||
|
||||
The internal representation of the empty tuple `tuple<>` is `null_type`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Head and tail]
|
||||
|
||||
Both tuple template and the cons templates provide the typedefs `head_type`
|
||||
and `tail_type`. The `head_type` typedef gives the type of the first element
|
||||
of the tuple (or the cons list). The `tail_type` typedef gives the remaining
|
||||
cons list after removing the first element. The head element is stored in the
|
||||
member variable `head` and the tail list in the member variable `tail`. Cons
|
||||
lists provide the member function `get_head()` for getting a reference to the
|
||||
head of a cons list, and `get_tail()` for getting a reference to the tail.
|
||||
There are const and non-const versions of both functions.
|
||||
|
||||
Note that in a one element tuple, `tail_type` equals `null_type` and the
|
||||
`get_tail()` function returns an object of type `null_type`.
|
||||
|
||||
The empty tuple (`null_type`) has no head or tail, hence the `get_head` and
|
||||
`get_tail` functions are not provided.
|
||||
|
||||
Treating tuples as cons lists gives a convenient means to define generic
|
||||
functions to manipulate tuples. For example, the following pair of function
|
||||
templates assign `0` to each element of a tuple (obviously, the assignments
|
||||
must be valid operations for the element types):
|
||||
|
||||
inline void set_to_zero(const null_type&) {};
|
||||
|
||||
template <class H, class T>
|
||||
inline void set_to_zero(cons<H, T>& x) { x.get_head() = 0; set_to_zero(x.get_tail()); }
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Constructing cons lists]
|
||||
|
||||
A cons list can be default constructed provided that all its elements can be
|
||||
default constructed.
|
||||
|
||||
A cons list can be constructed from its head and tail. The prototype of the
|
||||
constructor is:
|
||||
|
||||
cons(typename access_traits<head_type>::parameter_type h, const tail_type& t)
|
||||
|
||||
The traits template for the head parameter selects correct parameter types for
|
||||
different kinds of element types (for reference elements the parameter type
|
||||
equals the element type, for non-reference types the parameter type is a
|
||||
reference to const non-volatile element type).
|
||||
|
||||
For a one-element cons list the tail argument (`null_type`) can be omitted.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Traits classes for tuple element types]
|
||||
|
||||
[section access_traits]
|
||||
|
||||
The template `access_traits` defines three type functions. Let `T` be a type
|
||||
of an element in a tuple:
|
||||
|
||||
* `access_traits<T>::non_const_type` maps `T` to the return type of the no
|
||||
n-const access functions (nonmember and member `get` functions, and the
|
||||
`get_head` function).
|
||||
|
||||
* `access_traits<T>::const_type` maps `T` to the return type of the const
|
||||
access functions.
|
||||
|
||||
* `access_traits<T>::parameter_type` maps `T` to the parameter type of the
|
||||
tuple constructor.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section make_tuple_traits]
|
||||
|
||||
The element types of the tuples that are created with the `make_tuple`
|
||||
functions are computed with the type function `make_tuple_traits`. The type
|
||||
function call `make_tuple_traits<T>::type` implements the following type
|
||||
mapping:
|
||||
|
||||
* /any reference type/ -> /compile time error/
|
||||
|
||||
* /any array type/ -> /constant reference to the array type/
|
||||
|
||||
* `reference_wrapper<T>` -> `T&`
|
||||
|
||||
* `T` -> `T`
|
||||
|
||||
Objects of type `reference_wrapper` are created with the `ref` and `cref`
|
||||
functions (see [link tuple.constructing_tuples.make_tuple The `make_tuple`
|
||||
function]).
|
||||
|
||||
Reference wrappers were originally part of the tuple library, but they are now
|
||||
a general utility of boost. The `reference_wrapper` template and the `ref` and
|
||||
`cref` functions are defined in a separate file
|
||||
[@boost:/libs/core/doc/html/core/ref.html `ref.hpp`] in the main boost include
|
||||
directory; and directly in the `boost` namespace.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
529
doc/tuple_users_guide.html
Normal file
529
doc/tuple_users_guide.html
Normal file
@ -0,0 +1,529 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>The Boost Tuple Library</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
|
||||
<IMG SRC="../../../boost.png"
|
||||
ALT="C++ Boost" width="277" height="86">
|
||||
|
||||
<h1>The Boost Tuple Library</h1>
|
||||
|
||||
<p>
|
||||
A tuple (or <i>n</i>-tuple) is a fixed size collection of elements.
|
||||
Pairs, triples, quadruples etc. are tuples.
|
||||
In a programming language, a tuple is a data object containing other objects as elements.
|
||||
These element objects may be of different types.
|
||||
</p>
|
||||
|
||||
<p>Tuples are convenient in many circumstances.
|
||||
For instance, tuples make it easy to define functions that return more than one value.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Some programming languages, such as ML, Python and Haskell, have built-in tuple constructs.
|
||||
Unfortunately C++ does not.
|
||||
To compensate for this "deficiency", the Boost Tuple Library implements a tuple construct using templates.
|
||||
</p>
|
||||
|
||||
<h2>Table of Contents</h2>
|
||||
|
||||
<ol>
|
||||
<li><a href = "#using_library">Using the library</a></li>
|
||||
<li><a href = "#tuple_types">Tuple types</a></li>
|
||||
<li><a href = "#constructing_tuples">Constructing tuples</a></li>
|
||||
<li><a href = "#accessing_elements">Accessing tuple elements</a></li>
|
||||
<li><a href = "#construction_and_assignment">Copy construction and tuple assignment</a></li>
|
||||
<li><a href = "#relational_operators">Relational operators</a></li>
|
||||
<li><a href = "#tiers">Tiers</a></li>
|
||||
<li><a href = "#streaming">Streaming</a></li>
|
||||
<li><a href = "#performance">Performance</a></li>
|
||||
<li><a href = "#portability">Portability</a></li>
|
||||
<li><a href = "#thanks">Acknowledgements</a></li>
|
||||
<li><a href = "#references">References</a></li>
|
||||
</ol>
|
||||
|
||||
<h4>More details</h4>
|
||||
|
||||
<p>
|
||||
<a href = "tuple_advanced_interface.html">Advanced features</a> (describes some metafunctions etc.).</p>
|
||||
<p>
|
||||
<a href = "design_decisions_rationale.html">Rationale behind some design/implementation decisions.</a></p>
|
||||
|
||||
|
||||
<h2><a name="using_library">Using the library</a></h2>
|
||||
|
||||
<p>To use the library, just include:
|
||||
|
||||
<pre><code>#include "boost/tuple/tuple.hpp"</code></pre>
|
||||
|
||||
<p>Comparison operators can be included with:
|
||||
<pre><code>#include "boost/tuple/tuple_comparison.hpp"</code></pre>
|
||||
|
||||
<p>To use tuple input and output operators,
|
||||
|
||||
<pre><code>#include "boost/tuple/tuple_io.hpp"</code></pre>
|
||||
|
||||
Both <code>tuple_io.hpp</code> and <code>tuple_comparison.hpp</code> include <code>tuple.hpp</code>.
|
||||
|
||||
<p>All definitions are in namespace <code>::boost::tuples</code>, but the most common names are lifted to namespace <code>::boost</code> with using declarations. These names are: <code>tuple</code>, <code>make_tuple</code>, <code>tie</code> and <code>get</code>. Further, <code>ref</code> and <code>cref</code> are defined directly under the <code>::boost</code> namespace.
|
||||
|
||||
<h2><a name = "tuple_types">Tuple types</a></h2>
|
||||
|
||||
<p>A tuple type is an instantiation of the <code>tuple</code> template.
|
||||
The template parameters specify the types of the tuple elements.
|
||||
The current version supports tuples with 0-10 elements.
|
||||
If necessary, the upper limit can be increased up to, say, a few dozen elements.
|
||||
The data element can be any C++ type.
|
||||
Note that <code>void</code> and plain function types are valid
|
||||
C++ types, but objects of such types cannot exist.
|
||||
Hence, if a tuple type contains such types as elements, the tuple type
|
||||
can exist, but not an object of that type.
|
||||
There are natural limitations for element types that cannot
|
||||
be be copied, or that are not default constructible (see 'Constructing tuples'
|
||||
below).
|
||||
|
||||
<p>
|
||||
For example, the following definitions are valid tuple instantiations (<code>A</code>, <code>B</code> and <code>C</code> are some user defined classes):
|
||||
|
||||
<pre><code>tuple<int>
|
||||
tuple<double&, const double&, const double, double*, const double*>
|
||||
tuple<A, int(*)(char, int), B(A::*)(C&), C>
|
||||
tuple<std::string, std::pair<A, B> >
|
||||
tuple<A*, tuple<const A*, const B&, C>, bool, void*>
|
||||
</code></pre>
|
||||
|
||||
<h2><a name = "constructing_tuples">Constructing tuples</a></h2>
|
||||
|
||||
<p>
|
||||
The tuple constructor takes the tuple elements as arguments.
|
||||
For an <i>n</i>-element tuple, the constructor can be invoked with <i>k</i> arguments, where 0 <= <i>k</i> <= <i>n</i>.
|
||||
For example:
|
||||
<pre><code>tuple<int, double>()
|
||||
tuple<int, double>(1)
|
||||
tuple<int, double>(1, 3.14)
|
||||
</code></pre>
|
||||
|
||||
<p>
|
||||
If no initial value for an element is provided, it is default initialized (and hence must be default initializable).
|
||||
For example.
|
||||
|
||||
<pre><code>class X {
|
||||
X();
|
||||
public:
|
||||
X(std::string);
|
||||
};
|
||||
|
||||
tuple<X,X,X>() // error: no default constructor for X
|
||||
tuple<X,X,X>(string("Jaba"), string("Daba"), string("Duu")) // ok
|
||||
</code></pre>
|
||||
|
||||
In particular, reference types do not have a default initialization:
|
||||
|
||||
<pre><code>tuple<double&>() // error: reference must be
|
||||
// initialized explicitly
|
||||
|
||||
double d = 5;
|
||||
tuple<double&>(d) // ok
|
||||
|
||||
tuple<double&>(d+3.14) // error: cannot initialize
|
||||
// non-const reference with a temporary
|
||||
|
||||
tuple<const double&>(d+3.14) // ok, but dangerous:
|
||||
// the element becomes a dangling reference
|
||||
</code></pre>
|
||||
|
||||
<p>Using an initial value for an element that cannot be copied, is a compile
|
||||
time error:
|
||||
|
||||
<pre><code>class Y {
|
||||
Y(const Y&);
|
||||
public:
|
||||
Y();
|
||||
};
|
||||
|
||||
char a[10];
|
||||
|
||||
tuple<char[10], Y>(a, Y()); // error, neither arrays nor Y can be copied
|
||||
tuple<char[10], Y>(); // ok
|
||||
</code></pre>
|
||||
|
||||
Note particularly that the following is perfectly ok:
|
||||
<code><pre>Y y;
|
||||
tuple<char(&)[10], Y&>(a, y);
|
||||
</code></pre>
|
||||
|
||||
It is possible to come up with a tuple type that cannot be constructed.
|
||||
This occurs if an element that cannot be initialized has a lower
|
||||
index than an element that requires initialization.
|
||||
For example: <code>tuple<char[10], int&></code>.
|
||||
|
||||
<p>In sum, the tuple construction is semantically just a group of individual elementary constructions.
|
||||
</p>
|
||||
|
||||
<h4><a name="make_tuple">The <code>make_tuple</code> function</a></h4>
|
||||
|
||||
<p>
|
||||
Tuples can also be constructed using the <code>make_tuple</code> (cf. <code>std::make_pair</code>) helper functions.
|
||||
This makes the construction more convenient, saving the programmer from explicitly specifying the element types:
|
||||
<pre><code>tuple<int, int, double> add_multiply_divide(int a, int b) {
|
||||
return make_tuple(a+b, a*b, double(a)/double(b));
|
||||
}
|
||||
</code></pre>
|
||||
|
||||
<p>
|
||||
By default, the element types are deduced to the plain non-reference types. E.g:
|
||||
<pre><code>void foo(const A& a, B& b) {
|
||||
...
|
||||
make_tuple(a, b);
|
||||
</code></pre>
|
||||
The <code>make_tuple</code> invocation results in a tuple of type <code>tuple<A, B></code>.
|
||||
|
||||
<p>
|
||||
Sometimes the plain non-reference type is not desired, e.g. if the element type cannot be copied.
|
||||
Therefore, the programmer can control the type deduction and state that a reference to const or reference to
|
||||
non-const type should be used as the element type instead.
|
||||
This is accomplished with two helper template functions: <code>ref</code> and <code>cref</code>.
|
||||
Any argument can be wrapped with these functions to get the desired type.
|
||||
The mechanism does not compromise const correctness since a const object wrapped with <code>ref</code> results in a tuple element with const reference type (see the fifth code line below).
|
||||
For example:
|
||||
|
||||
<pre><code>A a; B b; const A ca = a;
|
||||
make_tuple(cref(a), b); // creates tuple<const A&, B>
|
||||
make_tuple(ref(a), b); // creates tuple<A&, B>
|
||||
make_tuple(ref(a), cref(b)); // creates tuple<A&, const B&>
|
||||
make_tuple(cref(ca)); // creates tuple<const A&>
|
||||
make_tuple(ref(ca)); // creates tuple<const A&>
|
||||
</code></pre>
|
||||
|
||||
|
||||
<p>
|
||||
Array arguments to <code>make_tuple</code> functions are deduced to reference to const types by default; there is no need to wrap them with <code>cref</code>. For example:
|
||||
<pre><code>make_tuple("Donald", "Daisy");
|
||||
</code></pre>
|
||||
|
||||
This creates an object of type <code>tuple<const char (&)[7], const char (&)[6]></code>
|
||||
(note that the type of a string literal is an array of const characters, not <code>const char*</code>).
|
||||
However, to get <code>make_tuple</code> to create a tuple with an element of a
|
||||
non-const array type one must use the <code>ref</code> wrapper.
|
||||
|
||||
<p>
|
||||
Function pointers are deduced to the plain non-reference type, that is, to plain function pointer.
|
||||
A tuple can also hold a reference to a function,
|
||||
but such a tuple cannot be constructed with <code>make_tuple</code> (a const qualified function type would result, which is illegal):
|
||||
<pre><code>void f(int i);
|
||||
...
|
||||
make_tuple(&f); // tuple<void (*)(int)>
|
||||
...
|
||||
tuple<tuple<void (&)(int)> > a(f) // ok
|
||||
make_tuple(f); // not ok
|
||||
</code></pre>
|
||||
|
||||
<h2><a name = "accessing_elements">Accessing tuple elements</a></h2>
|
||||
|
||||
<p>
|
||||
Tuple elements are accessed with the expression:
|
||||
|
||||
<pre><code>t.get<N>()
|
||||
</code></pre>
|
||||
or
|
||||
<pre><code>get<N>(t)
|
||||
</code></pre>
|
||||
where <code>t</code> is a tuple object and <code>N</code> is a constant integral expression specifying the index of the element to be accessed.
|
||||
Depending on whether <code>t</code> is const or not, <code>get</code> returns the <code>N</code>th element as a reference to const or
|
||||
non-const type.
|
||||
The index of the first element is 0 and thus<code>
|
||||
N</code> must be between 0 and <code>k-1</code>, where <code>k</code> is the number of elements in the tuple.
|
||||
Violations of these constrains are detected at compile time. Examples:
|
||||
|
||||
<pre><code>double d = 2.7; A a;
|
||||
tuple<int, double&, const A&> t(1, d, a);
|
||||
const tuple<int, double&, const A&> ct = t;
|
||||
...
|
||||
int i = get<0>(t); i = t.get<0>(); // ok
|
||||
int j = get<0>(ct); // ok
|
||||
get<0>(t) = 5; // ok
|
||||
get<0>(ct) = 5; // error, can't assign to const
|
||||
...
|
||||
double e = get<1>(t); // ok
|
||||
get<1>(t) = 3.14; // ok
|
||||
get<2>(t) = A(); // error, can't assign to const
|
||||
A aa = get<3>(t); // error: index out of bounds
|
||||
...
|
||||
++get<0>(t); // ok, can be used as any variable
|
||||
</code></pre>
|
||||
|
||||
Note! The member get functions are not supported with MS Visual C++ compiler.
|
||||
Further, the compiler has trouble with finding the non-member get functions without an explicit namespace qualifier.
|
||||
Hence, all <code>get</code> calls should be qualified as: <code>tuples::get<N>(a_tuple)</code> when writing code that shoud compile with MSVC++ 6.0.
|
||||
|
||||
<h2><a name = "construction_and_assignment">Copy construction and tuple assignment</a></h2>
|
||||
|
||||
<p>
|
||||
A tuple can be copy constructed from another tuple, provided that the element types are element-wise copy constructible.
|
||||
Analogously, a tuple can be assigned to another tuple, provided that the element types are element-wise assignable.
|
||||
For example:
|
||||
|
||||
<pre><code>class A {};
|
||||
class B : public A {};
|
||||
struct C { C(); C(const B&); };
|
||||
struct D { operator C() const; };
|
||||
tuple<char, B*, B, D> t;
|
||||
...
|
||||
tuple<int, A*, C, C> a(t); // ok
|
||||
a = t; // ok
|
||||
</code></pre>
|
||||
|
||||
In both cases, the conversions performed are: <code>char -> int</code>, <code>B* -> A*</code> (derived class pointer to base class pointer), <code>B -> C</code> (a user defined conversion) and <code>D -> C</code> (a user defined conversion).
|
||||
|
||||
<p>
|
||||
Note that assignment is also defined from <code>std::pair</code> types:
|
||||
|
||||
<pre><code>tuple<float, int> a = std::make_pair(1, 'a');
|
||||
</code></pre>
|
||||
|
||||
<h2><a name = "relational_operators">Relational operators</a></h2>
|
||||
<p>
|
||||
Tuples reduce the operators <code>==, !=, <, >, <=</code> and <code>>=</code> to the corresponding elementary operators.
|
||||
This means, that if any of these operators is defined between all elements of two tuples, then the same operator is defined between the tuples as well.
|
||||
|
||||
The equality operators for two tuples <code>a</code> and <code>b</code> are defined as:
|
||||
<ul>
|
||||
<li><code>a == b</code> iff for each <code>i</code>: <code>a<sub>i</sub> == b<sub>i</sub></code></li>
|
||||
<li><code>a != b</code> iff exists <code>i</code>: <code>a<sub>i</sub> != b<sub>i</sub></code></li>
|
||||
</ul>
|
||||
|
||||
The operators <code><, >, <=</code> and <code>>=</code> implement a lexicographical ordering.
|
||||
|
||||
<p>
|
||||
Note that an attempt to compare two tuples of different lengths results in a compile time error.</p>
|
||||
Also, the comparison operators are <i>"short-circuited"</i>: elementary comparisons start from the first elements and are performed only until the result is clear.
|
||||
|
||||
<p>Examples:
|
||||
|
||||
<pre><code>tuple<std::string, int, A> t1(std::string("same?"), 2, A());
|
||||
tuple<std::string, long, A> t2(std::string("same?"), 2, A());
|
||||
tuple<std::string, long, A> t3(std::string("different"), 3, A());
|
||||
|
||||
bool operator==(A, A) { std::cout << "All the same to me..."; return true; }
|
||||
|
||||
t1 == t2; // true
|
||||
t1 == t3; // false, does not print "All the..."
|
||||
</code></pre>
|
||||
|
||||
|
||||
<h2><a name = "tiers">Tiers</a></h2>
|
||||
|
||||
<p>
|
||||
<i>Tiers</i> are tuples, where all elements are of non-const reference types.
|
||||
They are constructed with a call to the <code>tie</code> function template (cf. <code>make_tuple</code>):
|
||||
|
||||
<pre><code>int i; char c; double d;
|
||||
...
|
||||
tie(i, c, a);
|
||||
</code></pre>
|
||||
|
||||
<p>
|
||||
The above <code>tie</code> function creates a tuple of type <code>tuple<int&, char&, double&></code>.
|
||||
The same result could be achieved with the call <code>make_tuple(ref(i), ref(c), ref(a))</code>.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
A tuple that contains non-const references as elements can be used to 'unpack' another tuple into variables. E.g.:
|
||||
|
||||
<pre><code>int i; char c; double d;
|
||||
tie(i, c, d) = make_tuple(1,'a', 5.5);
|
||||
std::cout << i << " " << c << " " << d;
|
||||
</code></pre>
|
||||
This code prints <code>1 a 5.5</code> to the standard output stream.
|
||||
|
||||
A tuple unpacking operation like this is found for example in ML and Python.
|
||||
It is convenient when calling functions which return tuples.
|
||||
|
||||
<p>
|
||||
The tying mechanism works with <code>std::pair</code> templates as well:
|
||||
|
||||
<pre><code>int i; char c;
|
||||
tie(i, c) = std::make_pair(1, 'a');
|
||||
</code></pre>
|
||||
<h4>Ignore</h4>
|
||||
There is also an object called <code>ignore</code> which allows you to ignore an element assigned by a tuple.
|
||||
The idea is that a function may return a tuple, only part of which you are interested in. For example (note, that <code>ignore</code> is under the <code>tuples</code> subnamespace):
|
||||
|
||||
<pre><code>char c;
|
||||
tie(tuples::ignore, c) = std::make_pair(1, 'a');
|
||||
</code></pre>
|
||||
|
||||
<h2><a name = "streaming">Streaming</a></h2>
|
||||
|
||||
<p>
|
||||
The global <code>operator<<</code> has been overloaded for <code>std::ostream</code> such that tuples are
|
||||
output by recursively calling <code>operator<<</code> for each element.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Analogously, the global <code>operator>></code> has been overloaded to extract tuples from <code>std::istream</code> by recursively calling <code>operator>></code> for each element.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
The default delimiter between the elements is space, and the tuple is enclosed
|
||||
in parenthesis.
|
||||
For Example:
|
||||
|
||||
<pre><code>tuple<float, int, std::string> a(1.0f, 2, std::string("Howdy folks!");
|
||||
|
||||
cout << a;
|
||||
</code></pre>
|
||||
outputs the tuple as: <code>(1.0 2 Howdy folks!)</code>
|
||||
|
||||
<p>
|
||||
The library defines three <i>manipulators</i> for changing the default behavior:
|
||||
<ul>
|
||||
<li><code>set_open(char)</code> defines the character that is output before the first
|
||||
element.</li>
|
||||
<li><code>set_close(char)</code> defines the character that is output after the
|
||||
last element.</li>
|
||||
<li><code>set_delimiter(char)</code> defines the delimiter character between
|
||||
elements.</li>
|
||||
</ul>
|
||||
|
||||
Note, that these manipulators are defined in the <code>tuples</code> subnamespace.
|
||||
For example:
|
||||
<code><pre>cout << tuples::set_open('[') << tuples::set_close(']') << tuples::set_delimiter(',') << a;
|
||||
</code></pre>
|
||||
outputs the same tuple <code>a</code> as: <code>[1.0,2,Howdy folks!]</code>
|
||||
|
||||
<p>The same manipulators work with <code>operator>></code> and <code>istream</code> as well. Suppose the <code>cin</code> stream contains the following data:
|
||||
|
||||
<pre><code>(1 2 3) [4:5]</code></pre>
|
||||
|
||||
The code:
|
||||
|
||||
<code><pre>tuple<int, int, int> i;
|
||||
tuple<int, int> j;
|
||||
|
||||
cin >> i;
|
||||
cin >> tuples::set_open('[') >> tuples::set_close(']') >> tules::set_delimiter(':');
|
||||
cin >> j;
|
||||
</code></pre>
|
||||
|
||||
reads the data into the tuples <code>i</code> and <code>j</code>.
|
||||
|
||||
<p>
|
||||
Note that extracting tuples with <code>std::string</code> or C-style string
|
||||
elements does not generally work, since the streamed tuple representation may not be unambiguously
|
||||
parseable.
|
||||
</p>
|
||||
|
||||
<h2><a name = "performance">Performance</a></h2>
|
||||
|
||||
All tuple access and construction functions are small inlined one-liners.
|
||||
Therefore, a decent compiler can eliminate any extra cost of using tuples compared to using hand written tuple like classes.
|
||||
Particularly, with a decent compiler there is no performance difference between this code:
|
||||
|
||||
<pre><code>class hand_made_tuple {
|
||||
A a; B b; C c;
|
||||
public:
|
||||
hand_made_tuple(const A& aa, const B& bb, const C& cc)
|
||||
: a(aa), b(bb), c(cc) {};
|
||||
A& getA() { return a; };
|
||||
B& getB() { return b; };
|
||||
C& getC() { return c; };
|
||||
};
|
||||
|
||||
hand_made_tuple hmt(A(), B(), C());
|
||||
hmt.getA(); hmt.getB(); hmt.getC();
|
||||
</code></pre>
|
||||
|
||||
and this code:
|
||||
|
||||
<pre><code>tuple<A, B, C> t(A(), B(), C());
|
||||
t.get<0>(); t.get<1>(); t.get<2>();
|
||||
</code></pre>
|
||||
|
||||
<p>Note, that there are widely used compilers (e.g. bcc 5.5.1) which fail to optimize this kind of tuple usage.
|
||||
</p>
|
||||
<p>
|
||||
Depending on the optimizing ability of the compiler, the tier mechanism may have a small performance penalty compared to using
|
||||
non-const reference parameters as a mechanism for returning multiple values from a function.
|
||||
For example, suppose that the following functions <code>f1</code> and <code>f2</code> have equivalent functionalities:
|
||||
|
||||
<pre><code>void f1(int&, double&);
|
||||
tuple<int, double> f2();
|
||||
</code></pre>
|
||||
|
||||
Then, the call #1 may be slightly faster than #2 in the code below:
|
||||
|
||||
<pre><code>int i; double d;
|
||||
...
|
||||
f1(i,d); // #1
|
||||
tie(i,d) = f2(); // #2
|
||||
</code></pre>
|
||||
See
|
||||
[<a href="#publ_1">1</a>,
|
||||
<a href="#publ_2">2</a>]
|
||||
for more in-depth discussions about efficiency.
|
||||
|
||||
<h4>Effect on Compile Time</h4>
|
||||
|
||||
<p>
|
||||
Compiling tuples can be slow due to the excessive amount of template instantiations.
|
||||
Depending on the compiler and the tuple length, it may be more than 10 times slower to compile a tuple construct, compared to compiling an equivalent explicitly written class, such as the <code>hand_made_tuple</code> class above.
|
||||
However, as a realistic program is likely to contain a lot of code in addition to tuple definitions, the difference is probably unnoticeable.
|
||||
Compile time increases between 5 to 10 percentages were measured for programs which used tuples very frequently.
|
||||
With the same test programs, memory consumption of compiling increased between 22% to 27%. See
|
||||
[<a href="#publ_1">1</a>,
|
||||
<a href="#publ_2">2</a>]
|
||||
for details.
|
||||
</p>
|
||||
|
||||
<h2><a name = "portability">Portability</a></h2>
|
||||
|
||||
<p>The library code is(?) standard C++ and thus the library works with a standard conforming compiler.
|
||||
Below is a list of compilers and known problems with each compiler:
|
||||
</p>
|
||||
<table>
|
||||
<tr><td><u>Compiler</u></td><td><u>Problems</u></td></tr>
|
||||
<tr><td>gcc 2.95</td><td>-</td></tr>
|
||||
<tr><td>edg 2.44</td><td>-</td></tr>
|
||||
<tr><td>Borland 5.5</td><td>Can't use function pointers or member pointers as tuple elements</td></tr>
|
||||
<tr><td>Metrowerks 6.2</td><td>Can't use <code>ref</code> and <code>cref</code> wrappers</td></tr>
|
||||
<tr><td>MS Visual C++</td><td>No reference elements (<code>tie</code> still works). Can't use <code>ref</code> and <code>cref</code> wrappers</td></tr>
|
||||
</table>
|
||||
|
||||
<h2><a name = "thanks">Acknowledgements</a></h2>
|
||||
Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC, David Abrahams found a way to get rid of most of the restrictions for compilers not supporting partial specialization. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions.
|
||||
The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David Abrahams and Hartmut Kaiser helped to improve the
|
||||
library.
|
||||
The idea for the tie mechanism came from an old usenet article by Ian McCulloch, where he proposed something similar for std::pairs.
|
||||
<h2><a name = "references">References</a></h2>
|
||||
|
||||
<p>
|
||||
<a name="publ_1"></a>[1]
|
||||
Järvi J.: <i>Tuples and multiple return values in C++</i>, TUCS Technical Report No 249, 1999<!-- (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>)-->.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
<a name="publ_2"></a>[2]
|
||||
Järvi J.: <i>ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism</i>, TUCS Technical Report No 267, 1999<!-- (<a href="http://www.tucs.fi/Publications">http://www.tucs.fi/Publications</a>)-->.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
[3] Järvi J.:<i>Tuple Types and Multiple Return Values</i>, C/C++ Users Journal, August 2001.
|
||||
</p>
|
||||
|
||||
<hr>
|
||||
|
||||
<p>Last modified 2003-09-07</p>
|
||||
|
||||
<p>© Copyright <a href="http://www.boost.org/people/jaakko_jarvi.htm"> Jaakko Järvi</a> 2001.
|
||||
|
||||
Permission to copy, use, modify, sell and distribute this software and its documentation is granted provided this copyright notice appears in all copies.
|
||||
This software and its documentation is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose.
|
||||
</p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,525 +0,0 @@
|
||||
[/
|
||||
/ Copyright (c) 2001 Jaakko J<>rvi
|
||||
/
|
||||
/ 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)
|
||||
/]
|
||||
|
||||
[library Boost.Tuple
|
||||
[quickbook 1.6]
|
||||
[id tuple]
|
||||
[copyright 2001 Jaakko J\u00E4rvi]
|
||||
[dirname tuple]
|
||||
[license Distributed under the
|
||||
[@http://boost.org/LICENSE_1_0.txt Boost Software License,
|
||||
Version 1.0].
|
||||
]
|
||||
]
|
||||
|
||||
[include tuple_advanced_interface.qbk]
|
||||
[include design_decisions_rationale.qbk]
|
||||
|
||||
[template simplesect[title]
|
||||
[block '''<simplesect><title>'''[title]'''</title>''']]
|
||||
|
||||
[template endsimplesect[]
|
||||
[block '''</simplesect>''']]
|
||||
|
||||
A tuple (or n-tuple) is a fixed size collection of elements. Pairs, triples,
|
||||
quadruples etc. are tuples. In a programming language, a tuple is a data
|
||||
object containing other objects as elements. These element objects may be of
|
||||
different types.
|
||||
|
||||
Tuples are convenient in many circumstances. For instance, tuples make it easy
|
||||
to define functions that return more than one value.
|
||||
|
||||
Some programming languages, such as ML, Python and Haskell, have built-in
|
||||
tuple constructs. Unfortunately C++ does not. To compensate for this
|
||||
"deficiency", the Boost Tuple Library implements a tuple construct using
|
||||
templates.
|
||||
|
||||
[section:using_library Using the Library]
|
||||
|
||||
To use the library, just include:
|
||||
|
||||
#include "boost/tuple/tuple.hpp"
|
||||
|
||||
Comparison operators can be included with:
|
||||
|
||||
#include "boost/tuple/tuple_comparison.hpp"
|
||||
|
||||
To use tuple input and output operators,
|
||||
|
||||
#include "boost/tuple/tuple_io.hpp"
|
||||
|
||||
Both `tuple_io.hpp` and `tuple_comparison.hpp` include `tuple.hpp`.
|
||||
|
||||
All definitions are in namespace `::boost::tuples`, but the most common names
|
||||
are lifted to namespace `::boost` with using declarations. These names are:
|
||||
`tuple`, `make_tuple`, `tie` and `get`. Further, `ref` and `cref` are defined
|
||||
directly under the `::boost` namespace.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:tuple_types Tuple Types]
|
||||
|
||||
A tuple type is an instantiation of the `tuple` template. The template
|
||||
parameters specify the types of the tuple elements. The current version
|
||||
supports tuples with 0-10 elements. If necessary, the upper limit can be
|
||||
increased up to, say, a few dozen elements. The data element can be any C++
|
||||
type. Note that `void` and plain function types are valid C++ types, but
|
||||
objects of such types cannot exist. Hence, if a tuple type contains such types
|
||||
as elements, the tuple type can exist, but not an object of that type. There
|
||||
are natural limitations for element types that cannot be copied, or that are
|
||||
not default constructible (see [link tuple.constructing_tuples 'Constructing tuples']
|
||||
below).
|
||||
|
||||
For example, the following definitions are valid tuple instantiations (`A`,
|
||||
`B` and `C` are some user defined classes):
|
||||
|
||||
tuple<int>
|
||||
tuple<double&, const double&, const double, double*, const double*>
|
||||
tuple<A, int(*)(char, int), B(A::*)(C&), C>
|
||||
tuple<std::string, std::pair<A, B> >
|
||||
tuple<A*, tuple<const A*, const B&, C>, bool, void*>
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:constructing_tuples Constructing Tuples]
|
||||
|
||||
The tuple constructor takes the tuple elements as arguments. For an /n/-
|
||||
element tuple, the constructor can be invoked with /k/ arguments, where
|
||||
`0` <= /k/ <= /n/. For example:
|
||||
|
||||
tuple<int, double>()
|
||||
tuple<int, double>(1)
|
||||
tuple<int, double>(1, 3.14)
|
||||
|
||||
If no initial value for an element is provided, it is default initialized
|
||||
(and hence must be default initializable). For example:
|
||||
|
||||
class X {
|
||||
X();
|
||||
public:
|
||||
X(std::string);
|
||||
};
|
||||
|
||||
tuple<X,X,X>() // error: no default constructor for X
|
||||
tuple<X,X,X>(string("Jaba"), string("Daba"), string("Duu")) // ok
|
||||
|
||||
In particular, reference types do not have a default initialization:
|
||||
|
||||
tuple<double&>() // error: reference must be
|
||||
// initialized explicitly
|
||||
|
||||
double d = 5;
|
||||
tuple<double&>(d) // ok
|
||||
|
||||
tuple<double&>(d+3.14) // error: cannot initialize
|
||||
// non-const reference with a temporary
|
||||
|
||||
tuple<const double&>(d+3.14) // ok, but dangerous:
|
||||
// the element becomes a dangling reference
|
||||
|
||||
Using an initial value for an element that cannot be copied, is a compile time
|
||||
error:
|
||||
|
||||
class Y {
|
||||
Y(const Y&);
|
||||
public:
|
||||
Y();
|
||||
};
|
||||
|
||||
char a[10];
|
||||
|
||||
tuple<char[10], Y>(a, Y()); // error, neither arrays nor Y can be copied
|
||||
tuple<char[10], Y>(); // ok
|
||||
|
||||
Note particularly that the following is perfectly ok:
|
||||
|
||||
Y y;
|
||||
tuple<char(&)[10], Y&>(a, y);
|
||||
|
||||
It is possible to come up with a tuple type that cannot be constructed. This
|
||||
occurs if an element that cannot be initialized has a lower index than an
|
||||
element that requires initialization. For example: `tuple<char[10], int&>`.
|
||||
|
||||
In sum, the tuple construction is semantically just a group of individual
|
||||
elementary constructions.
|
||||
|
||||
[section:make_tuple The `make_tuple` function]
|
||||
|
||||
Tuples can also be constructed using the `make_tuple` (cf. `std::make_pair`)
|
||||
helper functions. This makes the construction more convenient, saving the
|
||||
programmer from explicitly specifying the element types:
|
||||
|
||||
tuple<int, int, double> add_multiply_divide(int a, int b) {
|
||||
return make_tuple(a+b, a*b, double(a)/double(b));
|
||||
}
|
||||
|
||||
By default, the element types are deduced to the plain non-reference types.
|
||||
E.g.:
|
||||
|
||||
void foo(const A& a, B& b) {
|
||||
...
|
||||
make_tuple(a, b);
|
||||
|
||||
The `make_tuple` invocation results in a tuple of type `tuple<A, B>`.
|
||||
|
||||
Sometimes the plain non-reference type is not desired, e.g. if the element
|
||||
type cannot be copied. Therefore, the programmer can control the type
|
||||
deduction and state that a reference to const or reference to non-const type
|
||||
should be used as the element type instead. This is accomplished with two
|
||||
helper template functions: [@boost:/libs/core/doc/html/core/ref.html `boost::ref`]
|
||||
and [@boost:/libs/core/doc/html/core/ref.html `boost::cref`]. Any argument can
|
||||
be wrapped with these functions to get the desired type. The mechanism does
|
||||
not compromise const correctness since a const object wrapped with ref results
|
||||
in a tuple element with const reference type (see the fifth example below).
|
||||
For example:
|
||||
|
||||
A a; B b; const A ca = a;
|
||||
make_tuple(cref(a), b); // creates tuple<const A&, B>
|
||||
make_tuple(ref(a), b); // creates tuple<A&, B>
|
||||
make_tuple(ref(a), cref(b)); // creates tuple<A&, const B&>
|
||||
make_tuple(cref(ca)); // creates tuple<const A&>
|
||||
make_tuple(ref(ca)); // creates tuple<const A&>
|
||||
|
||||
Array arguments to `make_tuple` functions are deduced to reference to const
|
||||
types by default; there is no need to wrap them with `cref`. For example:
|
||||
|
||||
make_tuple("Donald", "Daisy");
|
||||
|
||||
This creates an object of type `tuple<const char (&)[7], const char (&)[6]>`
|
||||
(note that the type of a string literal is an array of const characters, not
|
||||
`const char*`). However, to get `make_tuple` to create a tuple with an element
|
||||
of a non-const array type one must use the `ref` wrapper.
|
||||
|
||||
Function pointers are deduced to the plain non-reference type, that is, to
|
||||
plain function pointer. A tuple can also hold a reference to a function, but
|
||||
such a tuple cannot be constructed with `make_tuple` (a const qualified
|
||||
function type would result, which is illegal):
|
||||
|
||||
void f(int i);
|
||||
...
|
||||
make_tuple(&f); // tuple<void (*)(int)>
|
||||
...
|
||||
tuple<tuple<void (&)(int)> > a(f) // ok
|
||||
make_tuple(f); // not ok
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:accessing_elements Accessing Tuple Elements]
|
||||
|
||||
Tuple elements are accessed with the expression:
|
||||
|
||||
t.get<N>()
|
||||
|
||||
or
|
||||
|
||||
get<N>(t)
|
||||
|
||||
where `t` is a tuple object and `N` is a constant integral expression
|
||||
specifying the index of the element to be accessed. Depending on whether `t`
|
||||
is const or not, `get` returns the `N`-th element as a reference to const or
|
||||
non-const type. The index of the first element is `0` and thus `N` must be
|
||||
between `0` and /k/`-1`, where /k/ is the number of elements in the tuple.
|
||||
Violations of these constraints are detected at compile time. Examples:
|
||||
|
||||
double d = 2.7; A a;
|
||||
tuple<int, double&, const A&> t(1, d, a);
|
||||
const tuple<int, double&, const A&> ct = t;
|
||||
...
|
||||
int i = get<0>(t); i = t.get<0>(); // ok
|
||||
int j = get<0>(ct); // ok
|
||||
get<0>(t) = 5; // ok
|
||||
get<0>(ct) = 5; // error, can't assign to const
|
||||
...
|
||||
double e = get<1>(t); // ok
|
||||
get<1>(t) = 3.14; // ok
|
||||
get<2>(t) = A(); // error, can't assign to const
|
||||
A aa = get<3>(t); // error: index out of bounds
|
||||
...
|
||||
++get<0>(t); // ok, can be used as any variable
|
||||
|
||||
/[Note:/ The member `get` functions are not supported with MS Visual C++
|
||||
compiler. Further, the compiler has trouble with finding the non-member `get`
|
||||
functions without an explicit namespace qualifier. Hence, all `get` calls
|
||||
should be qualified as `tuples::get<N>(a_tuple)` when writing code that should
|
||||
compile with MSVC++ 6.0./]/
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:construction_and_assignment Copy Construction and Tuple Assignment]
|
||||
|
||||
A tuple can be copy constructed from another tuple, provided that the element
|
||||
types are element-wise copy constructible. Analogously, a tuple can be
|
||||
assigned to another tuple, provided that the element types are element-wise
|
||||
assignable. For example:
|
||||
|
||||
class A {};
|
||||
class B : public A {};
|
||||
struct C { C(); C(const B&); };
|
||||
struct D { operator C() const; };
|
||||
tuple<char, B*, B, D> t;
|
||||
...
|
||||
tuple<int, A*, C, C> a(t); // ok
|
||||
a = t; // ok
|
||||
|
||||
In both cases, the conversions performed are:
|
||||
|
||||
* `char -> int`,
|
||||
* `B* -> A*` (derived class pointer to base class pointer),
|
||||
* `B -> C` (a user defined conversion), and
|
||||
* `D -> C` (a user defined conversion).
|
||||
|
||||
Note that assignment is also defined from `std::pair` types:
|
||||
|
||||
tuple<float, int> a = std::make_pair(1, 'a');
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:relational_operators Relational Operators]
|
||||
|
||||
Tuples reduce the operators `==`, `!=`, `<`, `>`, `<=` and `>=` to the
|
||||
corresponding elementary operators. This means, that if any of these operators
|
||||
is defined between all elements of two tuples, then the same operator is
|
||||
defined between the tuples as well. The equality operators for two tuples `a`
|
||||
and `b` are defined as:
|
||||
|
||||
* `a == b` iff for each `i`: `a`'''<subscript>i</subscript>'''` == b`'''<subscript>i</subscript>'''
|
||||
* `a != b` iff exists `i`: `a`'''<subscript>i</subscript>'''` != b`'''<subscript>i</subscript>'''
|
||||
|
||||
The operators `<`, `>`, `<=` and `>=` implement a lexicographical ordering.
|
||||
|
||||
Note that an attempt to compare two tuples of different lengths results in a
|
||||
compile time error. Also, the comparison operators are /"short-circuited"/:
|
||||
elementary comparisons start from the first elements and are performed only
|
||||
until the result is clear.
|
||||
|
||||
Examples:
|
||||
|
||||
tuple<std::string, int, A> t1(std::string("same?"), 2, A());
|
||||
tuple<std::string, long, A> t2(std::string("same?"), 2, A());
|
||||
tuple<std::string, long, A> t3(std::string("different"), 3, A());
|
||||
|
||||
bool operator==(A, A) { std::cout << "All the same to me..."; return true; }
|
||||
|
||||
t1 == t2; // true
|
||||
t1 == t3; // false, does not print "All the..."
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:tiers Tiers]
|
||||
|
||||
/Tiers/ are tuples, where all elements are of non-const reference types. They
|
||||
are constructed with a call to the `tie` function template (cf. `make_tuple`):
|
||||
|
||||
int i; char c; double d;
|
||||
...
|
||||
tie(i, c, a);
|
||||
|
||||
The above `tie` function creates a tuple of type `tuple<int&, char&, double&>`.
|
||||
The same result could be achieved with the call `make_tuple(ref(i), ref(c), ref(a))`.
|
||||
|
||||
A tuple that contains non-const references as elements can be used to 'unpack'
|
||||
another tuple into variables. E.g.:
|
||||
|
||||
int i; char c; double d;
|
||||
tie(i, c, d) = make_tuple(1,'a', 5.5);
|
||||
std::cout << i << " " << c << " " << d;
|
||||
|
||||
This code prints `1 a 5.5` to the standard output stream. A tuple unpacking
|
||||
operation like this is found for example in ML and Python. It is convenient
|
||||
when calling functions which return tuples.
|
||||
|
||||
The tying mechanism works with `std::pair` templates as well:
|
||||
|
||||
int i; char c;
|
||||
tie(i, c) = std::make_pair(1, 'a');
|
||||
|
||||
[section Ignore]
|
||||
|
||||
There is also an object called `ignore` which allows you to ignore an element
|
||||
assigned by a tuple. The idea is that a function may return a tuple, only part
|
||||
of which you are interested in. For example (note, that ignore is under the
|
||||
`tuples` subnamespace):
|
||||
|
||||
char c;
|
||||
tie(tuples::ignore, c) = std::make_pair(1, 'a');
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:streaming Streaming]
|
||||
|
||||
The global `operator<<` has been overloaded for `std::ostream` such that
|
||||
tuples are output by recursively calling `operator<<` for each element.
|
||||
|
||||
Analogously, the global `operator>>` has been overloaded to extract tuples
|
||||
from `std::istream` by recursively calling `operator>>` for each element.
|
||||
|
||||
The default delimiter between the elements is space, and the tuple is enclosed
|
||||
in parenthesis. For Example:
|
||||
|
||||
tuple<float, int, std::string> a(1.0f, 2, std::string("Howdy folks!");
|
||||
|
||||
cout << a;
|
||||
|
||||
outputs the tuple as: `(1.0 2 Howdy folks!)`
|
||||
|
||||
The library defines three manipulators for changing the default behavior:
|
||||
|
||||
* `set_open(char)` defines the character that is output before the first element.
|
||||
* `set_close(char)` defines the character that is output after the last element.
|
||||
* `set_delimiter(char)` defines the delimiter character between elements.
|
||||
|
||||
Note, that these manipulators are defined in the tuples subnamespace. For
|
||||
example:
|
||||
|
||||
cout << tuples::set_open('[') << tuples::set_close(']') << tuples::set_delimiter(',') << a;
|
||||
|
||||
outputs the same tuple `a` as: `[1.0,2,Howdy folks!]`
|
||||
|
||||
The same manipulators work with `operator>>` and `istream` as well. Suppose
|
||||
the `cin` stream contains the following data:
|
||||
|
||||
(1 2 3) [4:5]
|
||||
|
||||
The code:
|
||||
|
||||
tuple<int, int, int> i;
|
||||
tuple<int, int> j;
|
||||
|
||||
cin >> i;
|
||||
cin >> tuples::set_open('[') >> tuples::set_close(']') >> tuples::set_delimiter(':');
|
||||
cin >> j;
|
||||
|
||||
reads the data into the tuples `i` and `j`.
|
||||
|
||||
Note that extracting tuples with `std::string` or C-style string elements does
|
||||
not generally work, since the streamed tuple representation may not be
|
||||
unambiguously parseable.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:performance Performance]
|
||||
|
||||
All tuple access and construction functions are small inlined one-liners.
|
||||
Therefore, a decent compiler can eliminate any extra cost of using tuples
|
||||
compared to using hand-written tuple like classes. Particularly, with a decent
|
||||
compiler there is no performance difference between this code:
|
||||
|
||||
class hand_made_tuple {
|
||||
A a; B b; C c;
|
||||
public:
|
||||
hand_made_tuple(const A& aa, const B& bb, const C& cc)
|
||||
: a(aa), b(bb), c(cc) {};
|
||||
A& getA() { return a; };
|
||||
B& getB() { return b; };
|
||||
C& getC() { return c; };
|
||||
};
|
||||
|
||||
hand_made_tuple hmt(A(), B(), C());
|
||||
hmt.getA(); hmt.getB(); hmt.getC();
|
||||
|
||||
and this code:
|
||||
|
||||
tuple<A, B, C> t(A(), B(), C());
|
||||
t.get<0>(); t.get<1>(); t.get<2>();
|
||||
|
||||
Note, that there are widely used compilers (e.g. bcc 5.5.1) which fail to
|
||||
optimize this kind of tuple usage.
|
||||
|
||||
Depending on the optimizing ability of the compiler, the tier mechanism may
|
||||
have a small performance penalty compared to using non-const reference
|
||||
parameters as a mechanism for returning multiple values from a function. For
|
||||
example, suppose that the following functions `f1` and `f2` have equivalent
|
||||
functionalities:
|
||||
|
||||
void f1(int&, double&);
|
||||
tuple<int, double> f2();
|
||||
|
||||
Then, the call #1 may be slightly faster than #2 in the code below:
|
||||
|
||||
int i; double d;
|
||||
...
|
||||
f1(i,d); // #1
|
||||
tie(i,d) = f2(); // #2
|
||||
|
||||
See [[link publ_1 1], [link publ_2 2]] for more in-depth discussions about
|
||||
efficiency.
|
||||
|
||||
[section Effect on Compile Time]
|
||||
|
||||
Compiling tuples can be slow due to the excessive amount of template
|
||||
instantiations. Depending on the compiler and the tuple length, it may be more
|
||||
than 10 times slower to compile a tuple construct, compared to compiling an
|
||||
equivalent explicitly written class, such as the `hand_made_tuple` class above.
|
||||
However, as a realistic program is likely to contain a lot of code in addition
|
||||
to tuple definitions, the difference is probably unnoticeable. Compile time
|
||||
increases between 5 and 10 percent were measured for programs which used tuples
|
||||
very frequently. With the same test programs, memory consumption of compiling
|
||||
increased between 22% to 27%. See [[link publ_1 1], [link publ_2 2]] for
|
||||
details.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:portability Portability]
|
||||
|
||||
The library code is(?) standard C++ and thus the library works with a standard
|
||||
conforming compiler. Below is a list of compilers and known problems with each
|
||||
compiler:
|
||||
|
||||
[table
|
||||
[[Compiler] [Problems]]
|
||||
[[gcc 2.95] [-]]
|
||||
[[edg 2.44] [-]]
|
||||
[[Borland 5.5] [Can't use function pointers or member pointers as
|
||||
tuple elements]]
|
||||
[[Metrowerks 6.2] [Can't use `ref` and `cref` wrappers]]
|
||||
[[MS Visual C++] [No reference elements (`tie` still works). Can't use
|
||||
`ref` and `cref` wrappers]]
|
||||
]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:more_details More Details]
|
||||
|
||||
[link tuple_advanced_interface Advanced features] (describes some metafunctions etc.).
|
||||
|
||||
[link design_decisions_rationale Rationale behind some design/implementation decisions].
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:thanks Acknowledgements]
|
||||
|
||||
Gary Powell has been an indispensable helping hand. In particular, stream
|
||||
manipulators for tuples were his idea. Doug Gregor came up with a working
|
||||
version for MSVC, David Abrahams found a way to get rid of most of the
|
||||
restrictions for compilers not supporting partial specialization. Thanks to
|
||||
Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. The
|
||||
comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David
|
||||
Abrahams and Hartmut Kaiser helped to improve the library. The idea for the
|
||||
`tie` mechanism came from an old usenet article by Ian McCulloch, where he
|
||||
proposed something similar for `std::pair`s.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:references References]
|
||||
|
||||
[#publ_1]
|
||||
[1] J\u00E4rvi J.: /Tuples and multiple return values in C++/, TUCS Technical Report No 249, 1999.
|
||||
|
||||
[#publ_2]
|
||||
[2] J\u00E4rvi J.: /ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism/, TUCS Technical Report No 267, 1999.
|
||||
|
||||
[#publ_3]
|
||||
[3] J\u00E4rvi J.: /Tuple Types and Multiple Return Values/, C/C++ Users Journal, August 2001.
|
||||
|
||||
[endsect]
|
||||
@ -1,6 +1,6 @@
|
||||
// tuple_basic.hpp -----------------------------------------------------
|
||||
|
||||
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
@ -34,19 +34,11 @@
|
||||
|
||||
|
||||
#include <utility> // needed for the assignment from pair to tuple
|
||||
#include <cstddef> // for std::size_t
|
||||
|
||||
#include <boost/type_traits/cv_traits.hpp>
|
||||
#include <boost/type_traits/function_traits.hpp>
|
||||
#include <boost/type_traits/integral_constant.hpp>
|
||||
#include <boost/utility/swap.hpp>
|
||||
#include "boost/type_traits/cv_traits.hpp"
|
||||
#include "boost/type_traits/function_traits.hpp"
|
||||
|
||||
#include <boost/detail/workaround.hpp> // needed for BOOST_WORKAROUND
|
||||
|
||||
#if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
|
||||
#endif
|
||||
#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
|
||||
|
||||
namespace boost {
|
||||
namespace tuples {
|
||||
@ -94,28 +86,45 @@ namespace detail {
|
||||
template<class T>
|
||||
class generate_error;
|
||||
|
||||
template<std::size_t N>
|
||||
struct drop_front {
|
||||
template<class Tuple>
|
||||
struct apply {
|
||||
typedef BOOST_DEDUCED_TYPENAME drop_front<N-1>::BOOST_NESTED_TEMPLATE
|
||||
apply<Tuple> next;
|
||||
typedef BOOST_DEDUCED_TYPENAME next::type::tail_type type;
|
||||
static const type& call(const Tuple& tup) {
|
||||
return next::call(tup).tail;
|
||||
}
|
||||
};
|
||||
// - cons getters --------------------------------------------------------
|
||||
// called: get_class<N>::get<RETURN_TYPE>(aTuple)
|
||||
|
||||
template< int N >
|
||||
struct get_class {
|
||||
template<class RET, class HT, class TT >
|
||||
inline static RET get(const cons<HT, TT>& t)
|
||||
{
|
||||
#if BOOST_WORKAROUND(__IBMCPP__,==600)
|
||||
// vacpp 6.0 is not very consistent regarding the member template keyword
|
||||
// Here it generates an error when the template keyword is used.
|
||||
return get_class<N-1>::get<RET>(t.tail);
|
||||
#else
|
||||
return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
|
||||
#endif
|
||||
}
|
||||
template<class RET, class HT, class TT >
|
||||
inline static RET get(cons<HT, TT>& t)
|
||||
{
|
||||
#if BOOST_WORKAROUND(__IBMCPP__,==600)
|
||||
return get_class<N-1>::get<RET>(t.tail);
|
||||
#else
|
||||
return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct drop_front<0> {
|
||||
template<class Tuple>
|
||||
struct apply {
|
||||
typedef Tuple type;
|
||||
static const type& call(const Tuple& tup) {
|
||||
return tup;
|
||||
}
|
||||
};
|
||||
struct get_class<0> {
|
||||
template<class RET, class HT, class TT>
|
||||
inline static RET get(const cons<HT, TT>& t)
|
||||
{
|
||||
return t.head;
|
||||
}
|
||||
template<class RET, class HT, class TT>
|
||||
inline static RET get(cons<HT, TT>& t)
|
||||
{
|
||||
return t.head;
|
||||
}
|
||||
};
|
||||
|
||||
} // end of namespace detail
|
||||
@ -128,50 +137,83 @@ struct drop_front<0> {
|
||||
|
||||
#ifndef BOOST_NO_CV_SPECIALIZATIONS
|
||||
|
||||
template<std::size_t N, class T>
|
||||
template<int N, class T>
|
||||
struct element
|
||||
{
|
||||
typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
|
||||
apply<T>::type::head_type type;
|
||||
private:
|
||||
typedef typename T::tail_type Next;
|
||||
public:
|
||||
typedef typename element<N-1, Next>::type type;
|
||||
};
|
||||
template<class T>
|
||||
struct element<0,T>
|
||||
{
|
||||
typedef typename T::head_type type;
|
||||
};
|
||||
|
||||
template<std::size_t N, class T>
|
||||
template<int N, class T>
|
||||
struct element<N, const T>
|
||||
{
|
||||
private:
|
||||
typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
|
||||
apply<T>::type::head_type unqualified_type;
|
||||
typedef typename T::tail_type Next;
|
||||
typedef typename element<N-1, Next>::type unqualified_type;
|
||||
public:
|
||||
#if BOOST_WORKAROUND(BOOST_BORLANDC,<0x600)
|
||||
#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
|
||||
typedef const unqualified_type type;
|
||||
#else
|
||||
typedef BOOST_DEDUCED_TYPENAME boost::add_const<unqualified_type>::type type;
|
||||
typedef typename boost::add_const<unqualified_type>::type type;
|
||||
#endif
|
||||
|
||||
};
|
||||
template<class T>
|
||||
struct element<0,const T>
|
||||
{
|
||||
#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
|
||||
typedef const typename T::head_type type;
|
||||
#else
|
||||
typedef typename boost::add_const<typename T::head_type>::type type;
|
||||
#endif
|
||||
};
|
||||
|
||||
#else // def BOOST_NO_CV_SPECIALIZATIONS
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<std::size_t N, class T, bool IsConst>
|
||||
template<int N, class T, bool IsConst>
|
||||
struct element_impl
|
||||
{
|
||||
typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
|
||||
apply<T>::type::head_type type;
|
||||
private:
|
||||
typedef typename T::tail_type Next;
|
||||
public:
|
||||
typedef typename element_impl<N-1, Next, IsConst>::type type;
|
||||
};
|
||||
|
||||
template<std::size_t N, class T>
|
||||
template<int N, class T>
|
||||
struct element_impl<N, T, true /* IsConst */>
|
||||
{
|
||||
typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
|
||||
apply<T>::type::head_type unqualified_type;
|
||||
typedef const unqualified_type type;
|
||||
private:
|
||||
typedef typename T::tail_type Next;
|
||||
public:
|
||||
typedef const typename element_impl<N-1, Next, true>::type type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct element_impl<0, T, false /* IsConst */>
|
||||
{
|
||||
typedef typename T::head_type type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct element_impl<0, T, true /* IsConst */>
|
||||
{
|
||||
typedef const typename T::head_type type;
|
||||
};
|
||||
|
||||
} // end of namespace detail
|
||||
|
||||
|
||||
template<std::size_t N, class T>
|
||||
struct element:
|
||||
template<int N, class T>
|
||||
struct element:
|
||||
public detail::element_impl<N, T, ::boost::is_const<T>::value>
|
||||
{
|
||||
};
|
||||
@ -211,28 +253,43 @@ template <class T> struct access_traits<T&> {
|
||||
|
||||
// get function for non-const cons-lists, returns a reference to the element
|
||||
|
||||
template<std::size_t N, class HT, class TT>
|
||||
template<int N, class HT, class TT>
|
||||
inline typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::non_const_type
|
||||
get(cons<HT, TT>& c) {
|
||||
typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
|
||||
apply<cons<HT, TT> > impl;
|
||||
typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
|
||||
return const_cast<cons_element&>(impl::call(c)).head;
|
||||
get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
|
||||
#if BOOST_WORKAROUND(__IBMCPP__,==600 )
|
||||
return detail::get_class<N>::
|
||||
#else
|
||||
return detail::get_class<N>::BOOST_NESTED_TEMPLATE
|
||||
#endif
|
||||
get<
|
||||
typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::non_const_type,
|
||||
HT,TT
|
||||
>(c);
|
||||
}
|
||||
|
||||
// get function for const cons-lists, returns a const reference to
|
||||
// the element. If the element is a reference, returns the reference
|
||||
// as such (that is, can return a non-const reference)
|
||||
template<std::size_t N, class HT, class TT>
|
||||
template<int N, class HT, class TT>
|
||||
inline typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::const_type
|
||||
get(const cons<HT, TT>& c) {
|
||||
typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
|
||||
apply<cons<HT, TT> > impl;
|
||||
return impl::call(c).head;
|
||||
get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
|
||||
#if BOOST_WORKAROUND(__IBMCPP__,==600)
|
||||
return detail::get_class<N>::
|
||||
#else
|
||||
return detail::get_class<N>::BOOST_NESTED_TEMPLATE
|
||||
#endif
|
||||
get<
|
||||
typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::const_type,
|
||||
HT,TT
|
||||
>(c);
|
||||
}
|
||||
|
||||
// -- the cons template --------------------------------------------------
|
||||
@ -311,7 +368,6 @@ struct cons {
|
||||
tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
|
||||
{}
|
||||
|
||||
cons( const cons& u ) : head(u.head), tail(u.tail) {}
|
||||
|
||||
template <class HT2, class TT2>
|
||||
cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
|
||||
@ -334,7 +390,7 @@ struct cons {
|
||||
}
|
||||
|
||||
// get member functions (non-const and const)
|
||||
template <std::size_t N>
|
||||
template <int N>
|
||||
typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::non_const_type
|
||||
@ -342,7 +398,7 @@ struct cons {
|
||||
return boost::tuples::get<N>(*this); // delegate to non-member get
|
||||
}
|
||||
|
||||
template <std::size_t N>
|
||||
template <int N>
|
||||
typename access_traits<
|
||||
typename element<N, cons<HT, TT> >::type
|
||||
>::const_type
|
||||
@ -391,8 +447,6 @@ struct cons<HT, null_type> {
|
||||
const null_type&, const null_type&, const null_type&)
|
||||
: head () {}
|
||||
|
||||
cons( const cons& u ) : head(u.head) {}
|
||||
|
||||
template <class HT2>
|
||||
cons( const cons<HT2, null_type>& u ) : head(u.head) {}
|
||||
|
||||
@ -404,19 +458,19 @@ struct cons<HT, null_type> {
|
||||
// is illformed if HT is a reference
|
||||
cons& operator=(const cons& u) { head = u.head; return *this; }
|
||||
|
||||
template <std::size_t N>
|
||||
template <int N>
|
||||
typename access_traits<
|
||||
typename element<N, self_type>::type
|
||||
>::non_const_type
|
||||
get() {
|
||||
get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
|
||||
return boost::tuples::get<N>(*this);
|
||||
}
|
||||
|
||||
template <std::size_t N>
|
||||
template <int N>
|
||||
typename access_traits<
|
||||
typename element<N, self_type>::type
|
||||
>::const_type
|
||||
get() const {
|
||||
get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {
|
||||
return boost::tuples::get<N>(*this);
|
||||
}
|
||||
|
||||
@ -425,29 +479,20 @@ struct cons<HT, null_type> {
|
||||
// templates for finding out the length of the tuple -------------------
|
||||
|
||||
template<class T>
|
||||
struct length: boost::integral_constant<std::size_t, 1 + length<typename T::tail_type>::value>
|
||||
{
|
||||
struct length {
|
||||
BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
|
||||
};
|
||||
|
||||
template<>
|
||||
struct length<tuple<> >: boost::integral_constant<std::size_t, 0>
|
||||
{
|
||||
struct length<tuple<> > {
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
|
||||
template<>
|
||||
struct length<tuple<> const>: boost::integral_constant<std::size_t, 0>
|
||||
{
|
||||
struct length<null_type> {
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
|
||||
template<>
|
||||
struct length<null_type>: boost::integral_constant<std::size_t, 0>
|
||||
{
|
||||
};
|
||||
|
||||
template<>
|
||||
struct length<null_type const>: boost::integral_constant<std::size_t, 0>
|
||||
{
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
@ -489,7 +534,7 @@ public:
|
||||
// access_traits<T>::parameter_type takes non-reference types as const T&
|
||||
tuple() {}
|
||||
|
||||
explicit tuple(typename access_traits<T0>::parameter_type t0)
|
||||
tuple(typename access_traits<T0>::parameter_type t0)
|
||||
: inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull(),
|
||||
detail::cnull(), detail::cnull(), detail::cnull()) {}
|
||||
@ -609,21 +654,18 @@ public:
|
||||
// Swallows any assignment (by Doug Gregor)
|
||||
namespace detail {
|
||||
|
||||
struct swallow_assign;
|
||||
typedef void (detail::swallow_assign::*ignore_t)();
|
||||
struct swallow_assign {
|
||||
swallow_assign(ignore_t(*)(ignore_t)) {}
|
||||
|
||||
template<typename T>
|
||||
swallow_assign const& operator=(const T&) const {
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// "ignore" allows tuple positions to be ignored when using "tie".
|
||||
inline detail::ignore_t ignore(detail::ignore_t) { return 0; }
|
||||
detail::swallow_assign const ignore = detail::swallow_assign();
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// The call_traits for make_tuple
|
||||
@ -677,20 +719,20 @@ struct make_tuple_traits<T&> {
|
||||
// All arrays are converted to const. This is because make_tuple takes its
|
||||
// parameters as const T& and thus the knowledge of the potential
|
||||
// non-constness of actual argument is lost.
|
||||
template<class T, std::size_t n> struct make_tuple_traits <T[n]> {
|
||||
template<class T, int n> struct make_tuple_traits <T[n]> {
|
||||
typedef const T (&type)[n];
|
||||
};
|
||||
|
||||
template<class T, std::size_t n>
|
||||
template<class T, int n>
|
||||
struct make_tuple_traits<const T[n]> {
|
||||
typedef const T (&type)[n];
|
||||
};
|
||||
|
||||
template<class T, std::size_t n> struct make_tuple_traits<volatile T[n]> {
|
||||
template<class T, int n> struct make_tuple_traits<volatile T[n]> {
|
||||
typedef const volatile T (&type)[n];
|
||||
};
|
||||
|
||||
template<class T, std::size_t n>
|
||||
template<class T, int n>
|
||||
struct make_tuple_traits<const volatile T[n]> {
|
||||
typedef const volatile T (&type)[n];
|
||||
};
|
||||
@ -705,10 +747,6 @@ struct make_tuple_traits<const reference_wrapper<T> >{
|
||||
typedef T& type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct make_tuple_traits<detail::ignore_t(detail::ignore_t)> {
|
||||
typedef detail::swallow_assign type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -830,163 +868,77 @@ make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
|
||||
return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
|
||||
}
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class T>
|
||||
struct tie_traits {
|
||||
typedef T& type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct tie_traits<ignore_t(ignore_t)> {
|
||||
typedef swallow_assign type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct tie_traits<void> {
|
||||
typedef null_type type;
|
||||
};
|
||||
|
||||
template <
|
||||
class T0 = void, class T1 = void, class T2 = void,
|
||||
class T3 = void, class T4 = void, class T5 = void,
|
||||
class T6 = void, class T7 = void, class T8 = void,
|
||||
class T9 = void
|
||||
>
|
||||
struct tie_mapper {
|
||||
typedef
|
||||
tuple<typename tie_traits<T0>::type,
|
||||
typename tie_traits<T1>::type,
|
||||
typename tie_traits<T2>::type,
|
||||
typename tie_traits<T3>::type,
|
||||
typename tie_traits<T4>::type,
|
||||
typename tie_traits<T5>::type,
|
||||
typename tie_traits<T6>::type,
|
||||
typename tie_traits<T7>::type,
|
||||
typename tie_traits<T8>::type,
|
||||
typename tie_traits<T9>::type> type;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
// Tie function templates -------------------------------------------------
|
||||
template<class T0>
|
||||
inline typename detail::tie_mapper<T0>::type
|
||||
tie(T0& t0) {
|
||||
typedef typename detail::tie_mapper<T0>::type t;
|
||||
return t(t0);
|
||||
template<class T1>
|
||||
inline tuple<T1&> tie(T1& t1) {
|
||||
return tuple<T1&> (t1);
|
||||
}
|
||||
|
||||
template<class T0, class T1>
|
||||
inline typename detail::tie_mapper<T0, T1>::type
|
||||
tie(T0& t0, T1& t1) {
|
||||
typedef typename detail::tie_mapper<T0, T1>::type t;
|
||||
return t(t0, t1);
|
||||
template<class T1, class T2>
|
||||
inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
|
||||
return tuple<T1&, T2&> (t1, t2);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2>
|
||||
inline typename detail::tie_mapper<T0, T1, T2>::type
|
||||
tie(T0& t0, T1& t1, T2& t2) {
|
||||
typedef typename detail::tie_mapper<T0, T1, T2>::type t;
|
||||
return t(t0, t1, t2);
|
||||
template<class T1, class T2, class T3>
|
||||
inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
|
||||
return tuple<T1&, T2&, T3&> (t1, t2, t3);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3>
|
||||
inline typename detail::tie_mapper<T0, T1, T2, T3>::type
|
||||
tie(T0& t0, T1& t1, T2& t2, T3& t3) {
|
||||
typedef typename detail::tie_mapper<T0, T1, T2, T3>::type t;
|
||||
return t(t0, t1, t2, t3);
|
||||
template<class T1, class T2, class T3, class T4>
|
||||
inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
|
||||
return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4>
|
||||
inline typename detail::tie_mapper<T0, T1, T2, T3, T4>::type
|
||||
tie(T0& t0, T1& t1, T2& t2, T3& t3,
|
||||
T4& t4) {
|
||||
typedef typename detail::tie_mapper<T0, T1, T2, T3, T4>::type t;
|
||||
return t(t0, t1, t2, t3, t4);
|
||||
template<class T1, class T2, class T3, class T4, class T5>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5>
|
||||
inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type
|
||||
tie(T0& t0, T1& t1, T2& t2, T3& t3,
|
||||
T4& t4, T5& t5) {
|
||||
typedef typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type t;
|
||||
return t(t0, t1, t2, t3, t4, t5);
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
|
||||
inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6>::type
|
||||
tie(T0& t0, T1& t1, T2& t2, T3& t3,
|
||||
T4& t4, T5& t5, T6& t6) {
|
||||
typedef typename detail::tie_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6>::type t;
|
||||
return t(t0, t1, t2, t3, t4, t5, t6);
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
|
||||
class T7>
|
||||
inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
|
||||
tie(T0& t0, T1& t1, T2& t2, T3& t3,
|
||||
T4& t4, T5& t5, T6& t6, T7& t7) {
|
||||
typedef typename detail::tie_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7>::type t;
|
||||
return t(t0, t1, t2, t3, t4, t5, t6, t7);
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
|
||||
class T8>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
|
||||
(t1, t2, t3, t4, t5, t6, t7, t8);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
|
||||
class T7, class T8>
|
||||
inline typename detail::tie_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
|
||||
tie(T0& t0, T1& t1, T2& t2, T3& t3,
|
||||
T4& t4, T5& t5, T6& t6, T7& t7,
|
||||
T8& t8) {
|
||||
typedef typename detail::tie_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
|
||||
return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
|
||||
class T8, class T9>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
|
||||
T9& t9) {
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
|
||||
(t1, t2, t3, t4, t5, t6, t7, t8, t9);
|
||||
}
|
||||
|
||||
template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
|
||||
class T7, class T8, class T9>
|
||||
inline typename detail::tie_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
|
||||
tie(T0& t0, T1& t1, T2& t2, T3& t3,
|
||||
T4& t4, T5& t5, T6& t6, T7& t7,
|
||||
T8& t8, T9& t9) {
|
||||
typedef typename detail::tie_mapper
|
||||
<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
|
||||
return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
|
||||
}
|
||||
|
||||
template <class T0, class T1, class T2, class T3, class T4,
|
||||
class T5, class T6, class T7, class T8, class T9>
|
||||
void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
|
||||
tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs);
|
||||
inline void swap(null_type&, null_type&) {}
|
||||
template<class HH>
|
||||
inline void swap(cons<HH, null_type>& lhs, cons<HH, null_type>& rhs) {
|
||||
::boost::swap(lhs.head, rhs.head);
|
||||
}
|
||||
template<class HH, class TT>
|
||||
inline void swap(cons<HH, TT>& lhs, cons<HH, TT>& rhs) {
|
||||
::boost::swap(lhs.head, rhs.head);
|
||||
::boost::tuples::swap(lhs.tail, rhs.tail);
|
||||
}
|
||||
template <class T0, class T1, class T2, class T3, class T4,
|
||||
class T5, class T6, class T7, class T8, class T9>
|
||||
inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
|
||||
tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs) {
|
||||
typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tuple_type;
|
||||
typedef typename tuple_type::inherited base;
|
||||
::boost::tuples::swap(static_cast<base&>(lhs), static_cast<base&>(rhs));
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
|
||||
class T8, class T9, class T10>
|
||||
inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
|
||||
T9& t9, T10& t10) {
|
||||
return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
|
||||
(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
|
||||
}
|
||||
|
||||
} // end of namespace tuples
|
||||
} // end of namespace boost
|
||||
|
||||
|
||||
#if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
|
||||
|
||||
#endif // BOOST_TUPLE_BASIC_HPP
|
||||
|
||||
|
||||
|
||||
841
include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
Normal file
841
include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
Normal file
@ -0,0 +1,841 @@
|
||||
// - tuple_basic_no_partial_spec.hpp -----------------------------------------
|
||||
|
||||
// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu)
|
||||
// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
|
||||
//
|
||||
// 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)
|
||||
|
||||
// For more information, see http://www.boost.org or http://lambda.cs.utu.fi
|
||||
|
||||
// Revision History
|
||||
// 14 02 01 Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG)
|
||||
// 10 02 01 Fixed "null_type" constructors.
|
||||
// Implemented comparison operators globally.
|
||||
// Hide element_type_ref and element_type_const_ref.
|
||||
// (DG).
|
||||
// 09 02 01 Extended to tuples of length 10. Changed comparison for
|
||||
// operator<()
|
||||
// to the same used by std::pair<>, added cnull_type() (GP)
|
||||
// 03 02 01 Initial Version from original tuple.hpp code by JJ. (DG)
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
|
||||
#define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
|
||||
|
||||
#include "boost/type_traits.hpp"
|
||||
#include <utility>
|
||||
|
||||
#if defined BOOST_MSVC
|
||||
#pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored
|
||||
#pragma warning(disable:4181) // qualifier applied to reference type ignored
|
||||
#pragma warning(disable:4227) // qualifier applied to reference type ignored
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace tuples {
|
||||
|
||||
// null_type denotes the end of a list built with "cons"
|
||||
struct null_type
|
||||
{
|
||||
null_type() {}
|
||||
null_type(const null_type&, const null_type&) {}
|
||||
};
|
||||
|
||||
// a helper function to provide a const null_type type temporary
|
||||
inline const null_type cnull_type() { return null_type(); }
|
||||
|
||||
// forward declaration of tuple
|
||||
template<
|
||||
typename T1 = null_type,
|
||||
typename T2 = null_type,
|
||||
typename T3 = null_type,
|
||||
typename T4 = null_type,
|
||||
typename T5 = null_type,
|
||||
typename T6 = null_type,
|
||||
typename T7 = null_type,
|
||||
typename T8 = null_type,
|
||||
typename T9 = null_type,
|
||||
typename T10 = null_type
|
||||
>
|
||||
class tuple;
|
||||
|
||||
// forward declaration of cons
|
||||
template<typename Head, typename Tail = null_type>
|
||||
struct cons;
|
||||
|
||||
namespace detail {
|
||||
|
||||
// Takes a pointer and routes all assignments to whatever it points to
|
||||
template<typename T>
|
||||
struct assign_to_pointee
|
||||
{
|
||||
public:
|
||||
explicit assign_to_pointee(T* p) : ptr(p) {}
|
||||
|
||||
template<typename Other>
|
||||
assign_to_pointee& operator=(const Other& other)
|
||||
{
|
||||
*ptr = other;
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
T* ptr;
|
||||
};
|
||||
|
||||
// Swallows any assignment
|
||||
struct swallow_assign
|
||||
{
|
||||
template<typename T>
|
||||
swallow_assign const& operator=(const T&) const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T> struct add_const_reference : add_reference<typename add_const<T>::type> {};
|
||||
|
||||
template <class MyTail>
|
||||
struct init_tail
|
||||
{
|
||||
// Each of vc6 and vc7 seem to require a different formulation
|
||||
// of this return type
|
||||
template <class H, class T>
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
||||
static typename add_reference<typename add_const<T>::type>::type
|
||||
#else
|
||||
static typename add_const_reference<T>::type
|
||||
#endif
|
||||
execute( cons<H,T> const& u, long )
|
||||
{
|
||||
return u.get_tail();
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct init_tail<null_type>
|
||||
{
|
||||
template <class H>
|
||||
static null_type execute( cons<H,null_type> const& u, long )
|
||||
{
|
||||
return null_type();
|
||||
}
|
||||
|
||||
template <class U>
|
||||
static null_type execute(U const&, ...)
|
||||
{
|
||||
return null_type();
|
||||
}
|
||||
private:
|
||||
template <class H, class T>
|
||||
void execute( cons<H,T> const&, int);
|
||||
};
|
||||
|
||||
template <class Other>
|
||||
Other const&
|
||||
init_head( Other const& u, ... )
|
||||
{
|
||||
return u;
|
||||
}
|
||||
|
||||
template <class H, class T>
|
||||
typename add_reference<typename add_const<H>::type>::type
|
||||
init_head( cons<H,T> const& u, int )
|
||||
{
|
||||
return u.get_head();
|
||||
}
|
||||
|
||||
inline char**** init_head(null_type const&, int);
|
||||
|
||||
} // end of namespace detail
|
||||
|
||||
// cons builds a heterogenous list of types
|
||||
template<typename Head, typename Tail>
|
||||
struct cons
|
||||
{
|
||||
typedef cons self_type;
|
||||
typedef Head head_type;
|
||||
typedef Tail tail_type;
|
||||
|
||||
private:
|
||||
typedef typename boost::add_reference<head_type>::type head_ref;
|
||||
typedef typename boost::add_reference<tail_type>::type tail_ref;
|
||||
typedef typename detail::add_const_reference<head_type>::type head_cref;
|
||||
typedef typename detail::add_const_reference<tail_type>::type tail_cref;
|
||||
public:
|
||||
head_type head;
|
||||
tail_type tail;
|
||||
|
||||
head_ref get_head() { return head; }
|
||||
tail_ref get_tail() { return tail; }
|
||||
|
||||
head_cref get_head() const { return head; }
|
||||
tail_cref get_tail() const { return tail; }
|
||||
|
||||
cons() : head(), tail() {}
|
||||
|
||||
#if defined BOOST_MSVC
|
||||
template<typename Tail>
|
||||
cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
|
||||
const Tail& t) : head(h), tail(t.head, t.tail)
|
||||
{
|
||||
}
|
||||
|
||||
cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
|
||||
const null_type& t) : head(h), tail(t)
|
||||
{
|
||||
}
|
||||
|
||||
#else
|
||||
template<typename T>
|
||||
explicit cons(head_cref h, const T& t) :
|
||||
head(h), tail(t.head, t.tail)
|
||||
{
|
||||
}
|
||||
|
||||
explicit cons(head_cref h = head_type(),
|
||||
tail_cref t = tail_type()) :
|
||||
head(h), tail(t)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class U>
|
||||
cons( const U& u )
|
||||
: head(detail::init_head(u, 0))
|
||||
, tail(detail::init_tail<Tail>::execute(u, 0L))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Other>
|
||||
cons& operator=(const Other& other)
|
||||
{
|
||||
head = other.head;
|
||||
tail = other.tail;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
// Determines if the parameter is null_type
|
||||
template<typename T> struct is_null_type { enum { RET = 0 }; };
|
||||
template<> struct is_null_type<null_type> { enum { RET = 1 }; };
|
||||
|
||||
/* Build a cons structure from the given Head and Tail. If both are null_type,
|
||||
return null_type. */
|
||||
template<typename Head, typename Tail>
|
||||
struct build_cons
|
||||
{
|
||||
private:
|
||||
enum { tail_is_null_type = is_null_type<Tail>::RET };
|
||||
public:
|
||||
typedef cons<Head, Tail> RET;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct build_cons<null_type, null_type>
|
||||
{
|
||||
typedef null_type RET;
|
||||
};
|
||||
|
||||
// Map the N elements of a tuple into a cons list
|
||||
template<
|
||||
typename T1,
|
||||
typename T2 = null_type,
|
||||
typename T3 = null_type,
|
||||
typename T4 = null_type,
|
||||
typename T5 = null_type,
|
||||
typename T6 = null_type,
|
||||
typename T7 = null_type,
|
||||
typename T8 = null_type,
|
||||
typename T9 = null_type,
|
||||
typename T10 = null_type
|
||||
>
|
||||
struct map_tuple_to_cons
|
||||
{
|
||||
typedef typename detail::build_cons<T10, null_type >::RET cons10;
|
||||
typedef typename detail::build_cons<T9, cons10>::RET cons9;
|
||||
typedef typename detail::build_cons<T8, cons9>::RET cons8;
|
||||
typedef typename detail::build_cons<T7, cons8>::RET cons7;
|
||||
typedef typename detail::build_cons<T6, cons7>::RET cons6;
|
||||
typedef typename detail::build_cons<T5, cons6>::RET cons5;
|
||||
typedef typename detail::build_cons<T4, cons5>::RET cons4;
|
||||
typedef typename detail::build_cons<T3, cons4>::RET cons3;
|
||||
typedef typename detail::build_cons<T2, cons3>::RET cons2;
|
||||
typedef typename detail::build_cons<T1, cons2>::RET cons1;
|
||||
};
|
||||
|
||||
// Workaround the lack of partial specialization in some compilers
|
||||
template<int N>
|
||||
struct _element_type
|
||||
{
|
||||
template<typename Tuple>
|
||||
struct inner
|
||||
{
|
||||
private:
|
||||
typedef typename Tuple::tail_type tail_type;
|
||||
typedef _element_type<N-1> next_elt_type;
|
||||
|
||||
public:
|
||||
typedef typename _element_type<N-1>::template inner<tail_type>::RET RET;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct _element_type<0>
|
||||
{
|
||||
template<typename Tuple>
|
||||
struct inner
|
||||
{
|
||||
typedef typename Tuple::head_type RET;
|
||||
};
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
|
||||
// Return the Nth type of the given Tuple
|
||||
template<int N, typename Tuple>
|
||||
struct element
|
||||
{
|
||||
private:
|
||||
typedef detail::_element_type<N> nth_type;
|
||||
|
||||
public:
|
||||
typedef typename nth_type::template inner<Tuple>::RET RET;
|
||||
typedef RET type;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
|
||||
// special workaround for vc7:
|
||||
|
||||
template <bool x>
|
||||
struct reference_adder
|
||||
{
|
||||
template <class T>
|
||||
struct rebind
|
||||
{
|
||||
typedef T& type;
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct reference_adder<true>
|
||||
{
|
||||
template <class T>
|
||||
struct rebind
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
// Return a reference to the Nth type of the given Tuple
|
||||
template<int N, typename Tuple>
|
||||
struct element_ref
|
||||
{
|
||||
private:
|
||||
typedef typename element<N, Tuple>::RET elt_type;
|
||||
enum { is_ref = is_reference<elt_type>::value };
|
||||
|
||||
public:
|
||||
typedef reference_adder<is_ref>::rebind<elt_type>::type RET;
|
||||
typedef RET type;
|
||||
};
|
||||
|
||||
// Return a const reference to the Nth type of the given Tuple
|
||||
template<int N, typename Tuple>
|
||||
struct element_const_ref
|
||||
{
|
||||
private:
|
||||
typedef typename element<N, Tuple>::RET elt_type;
|
||||
enum { is_ref = is_reference<elt_type>::value };
|
||||
|
||||
public:
|
||||
typedef reference_adder<is_ref>::rebind<const elt_type>::type RET;
|
||||
typedef RET type;
|
||||
};
|
||||
|
||||
#else // vc7
|
||||
|
||||
// Return a reference to the Nth type of the given Tuple
|
||||
template<int N, typename Tuple>
|
||||
struct element_ref
|
||||
{
|
||||
private:
|
||||
typedef typename element<N, Tuple>::RET elt_type;
|
||||
|
||||
public:
|
||||
typedef typename add_reference<elt_type>::type RET;
|
||||
typedef RET type;
|
||||
};
|
||||
|
||||
// Return a const reference to the Nth type of the given Tuple
|
||||
template<int N, typename Tuple>
|
||||
struct element_const_ref
|
||||
{
|
||||
private:
|
||||
typedef typename element<N, Tuple>::RET elt_type;
|
||||
|
||||
public:
|
||||
typedef typename add_reference<const elt_type>::type RET;
|
||||
typedef RET type;
|
||||
};
|
||||
#endif // vc7
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// Get length of this tuple
|
||||
template<typename Tuple>
|
||||
struct length
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
|
||||
};
|
||||
|
||||
template<> struct length<tuple<> > {
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
|
||||
template<>
|
||||
struct length<null_type>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
// Reference the Nth element in a tuple and retrieve it with "get"
|
||||
template<int N>
|
||||
struct get_class
|
||||
{
|
||||
template<typename Head, typename Tail>
|
||||
static inline
|
||||
typename detail::element_ref<N, cons<Head, Tail> >::RET
|
||||
get(cons<Head, Tail>& t)
|
||||
{
|
||||
return get_class<N-1>::get(t.tail);
|
||||
}
|
||||
|
||||
template<typename Head, typename Tail>
|
||||
static inline
|
||||
typename detail::element_const_ref<N, cons<Head, Tail> >::RET
|
||||
get(const cons<Head, Tail>& t)
|
||||
{
|
||||
return get_class<N-1>::get(t.tail);
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct get_class<0>
|
||||
{
|
||||
template<typename Head, typename Tail>
|
||||
static inline
|
||||
typename add_reference<Head>::type
|
||||
get(cons<Head, Tail>& t)
|
||||
{
|
||||
return t.head;
|
||||
}
|
||||
|
||||
template<typename Head, typename Tail>
|
||||
static inline
|
||||
typename add_reference<const Head>::type
|
||||
get(const cons<Head, Tail>& t)
|
||||
{
|
||||
return t.head;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// tuple class
|
||||
template<
|
||||
typename T1,
|
||||
typename T2,
|
||||
typename T3,
|
||||
typename T4,
|
||||
typename T5,
|
||||
typename T6,
|
||||
typename T7,
|
||||
typename T8,
|
||||
typename T9,
|
||||
typename T10
|
||||
>
|
||||
class tuple :
|
||||
public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
|
||||
{
|
||||
private:
|
||||
typedef detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mapped_tuple;
|
||||
typedef typename mapped_tuple::cons10 cons10;
|
||||
typedef typename mapped_tuple::cons9 cons9;
|
||||
typedef typename mapped_tuple::cons8 cons8;
|
||||
typedef typename mapped_tuple::cons7 cons7;
|
||||
typedef typename mapped_tuple::cons6 cons6;
|
||||
typedef typename mapped_tuple::cons5 cons5;
|
||||
typedef typename mapped_tuple::cons4 cons4;
|
||||
typedef typename mapped_tuple::cons3 cons3;
|
||||
typedef typename mapped_tuple::cons2 cons2;
|
||||
typedef typename mapped_tuple::cons1 cons1;
|
||||
|
||||
typedef typename detail::add_const_reference<T1>::type t1_cref;
|
||||
typedef typename detail::add_const_reference<T2>::type t2_cref;
|
||||
typedef typename detail::add_const_reference<T3>::type t3_cref;
|
||||
typedef typename detail::add_const_reference<T4>::type t4_cref;
|
||||
typedef typename detail::add_const_reference<T5>::type t5_cref;
|
||||
typedef typename detail::add_const_reference<T6>::type t6_cref;
|
||||
typedef typename detail::add_const_reference<T7>::type t7_cref;
|
||||
typedef typename detail::add_const_reference<T8>::type t8_cref;
|
||||
typedef typename detail::add_const_reference<T9>::type t9_cref;
|
||||
typedef typename detail::add_const_reference<T10>::type t10_cref;
|
||||
public:
|
||||
typedef cons1 inherited;
|
||||
typedef tuple self_type;
|
||||
|
||||
tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
|
||||
{}
|
||||
|
||||
tuple(
|
||||
t1_cref t1,
|
||||
t2_cref t2,
|
||||
t3_cref t3 = T3(),
|
||||
t4_cref t4 = T4(),
|
||||
t5_cref t5 = T5(),
|
||||
t6_cref t6 = T6(),
|
||||
t7_cref t7 = T7(),
|
||||
t8_cref t8 = T8(),
|
||||
t9_cref t9 = T9(),
|
||||
t10_cref t10 = T10()
|
||||
) :
|
||||
cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
|
||||
{
|
||||
}
|
||||
|
||||
explicit tuple(t1_cref t1)
|
||||
: cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
|
||||
{}
|
||||
|
||||
template<typename Head, typename Tail>
|
||||
tuple(const cons<Head, Tail>& other) :
|
||||
cons1(other.head, other.tail)
|
||||
{
|
||||
}
|
||||
|
||||
template<typename First, typename Second>
|
||||
self_type& operator=(const std::pair<First, Second>& other)
|
||||
{
|
||||
this->head = other.first;
|
||||
this->tail.head = other.second;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename Head, typename Tail>
|
||||
self_type& operator=(const cons<Head, Tail>& other)
|
||||
{
|
||||
this->head = other.head;
|
||||
this->tail = other.tail;
|
||||
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<int N> struct workaround_holder {};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<int N, typename Head, typename Tail>
|
||||
typename detail::element_ref<N, cons<Head, Tail> >::RET
|
||||
get(cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
|
||||
{
|
||||
return detail::get_class<N>::get(t);
|
||||
}
|
||||
|
||||
template<int N, typename Head, typename Tail>
|
||||
typename detail::element_const_ref<N, cons<Head, Tail> >::RET
|
||||
get(const cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
|
||||
{
|
||||
return detail::get_class<N>::get(t);
|
||||
}
|
||||
|
||||
// Make a tuple
|
||||
template<typename T1>
|
||||
inline
|
||||
tuple<T1>
|
||||
make_tuple(const T1& t1)
|
||||
{
|
||||
return tuple<T1>(t1);
|
||||
}
|
||||
|
||||
// Make a tuple
|
||||
template<typename T1, typename T2>
|
||||
inline
|
||||
tuple<T1, T2>
|
||||
make_tuple(const T1& t1, const T2& t2)
|
||||
{
|
||||
return tuple<T1, T2>(t1, t2);
|
||||
}
|
||||
|
||||
// Make a tuple
|
||||
template<typename T1, typename T2, typename T3>
|
||||
inline
|
||||
tuple<T1, T2, T3>
|
||||
make_tuple(const T1& t1, const T2& t2, const T3& t3)
|
||||
{
|
||||
return tuple<T1, T2, T3>(t1, t2, t3);
|
||||
}
|
||||
|
||||
// Make a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4>
|
||||
inline
|
||||
tuple<T1, T2, T3, T4>
|
||||
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
|
||||
{
|
||||
return tuple<T1, T2, T3, T4>(t1, t2, t3, t4);
|
||||
}
|
||||
|
||||
// Make a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5>
|
||||
inline
|
||||
tuple<T1, T2, T3, T4, T5>
|
||||
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5)
|
||||
{
|
||||
return tuple<T1, T2, T3, T4, T5>(t1, t2, t3, t4, t5);
|
||||
}
|
||||
|
||||
// Make a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
|
||||
inline
|
||||
tuple<T1, T2, T3, T4, T5, T6>
|
||||
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6)
|
||||
{
|
||||
return tuple<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6);
|
||||
}
|
||||
|
||||
// Make a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
|
||||
inline
|
||||
tuple<T1, T2, T3, T4, T5, T6, T7>
|
||||
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7)
|
||||
{
|
||||
return tuple<T1, T2, T3, T4, T5, T6, T7>(t1, t2, t3, t4, t5, t6, t7);
|
||||
}
|
||||
|
||||
// Make a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
|
||||
inline
|
||||
tuple<T1, T2, T3, T4, T5, T6, T7, T8>
|
||||
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8)
|
||||
{
|
||||
return tuple<T1, T2, T3, T4, T5, T6, T7, T8>(t1, t2, t3, t4, t5, t6, t7, t8);
|
||||
}
|
||||
|
||||
// Make a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
|
||||
inline
|
||||
tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
|
||||
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9)
|
||||
{
|
||||
return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(t1, t2, t3, t4, t5, t6, t7, t8, t9);
|
||||
}
|
||||
|
||||
// Make a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
|
||||
inline
|
||||
tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
|
||||
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10)
|
||||
{
|
||||
return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1> >
|
||||
tie(T1& t1)
|
||||
{
|
||||
return make_tuple(detail::assign_to_pointee<T1>(&t1));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2> >
|
||||
tie(T1& t1, T2& t2)
|
||||
{
|
||||
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
||||
detail::assign_to_pointee<T2>(&t2));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3> >
|
||||
tie(T1& t1, T2& t2, T3& t3)
|
||||
{
|
||||
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
||||
detail::assign_to_pointee<T2>(&t2),
|
||||
detail::assign_to_pointee<T3>(&t3));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4> >
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4)
|
||||
{
|
||||
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
||||
detail::assign_to_pointee<T2>(&t2),
|
||||
detail::assign_to_pointee<T3>(&t3),
|
||||
detail::assign_to_pointee<T4>(&t4));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4>,
|
||||
detail::assign_to_pointee<T5> >
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5)
|
||||
{
|
||||
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
||||
detail::assign_to_pointee<T2>(&t2),
|
||||
detail::assign_to_pointee<T3>(&t3),
|
||||
detail::assign_to_pointee<T4>(&t4),
|
||||
detail::assign_to_pointee<T5>(&t5));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4>,
|
||||
detail::assign_to_pointee<T5>,
|
||||
detail::assign_to_pointee<T6> >
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6)
|
||||
{
|
||||
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
||||
detail::assign_to_pointee<T2>(&t2),
|
||||
detail::assign_to_pointee<T3>(&t3),
|
||||
detail::assign_to_pointee<T4>(&t4),
|
||||
detail::assign_to_pointee<T5>(&t5),
|
||||
detail::assign_to_pointee<T6>(&t6));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4>,
|
||||
detail::assign_to_pointee<T5>,
|
||||
detail::assign_to_pointee<T6>,
|
||||
detail::assign_to_pointee<T7> >
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7)
|
||||
{
|
||||
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
||||
detail::assign_to_pointee<T2>(&t2),
|
||||
detail::assign_to_pointee<T3>(&t3),
|
||||
detail::assign_to_pointee<T4>(&t4),
|
||||
detail::assign_to_pointee<T5>(&t5),
|
||||
detail::assign_to_pointee<T6>(&t6),
|
||||
detail::assign_to_pointee<T7>(&t7));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4>,
|
||||
detail::assign_to_pointee<T5>,
|
||||
detail::assign_to_pointee<T6>,
|
||||
detail::assign_to_pointee<T7>,
|
||||
detail::assign_to_pointee<T8> >
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
|
||||
{
|
||||
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
||||
detail::assign_to_pointee<T2>(&t2),
|
||||
detail::assign_to_pointee<T3>(&t3),
|
||||
detail::assign_to_pointee<T4>(&t4),
|
||||
detail::assign_to_pointee<T5>(&t5),
|
||||
detail::assign_to_pointee<T6>(&t6),
|
||||
detail::assign_to_pointee<T7>(&t7),
|
||||
detail::assign_to_pointee<T8>(&t8));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4>,
|
||||
detail::assign_to_pointee<T5>,
|
||||
detail::assign_to_pointee<T6>,
|
||||
detail::assign_to_pointee<T7>,
|
||||
detail::assign_to_pointee<T8>,
|
||||
detail::assign_to_pointee<T9> >
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
|
||||
{
|
||||
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
||||
detail::assign_to_pointee<T2>(&t2),
|
||||
detail::assign_to_pointee<T3>(&t3),
|
||||
detail::assign_to_pointee<T4>(&t4),
|
||||
detail::assign_to_pointee<T5>(&t5),
|
||||
detail::assign_to_pointee<T6>(&t6),
|
||||
detail::assign_to_pointee<T7>(&t7),
|
||||
detail::assign_to_pointee<T8>(&t8),
|
||||
detail::assign_to_pointee<T9>(&t9));
|
||||
}
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
|
||||
inline
|
||||
tuple<detail::assign_to_pointee<T1>,
|
||||
detail::assign_to_pointee<T2>,
|
||||
detail::assign_to_pointee<T3>,
|
||||
detail::assign_to_pointee<T4>,
|
||||
detail::assign_to_pointee<T5>,
|
||||
detail::assign_to_pointee<T6>,
|
||||
detail::assign_to_pointee<T7>,
|
||||
detail::assign_to_pointee<T8>,
|
||||
detail::assign_to_pointee<T9>,
|
||||
detail::assign_to_pointee<T10> >
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10)
|
||||
{
|
||||
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
||||
detail::assign_to_pointee<T2>(&t2),
|
||||
detail::assign_to_pointee<T3>(&t3),
|
||||
detail::assign_to_pointee<T4>(&t4),
|
||||
detail::assign_to_pointee<T5>(&t5),
|
||||
detail::assign_to_pointee<T6>(&t6),
|
||||
detail::assign_to_pointee<T7>(&t7),
|
||||
detail::assign_to_pointee<T8>(&t8),
|
||||
detail::assign_to_pointee<T9>(&t9),
|
||||
detail::assign_to_pointee<T10>(&t10));
|
||||
}
|
||||
// "ignore" allows tuple positions to be ignored when using "tie".
|
||||
|
||||
detail::swallow_assign const ignore = detail::swallow_assign();
|
||||
|
||||
} // namespace tuples
|
||||
} // namespace boost
|
||||
#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
|
||||
@ -1,6 +1,6 @@
|
||||
// tuple.hpp - Boost Tuple Library --------------------------------------
|
||||
|
||||
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_TUPLE_HPP
|
||||
#define BOOST_TUPLE_HPP
|
||||
@ -20,22 +20,28 @@
|
||||
namespace boost { namespace python { class tuple; }}
|
||||
#endif
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include "boost/config.hpp"
|
||||
#include "boost/static_assert.hpp"
|
||||
|
||||
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
// The MSVC version
|
||||
#include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp"
|
||||
|
||||
#else
|
||||
// other compilers
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/tuple/detail/tuple_basic.hpp>
|
||||
#include "boost/ref.hpp"
|
||||
#include "boost/tuple/detail/tuple_basic.hpp"
|
||||
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
namespace boost {
|
||||
namespace boost {
|
||||
|
||||
using tuples::tuple;
|
||||
using tuples::make_tuple;
|
||||
using tuples::tie;
|
||||
#if !defined(BOOST_NO_USING_TEMPLATE)
|
||||
using tuples::get;
|
||||
#else
|
||||
#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
//
|
||||
// The "using tuples::get" statement causes the
|
||||
// Borland compiler to ICE, use forwarding
|
||||
@ -47,7 +53,7 @@ inline typename tuples::access_traits<
|
||||
>::non_const_type
|
||||
get(tuples::cons<HT, TT>& c) {
|
||||
return tuples::get<N,HT,TT>(c);
|
||||
}
|
||||
}
|
||||
// get function for const cons-lists, returns a const reference to
|
||||
// the element. If the element is a reference, returns the reference
|
||||
// as such (that is, can return a non-const reference)
|
||||
@ -58,61 +64,27 @@ inline typename tuples::access_traits<
|
||||
get(const tuples::cons<HT, TT>& c) {
|
||||
return tuples::get<N,HT,TT>(c);
|
||||
}
|
||||
#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
//
|
||||
// MSVC, using declarations don't mix with templates well,
|
||||
// so use forwarding functions instead:
|
||||
//
|
||||
template<int N, typename Head, typename Tail>
|
||||
typename tuples::detail::element_ref<N, tuples::cons<Head, Tail> >::RET
|
||||
get(tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
|
||||
{
|
||||
return tuples::detail::get_class<N>::get(t);
|
||||
}
|
||||
|
||||
template<int N, typename Head, typename Tail>
|
||||
typename tuples::detail::element_const_ref<N, tuples::cons<Head, Tail> >::RET
|
||||
get(const tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
|
||||
{
|
||||
return tuples::detail::get_class<N>::get(t);
|
||||
}
|
||||
#endif // BOOST_NO_USING_TEMPLATE
|
||||
|
||||
|
||||
} // end namespace boost
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
|
||||
|
||||
#include <tuple>
|
||||
#include <cstddef>
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
#if defined(BOOST_CLANG)
|
||||
# pragma clang diagnostic push
|
||||
# pragma clang diagnostic ignored "-Wmismatched-tags"
|
||||
#endif
|
||||
|
||||
// std::tuple_size
|
||||
|
||||
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
|
||||
class tuple_size< boost::tuples::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >:
|
||||
public boost::tuples::length< boost::tuples::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >
|
||||
{
|
||||
};
|
||||
|
||||
template<class H, class T> class tuple_size< boost::tuples::cons<H, T> >:
|
||||
public boost::tuples::length< boost::tuples::cons<H, T> >
|
||||
{
|
||||
};
|
||||
|
||||
template<> class tuple_size< boost::tuples::null_type >:
|
||||
public boost::tuples::length< boost::tuples::null_type >
|
||||
{
|
||||
};
|
||||
|
||||
// std::tuple_element
|
||||
|
||||
template<std::size_t I, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
|
||||
class tuple_element< I, boost::tuples::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >:
|
||||
public boost::tuples::element< I, boost::tuples::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >
|
||||
{
|
||||
};
|
||||
|
||||
template<std::size_t I, class H, class T> class tuple_element< I, boost::tuples::cons<H, T> >:
|
||||
public boost::tuples::element< I, boost::tuples::cons<H, T> >
|
||||
{
|
||||
};
|
||||
|
||||
#if defined(BOOST_CLANG)
|
||||
# pragma clang diagnostic pop
|
||||
#endif
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif // !defined(BOOST_NO_CXX11_HDR_TUPLE)
|
||||
|
||||
#endif // BOOST_TUPLE_HPP
|
||||
|
||||
@ -1,31 +1,31 @@
|
||||
// tuple_comparison.hpp -----------------------------------------------------
|
||||
//
|
||||
// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
//
|
||||
// Copyright (C) 2001 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
//
|
||||
// For more information, see http://www.boost.org
|
||||
//
|
||||
//
|
||||
// (The idea and first impl. of comparison operators was from Doug Gregor)
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_TUPLE_COMPARISON_HPP
|
||||
#define BOOST_TUPLE_COMPARISON_HPP
|
||||
|
||||
#include <boost/tuple/tuple.hpp>
|
||||
#include "boost/tuple/tuple.hpp"
|
||||
|
||||
// -------------------------------------------------------------
|
||||
// equality and comparison operators
|
||||
// equality and comparison operators
|
||||
//
|
||||
// == and != compare tuples elementwise
|
||||
// <, >, <= and >= use lexicographical ordering
|
||||
//
|
||||
// Any operator between tuples of different length fails at compile time
|
||||
// No dependencies between operators are assumed
|
||||
// No dependencies between operators are assumed
|
||||
// (i.e. !(a<b) does not imply a>=b, a!=b does not imply a==b etc.
|
||||
// so any weirdnesses of elementary operators are respected).
|
||||
//
|
||||
@ -46,7 +46,7 @@ inline bool operator>(const null_type&, const null_type&) { return false; }
|
||||
namespace detail {
|
||||
// comparison operators check statically the length of its operands and
|
||||
// delegate the comparing task to the following functions. Hence
|
||||
// the static check is only made once (should help the compiler).
|
||||
// the static check is only made once (should help the compiler).
|
||||
// These functions assume tuples to be of the same length.
|
||||
|
||||
|
||||
@ -69,8 +69,8 @@ inline bool neq<null_type,null_type>(const null_type&, const null_type&) { retur
|
||||
template<class T1, class T2>
|
||||
inline bool lt(const T1& lhs, const T2& rhs) {
|
||||
return lhs.get_head() < rhs.get_head() ||
|
||||
( !(rhs.get_head() < lhs.get_head()) &&
|
||||
lt(lhs.get_tail(), rhs.get_tail()));
|
||||
!(rhs.get_head() < lhs.get_head()) &&
|
||||
lt(lhs.get_tail(), rhs.get_tail());
|
||||
}
|
||||
template<>
|
||||
inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; }
|
||||
@ -78,8 +78,8 @@ inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return
|
||||
template<class T1, class T2>
|
||||
inline bool gt(const T1& lhs, const T2& rhs) {
|
||||
return lhs.get_head() > rhs.get_head() ||
|
||||
( !(rhs.get_head() > lhs.get_head()) &&
|
||||
gt(lhs.get_tail(), rhs.get_tail()));
|
||||
!(rhs.get_head() > lhs.get_head()) &&
|
||||
gt(lhs.get_tail(), rhs.get_tail());
|
||||
}
|
||||
template<>
|
||||
inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; }
|
||||
|
||||
@ -1,28 +1,39 @@
|
||||
// tuple_io.hpp --------------------------------------------------------------
|
||||
|
||||
// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2001 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
// 2001 Gary Powell (gary.powell@sierra.com)
|
||||
//
|
||||
// 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)
|
||||
// For more information, see http://www.boost.org
|
||||
// For more information, see http://www.boost.org
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_TUPLE_IO_HPP
|
||||
#define BOOST_TUPLE_IO_HPP
|
||||
|
||||
|
||||
// add to boost/config.hpp
|
||||
// for now
|
||||
# if defined __GNUC__
|
||||
# if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97)
|
||||
#define BOOST_NO_TEMPLATED_STREAMS
|
||||
#endif
|
||||
#endif // __GNUC__
|
||||
|
||||
#if defined BOOST_NO_TEMPLATED_STREAMS
|
||||
#include <iostream>
|
||||
#else
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
#endif
|
||||
|
||||
#include <sstream>
|
||||
|
||||
#include <boost/tuple/tuple.hpp>
|
||||
#include "boost/tuple/tuple.hpp"
|
||||
|
||||
// This is ugly: one should be using twoargument isspace since whitspace can
|
||||
// be locale dependent, in theory at least.
|
||||
// not all libraries implement have the two-arg version, so we need to
|
||||
// not all libraries implement have the two-arg version, so we need to
|
||||
// use the one-arg one, which one should get with <cctype> but there seem
|
||||
// to be exceptions to this.
|
||||
|
||||
@ -30,9 +41,9 @@
|
||||
|
||||
#include <locale> // for two-arg isspace
|
||||
|
||||
#else
|
||||
#else
|
||||
|
||||
#include <cctype> // for one-arg (old) isspace
|
||||
#include <cctype> // for one-arg (old) isspace
|
||||
#include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
|
||||
|
||||
#endif
|
||||
@ -43,12 +54,12 @@ namespace tuples {
|
||||
namespace detail {
|
||||
|
||||
class format_info {
|
||||
public:
|
||||
public:
|
||||
|
||||
enum manipulator_type { open, close, delimiter };
|
||||
BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1);
|
||||
private:
|
||||
|
||||
|
||||
static int get_stream_index (int m)
|
||||
{
|
||||
static const int stream_index[number_of_manipulators]
|
||||
@ -58,19 +69,38 @@ private:
|
||||
}
|
||||
|
||||
format_info(const format_info&);
|
||||
format_info();
|
||||
format_info();
|
||||
|
||||
|
||||
public:
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATED_STREAMS)
|
||||
static char get_manipulator(std::ios& i, manipulator_type m) {
|
||||
char c = static_cast<char>(i.iword(get_stream_index(m)));
|
||||
|
||||
// parentheses and space are the default manipulators
|
||||
if (!c) {
|
||||
switch(m) {
|
||||
case detail::format_info::open : c = '('; break;
|
||||
case detail::format_info::close : c = ')'; break;
|
||||
case detail::format_info::delimiter : c = ' '; break;
|
||||
}
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
static void set_manipulator(std::ios& i, manipulator_type m, char c) {
|
||||
i.iword(get_stream_index(m)) = static_cast<long>(c);
|
||||
}
|
||||
#else
|
||||
template<class CharType, class CharTrait>
|
||||
static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& i,
|
||||
static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& i,
|
||||
manipulator_type m) {
|
||||
// The manipulators are stored as long.
|
||||
// A valid instanitation of basic_stream allows CharType to be any POD,
|
||||
// hence, the static_cast may fail (it fails if long is not convertible
|
||||
// hence, the static_cast may fail (it fails if long is not convertible
|
||||
// to CharType
|
||||
CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) );
|
||||
CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) );
|
||||
// parentheses and space are the default manipulators
|
||||
if (!c) {
|
||||
switch(m) {
|
||||
@ -84,33 +114,61 @@ public:
|
||||
|
||||
|
||||
template<class CharType, class CharTrait>
|
||||
static void set_manipulator(std::basic_ios<CharType, CharTrait>& i,
|
||||
static void set_manipulator(std::basic_ios<CharType, CharTrait>& i,
|
||||
manipulator_type m, CharType c) {
|
||||
// The manipulators are stored as long.
|
||||
// A valid instanitation of basic_stream allows CharType to be any POD,
|
||||
// hence, the static_cast may fail (it fails if CharType is not
|
||||
// hence, the static_cast may fail (it fails if CharType is not
|
||||
// convertible long.
|
||||
i.iword(get_stream_index(m)) = static_cast<long>(c);
|
||||
}
|
||||
#endif // BOOST_NO_TEMPLATED_STREAMS
|
||||
};
|
||||
|
||||
} // end of namespace detail
|
||||
|
||||
template<class CharType>
|
||||
|
||||
template<class CharType>
|
||||
class tuple_manipulator {
|
||||
const detail::format_info::manipulator_type mt;
|
||||
CharType f_c;
|
||||
public:
|
||||
explicit tuple_manipulator(detail::format_info::manipulator_type m,
|
||||
CharType c = CharType())
|
||||
explicit tuple_manipulator(detail::format_info::manipulator_type m,
|
||||
const char c = 0)
|
||||
: mt(m), f_c(c) {}
|
||||
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATED_STREAMS)
|
||||
void set(std::ios &io) const {
|
||||
detail::format_info::set_manipulator(io, mt, f_c);
|
||||
}
|
||||
#else
|
||||
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
template<class CharType2, class CharTrait>
|
||||
void set(std::basic_ios<CharType2, CharTrait> &io) const {
|
||||
detail::format_info::set_manipulator(io, mt, f_c);
|
||||
}
|
||||
#else
|
||||
template<class CharTrait>
|
||||
void set(std::basic_ios<CharType, CharTrait> &io) const {
|
||||
detail::format_info::set_manipulator(io, mt, f_c);
|
||||
}
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
#endif // BOOST_NO_TEMPLATED_STREAMS
|
||||
};
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATED_STREAMS)
|
||||
inline std::ostream&
|
||||
operator<<(std::ostream& o, const tuple_manipulator<char>& m) {
|
||||
m.set(o);
|
||||
return o;
|
||||
}
|
||||
|
||||
inline std::istream&
|
||||
operator>>(std::istream& i, const tuple_manipulator<char>& m) {
|
||||
m.set(i);
|
||||
return i;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
template<class CharType, class CharTrait>
|
||||
inline std::basic_ostream<CharType, CharTrait>&
|
||||
@ -126,7 +184,8 @@ operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<C
|
||||
return i;
|
||||
}
|
||||
|
||||
|
||||
#endif // BOOST_NO_TEMPLATED_STREAMS
|
||||
|
||||
template<class CharType>
|
||||
inline tuple_manipulator<CharType> set_open(const CharType c) {
|
||||
return tuple_manipulator<CharType>(detail::format_info::open, c);
|
||||
@ -144,114 +203,229 @@ inline tuple_manipulator<CharType> set_delimiter(const CharType c) {
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// -------------------------------------------------------------
|
||||
// printing tuples to ostream in format (a b c)
|
||||
// parentheses and space are defaults, but can be overriden with manipulators
|
||||
// set_open, set_close and set_delimiter
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
// Note: The order of the print functions is critical
|
||||
// Note: The order of the print functions is critical
|
||||
// to let a conforming compiler find and select the correct one.
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATED_STREAMS)
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
template<class T1>
|
||||
inline std::ostream& print(std::ostream& o, const cons<T1, null_type>& t) {
|
||||
return o << t.head;
|
||||
}
|
||||
#endif // BOOST_NO_TEMPLATED_STREAMS
|
||||
|
||||
inline std::ostream& print(std::ostream& o, const null_type&) { return o; }
|
||||
|
||||
template<class T1, class T2>
|
||||
inline std::ostream&
|
||||
print(std::ostream& o, const cons<T1, T2>& t) {
|
||||
|
||||
const char d = format_info::get_manipulator(o, format_info::delimiter);
|
||||
|
||||
o << t.head;
|
||||
|
||||
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
if (tuples::length<T2>::value == 0)
|
||||
return o;
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
o << d;
|
||||
|
||||
return print(o, t.tail );
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
#else
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
template<class CharType, class CharTrait, class T1>
|
||||
inline std::basic_ostream<CharType, CharTrait>&
|
||||
inline std::basic_ostream<CharType, CharTrait>&
|
||||
print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, null_type>& t) {
|
||||
return o << t.head;
|
||||
}
|
||||
#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
|
||||
|
||||
template<class CharType, class CharTrait>
|
||||
inline std::basic_ostream<CharType, CharTrait>&
|
||||
print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) {
|
||||
return o;
|
||||
inline std::basic_ostream<CharType, CharTrait>&
|
||||
print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) {
|
||||
return o;
|
||||
}
|
||||
|
||||
template<class CharType, class CharTrait, class T1, class T2>
|
||||
inline std::basic_ostream<CharType, CharTrait>&
|
||||
inline std::basic_ostream<CharType, CharTrait>&
|
||||
print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
|
||||
|
||||
|
||||
const CharType d = format_info::get_manipulator(o, format_info::delimiter);
|
||||
|
||||
|
||||
o << t.head;
|
||||
|
||||
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
if (tuples::length<T2>::value == 0)
|
||||
return o;
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
o << d;
|
||||
|
||||
return print(o, t.tail);
|
||||
}
|
||||
|
||||
template<class CharT, class Traits, class T>
|
||||
inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) {
|
||||
std::streamsize width = o.width();
|
||||
if(width == 0) return false;
|
||||
|
||||
std::basic_ostringstream<CharT, Traits> ss;
|
||||
|
||||
ss.copyfmt(o);
|
||||
ss.tie(0);
|
||||
ss.width(0);
|
||||
|
||||
ss << t;
|
||||
o << ss.str();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif // BOOST_NO_TEMPLATED_STREAMS
|
||||
|
||||
} // namespace detail
|
||||
|
||||
|
||||
template<class CharType, class CharTrait>
|
||||
inline std::basic_ostream<CharType, CharTrait>&
|
||||
operator<<(std::basic_ostream<CharType, CharTrait>& o,
|
||||
const null_type& t) {
|
||||
#if defined (BOOST_NO_TEMPLATED_STREAMS)
|
||||
template<class T1, class T2>
|
||||
inline std::ostream& operator<<(std::ostream& o, const cons<T1, T2>& t) {
|
||||
if (!o.good() ) return o;
|
||||
if (detail::handle_width(o, t)) return o;
|
||||
|
||||
const CharType l =
|
||||
|
||||
const char l =
|
||||
detail::format_info::get_manipulator(o, detail::format_info::open);
|
||||
const CharType r =
|
||||
const char r =
|
||||
detail::format_info::get_manipulator(o, detail::format_info::close);
|
||||
|
||||
|
||||
o << l;
|
||||
|
||||
detail::print(o, t);
|
||||
|
||||
o << r;
|
||||
|
||||
return o;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
template<class CharType, class CharTrait, class T1, class T2>
|
||||
inline std::basic_ostream<CharType, CharTrait>&
|
||||
operator<<(std::basic_ostream<CharType, CharTrait>& o,
|
||||
inline std::basic_ostream<CharType, CharTrait>&
|
||||
operator<<(std::basic_ostream<CharType, CharTrait>& o,
|
||||
const cons<T1, T2>& t) {
|
||||
if (!o.good() ) return o;
|
||||
if (detail::handle_width(o, t)) return o;
|
||||
|
||||
const CharType l =
|
||||
|
||||
const CharType l =
|
||||
detail::format_info::get_manipulator(o, detail::format_info::open);
|
||||
const CharType r =
|
||||
const CharType r =
|
||||
detail::format_info::get_manipulator(o, detail::format_info::close);
|
||||
|
||||
o << l;
|
||||
|
||||
o << l;
|
||||
|
||||
detail::print(o, t);
|
||||
detail::print(o, t);
|
||||
|
||||
o << r;
|
||||
|
||||
return o;
|
||||
}
|
||||
#endif // BOOST_NO_TEMPLATED_STREAMS
|
||||
|
||||
|
||||
|
||||
// -------------------------------------------------------------
|
||||
// input stream operators
|
||||
|
||||
namespace detail {
|
||||
|
||||
#if defined (BOOST_NO_TEMPLATED_STREAMS)
|
||||
|
||||
inline std::istream&
|
||||
extract_and_check_delimiter(
|
||||
std::istream& is, format_info::manipulator_type del)
|
||||
{
|
||||
const char d = format_info::get_manipulator(is, del);
|
||||
|
||||
#if defined (BOOST_NO_STD_LOCALE)
|
||||
const bool is_delimiter = !isspace(d);
|
||||
#else
|
||||
const bool is_delimiter = (!std::isspace(d, is.getloc()) );
|
||||
#endif
|
||||
|
||||
char c;
|
||||
if (is_delimiter) {
|
||||
is >> c;
|
||||
if (is.good() && c!=d) {
|
||||
is.setstate(std::ios::failbit);
|
||||
}
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
|
||||
// Note: The order of the read functions is critical to let a
|
||||
// (conforming?) compiler find and select the correct one.
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
template<class T1>
|
||||
inline std::istream &
|
||||
read (std::istream &is, cons<T1, null_type>& t1) {
|
||||
|
||||
if (!is.good()) return is;
|
||||
|
||||
return is >> t1.head ;
|
||||
}
|
||||
#else
|
||||
inline std::istream& read(std::istream& i, const null_type&) { return i; }
|
||||
#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
template<class T1, class T2>
|
||||
inline std::istream&
|
||||
read(std::istream &is, cons<T1, T2>& t1) {
|
||||
|
||||
if (!is.good()) return is;
|
||||
|
||||
is >> t1.head;
|
||||
|
||||
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
if (tuples::length<T2>::value == 0)
|
||||
return is;
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
extract_and_check_delimiter(is, format_info::delimiter);
|
||||
|
||||
return read(is, t1.tail);
|
||||
}
|
||||
|
||||
} // end namespace detail
|
||||
|
||||
inline std::istream&
|
||||
operator>>(std::istream &is, null_type&) {
|
||||
|
||||
if (!is.good() ) return is;
|
||||
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::open);
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::close);
|
||||
|
||||
return is;
|
||||
}
|
||||
|
||||
|
||||
template<class T1, class T2>
|
||||
inline std::istream&
|
||||
operator>>(std::istream& is, cons<T1, T2>& t1) {
|
||||
|
||||
if (!is.good() ) return is;
|
||||
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::open);
|
||||
|
||||
detail::read(is, t1);
|
||||
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::close);
|
||||
|
||||
return is;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#else
|
||||
|
||||
template<class CharType, class CharTrait>
|
||||
inline std::basic_istream<CharType, CharTrait>&
|
||||
inline std::basic_istream<CharType, CharTrait>&
|
||||
extract_and_check_delimiter(
|
||||
std::basic_istream<CharType, CharTrait> &is, format_info::manipulator_type del)
|
||||
{
|
||||
@ -259,43 +433,52 @@ extract_and_check_delimiter(
|
||||
|
||||
#if defined (BOOST_NO_STD_LOCALE)
|
||||
const bool is_delimiter = !isspace(d);
|
||||
#elif defined ( BOOST_BORLANDC )
|
||||
#elif defined ( __BORLANDC__ )
|
||||
const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
|
||||
(is.getloc() ).is( std::ctype_base::space, d);
|
||||
#else
|
||||
const bool is_delimiter = (!std::isspace(d, is.getloc()) );
|
||||
const bool is_delimiter = (!std::isspace(d, is.getloc()) );
|
||||
#endif
|
||||
|
||||
CharType c;
|
||||
if (is_delimiter) {
|
||||
if (is_delimiter) {
|
||||
is >> c;
|
||||
if (is.good() && c!=d) {
|
||||
if (is.good() && c!=d) {
|
||||
is.setstate(std::ios::failbit);
|
||||
}
|
||||
} else {
|
||||
is >> std::ws;
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
template<class CharType, class CharTrait, class T1>
|
||||
inline std::basic_istream<CharType, CharTrait> &
|
||||
inline std::basic_istream<CharType, CharTrait> &
|
||||
read (std::basic_istream<CharType, CharTrait> &is, cons<T1, null_type>& t1) {
|
||||
|
||||
if (!is.good()) return is;
|
||||
|
||||
return is >> t1.head;
|
||||
if (!is.good()) return is;
|
||||
|
||||
return is >> t1.head;
|
||||
}
|
||||
#else
|
||||
template<class CharType, class CharTrait>
|
||||
inline std::basic_istream<CharType, CharTrait>&
|
||||
read(std::basic_istream<CharType, CharTrait>& i, const null_type&) { return i; }
|
||||
|
||||
#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
template<class CharType, class CharTrait, class T1, class T2>
|
||||
inline std::basic_istream<CharType, CharTrait>&
|
||||
inline std::basic_istream<CharType, CharTrait>&
|
||||
read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
|
||||
|
||||
if (!is.good()) return is;
|
||||
|
||||
|
||||
is >> t1.head;
|
||||
|
||||
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
if (tuples::length<T2>::value == 0)
|
||||
return is;
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
extract_and_check_delimiter(is, format_info::delimiter);
|
||||
|
||||
@ -306,7 +489,7 @@ read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
|
||||
|
||||
|
||||
template<class CharType, class CharTrait>
|
||||
inline std::basic_istream<CharType, CharTrait>&
|
||||
inline std::basic_istream<CharType, CharTrait>&
|
||||
operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {
|
||||
|
||||
if (!is.good() ) return is;
|
||||
@ -318,22 +501,25 @@ operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {
|
||||
}
|
||||
|
||||
template<class CharType, class CharTrait, class T1, class T2>
|
||||
inline std::basic_istream<CharType, CharTrait>&
|
||||
inline std::basic_istream<CharType, CharTrait>&
|
||||
operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
|
||||
|
||||
if (!is.good() ) return is;
|
||||
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::open);
|
||||
|
||||
|
||||
detail::read(is, t1);
|
||||
|
||||
|
||||
detail::extract_and_check_delimiter(is, detail::format_info::close);
|
||||
|
||||
return is;
|
||||
}
|
||||
|
||||
#endif // BOOST_NO_TEMPLATED_STREAMS
|
||||
|
||||
} // end of namespace tuples
|
||||
} // end of namespace boost
|
||||
|
||||
#endif // BOOST_TUPLE_IO_HPP
|
||||
|
||||
|
||||
|
||||
@ -1,9 +1,9 @@
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=doc/html/tuple_users_guide.html">
|
||||
<meta http-equiv="refresh" content="0; URL=doc/tuple_users_guide.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to <a href="doc/html/tuple_users_guide.html">doc/html/tuple_users_guide.html</a>
|
||||
Automatic redirection failed, please go to <a href="doc/tuple_users_guide.html">doc/tuple_users_guide.html</a>
|
||||
<hr>
|
||||
<p><EFBFBD> Copyright Beman Dawes, 2001</p>
|
||||
<p>Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
|
||||
@ -1,18 +0,0 @@
|
||||
{
|
||||
"key": "tuple",
|
||||
"name": "Tuple",
|
||||
"authors": [
|
||||
"Jaakko Järvi"
|
||||
],
|
||||
"description": "Ease definition of functions returning multiple values, and more.",
|
||||
"std": [
|
||||
"tr1"
|
||||
],
|
||||
"category": [
|
||||
"Data"
|
||||
],
|
||||
"maintainers": [
|
||||
"Jaakko Jarvi <jarvi -at- cs.tamu.edu>"
|
||||
],
|
||||
"cxxstd": "03"
|
||||
}
|
||||
@ -1,11 +1,8 @@
|
||||
# Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
project : requirements <library>/boost/test//boost_test_exec_monitor ;
|
||||
|
||||
test-suite tuple :
|
||||
[ run tuple_test_bench.cpp ]
|
||||
[ run io_test.cpp ]
|
||||
[ run another_tuple_test_bench.cpp ]
|
||||
[ run std_tuple_size.cpp ]
|
||||
[ run std_tuple_element.cpp ]
|
||||
[ run structured_bindings.cpp ]
|
||||
;
|
||||
;
|
||||
@ -1,4 +1,4 @@
|
||||
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
@ -15,13 +15,15 @@
|
||||
// Defining any of E1 to E5 or E7 to E11 opens some illegal code that
|
||||
// should cause the compliation to fail.
|
||||
|
||||
#include "boost/tuple/tuple.hpp"
|
||||
#define BOOST_INCLUDE_MAIN // for testing, include rather than link
|
||||
#include <boost/test/test_tools.hpp> // see "Header Implementation Option"
|
||||
|
||||
#include "boost/core/lightweight_test.hpp"
|
||||
#include "boost/tuple/tuple.hpp"
|
||||
|
||||
#include <string>
|
||||
#include <utility>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
using namespace boost::tuples;
|
||||
|
||||
@ -148,7 +150,7 @@ void foo7() {
|
||||
|
||||
// --------------------------------
|
||||
// ----------------------------
|
||||
int main() {
|
||||
int test_main(int, char *[]) {
|
||||
|
||||
foo1();
|
||||
foo2();
|
||||
@ -158,5 +160,5 @@ int main() {
|
||||
|
||||
foo7();
|
||||
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
@ -10,16 +10,16 @@
|
||||
//
|
||||
// Testing the I/O facilities of tuples
|
||||
|
||||
#define BOOST_INCLUDE_MAIN // for testing, include rather than link
|
||||
#include "boost/test/test_tools.hpp" // see "Header Implementation Option"
|
||||
|
||||
#include "boost/tuple/tuple_io.hpp"
|
||||
#include "boost/tuple/tuple_comparison.hpp"
|
||||
|
||||
#include "boost/core/lightweight_test.hpp"
|
||||
|
||||
#include <fstream>
|
||||
#include <iterator>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
#include <iomanip>
|
||||
|
||||
#if defined BOOST_NO_STRINGSTREAM
|
||||
#include <strstream>
|
||||
@ -27,19 +27,20 @@
|
||||
#include <sstream>
|
||||
#endif
|
||||
|
||||
#define BOOST_CHECK BOOST_TEST
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
#if defined BOOST_NO_STRINGSTREAM
|
||||
typedef std::ostrstream useThisOStringStream;
|
||||
typedef std::istrstream useThisIStringStream;
|
||||
typedef ostrstream useThisOStringStream;
|
||||
typedef istrstream useThisIStringStream;
|
||||
#else
|
||||
typedef std::ostringstream useThisOStringStream;
|
||||
typedef std::istringstream useThisIStringStream;
|
||||
typedef ostringstream useThisOStringStream;
|
||||
typedef istringstream useThisIStringStream;
|
||||
#endif
|
||||
|
||||
int main() {
|
||||
int test_main(int argc, char * argv[] ) {
|
||||
(void)argc;
|
||||
(void)argv;
|
||||
using boost::tuples::set_close;
|
||||
using boost::tuples::set_open;
|
||||
using boost::tuples::set_delimiter;
|
||||
@ -69,33 +70,19 @@ int main() {
|
||||
os1 << make_tuple(1, 2, 3);
|
||||
BOOST_CHECK (os1.str() == std::string("[1,2,3][1,2,3]") );
|
||||
|
||||
// check empty tuple.
|
||||
useThisOStringStream os3;
|
||||
os3 << make_tuple();
|
||||
BOOST_CHECK (os3.str() == std::string("()") );
|
||||
os3 << set_open('[');
|
||||
os3 << set_close(']');
|
||||
os3 << make_tuple();
|
||||
BOOST_CHECK (os3.str() == std::string("()[]") );
|
||||
|
||||
// check width
|
||||
useThisOStringStream os4;
|
||||
os4 << std::setw(10) << make_tuple(1, 2, 3);
|
||||
BOOST_CHECK (os4.str() == std::string(" (1 2 3)") );
|
||||
|
||||
std::ofstream tmp("temp.tmp");
|
||||
ofstream tmp("temp.tmp");
|
||||
|
||||
#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
tmp << make_tuple("One", "Two", 3);
|
||||
#endif
|
||||
tmp << set_delimiter(':');
|
||||
tmp << make_tuple(1000, 2000, 3000) << std::endl;
|
||||
tmp << make_tuple(1000, 2000, 3000) << endl;
|
||||
|
||||
tmp.close();
|
||||
|
||||
// When teading tuples from a stream, manipulators must be set correctly:
|
||||
std::ifstream tmp3("temp.tmp");
|
||||
tuple<std::string, std::string, int> j;
|
||||
ifstream tmp3("temp.tmp");
|
||||
tuple<string, string, int> j;
|
||||
|
||||
#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
tmp3 >> j;
|
||||
@ -111,31 +98,18 @@ int main() {
|
||||
|
||||
|
||||
// reading tuple<int, int, int> in format (a b c);
|
||||
useThisIStringStream is1("(100 200 300)");
|
||||
useThisIStringStream is("(100 200 300)");
|
||||
|
||||
tuple<int, int, int> ti1;
|
||||
BOOST_CHECK(bool(is1 >> ti1));
|
||||
BOOST_CHECK(ti1 == make_tuple(100, 200, 300));
|
||||
|
||||
useThisIStringStream is2("()");
|
||||
tuple<> ti2;
|
||||
BOOST_CHECK(bool(is2 >> ti2));
|
||||
useThisIStringStream is3("[]");
|
||||
is3 >> set_open('[');
|
||||
is3 >> set_close(']');
|
||||
BOOST_CHECK(bool(is3 >> ti2));
|
||||
|
||||
// Make sure that whitespace between elements
|
||||
// is skipped.
|
||||
useThisIStringStream is4("(100 200 300)");
|
||||
tuple<int, int, int> ti;
|
||||
BOOST_CHECK(bool(is >> ti));
|
||||
BOOST_CHECK(ti == make_tuple(100, 200, 300));
|
||||
|
||||
BOOST_CHECK(bool(is4 >> std::noskipws >> ti1));
|
||||
BOOST_CHECK(ti1 == make_tuple(100, 200, 300));
|
||||
|
||||
// Note that strings are problematic:
|
||||
// writing a tuple on a stream and reading it back doesn't work in
|
||||
// general. If this is wanted, some kind of a parseable string class
|
||||
// should be used.
|
||||
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -1,56 +0,0 @@
|
||||
// Copyright 2017 Peter Dimov.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
#include <boost/tuple/tuple.hpp>
|
||||
#include <boost/core/lightweight_test_trait.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
|
||||
#if defined(BOOST_NO_CXX11_HDR_TUPLE)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Skipping std::tuple_element tests for lack of <tuple>")
|
||||
int main() {}
|
||||
|
||||
#else
|
||||
|
||||
#include <tuple>
|
||||
|
||||
template<class Tp, std::size_t I, class E> void test()
|
||||
{
|
||||
BOOST_TEST_TRAIT_TRUE((boost::is_same<typename std::tuple_element<I, Tp>::type, E>));
|
||||
|
||||
typedef typename Tp::inherited Tp2;
|
||||
BOOST_TEST_TRAIT_TRUE((boost::is_same<typename std::tuple_element<I, Tp2>::type, E>));
|
||||
}
|
||||
|
||||
template<int> struct X
|
||||
{
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test<boost::tuple<X<0> const>, 0, X<0> const>();
|
||||
|
||||
test<boost::tuple<X<0> const, X<1> const>, 0, X<0> const>();
|
||||
test<boost::tuple<X<0> const, X<1> const>, 1, X<1> const>();
|
||||
|
||||
test<boost::tuple<X<0> const, X<1> const, X<2> const>, 0, X<0> const>();
|
||||
test<boost::tuple<X<0> const, X<1> const, X<2> const>, 1, X<1> const>();
|
||||
test<boost::tuple<X<0> const, X<1> const, X<2> const>, 2, X<2> const>();
|
||||
|
||||
test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const>, 0, X<0> const>();
|
||||
test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const>, 1, X<1> const>();
|
||||
test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const>, 2, X<2> const>();
|
||||
test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const>, 3, X<3> const>();
|
||||
|
||||
test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 0, X<0> const>();
|
||||
test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 1, X<1> const>();
|
||||
test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 2, X<2> const>();
|
||||
test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 3, X<3> const>();
|
||||
test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 4, X<4> const>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,61 +0,0 @@
|
||||
// Copyright 2017 Peter Dimov.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
#include <boost/tuple/tuple.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
|
||||
#if defined(BOOST_NO_CXX11_HDR_TUPLE)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Skipping std::tuple_size tests for lack of <tuple>")
|
||||
int main() {}
|
||||
|
||||
#else
|
||||
|
||||
#include <tuple>
|
||||
|
||||
template<class Tp> void test( std::size_t x )
|
||||
{
|
||||
BOOST_TEST_EQ( std::tuple_size< Tp >::value, x );
|
||||
BOOST_TEST_EQ( std::tuple_size< typename Tp::inherited >::value, x );
|
||||
}
|
||||
|
||||
struct V
|
||||
{
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
test< boost::tuple<> >( 0 );
|
||||
test< boost::tuple<V> >( 1 );
|
||||
test< boost::tuple<V, V> >( 2 );
|
||||
test< boost::tuple<V, V, V> >( 3 );
|
||||
test< boost::tuple<V, V, V, V> >( 4 );
|
||||
test< boost::tuple<V, V, V, V, V> >( 5 );
|
||||
test< boost::tuple<V, V, V, V, V, V> >( 6 );
|
||||
test< boost::tuple<V, V, V, V, V, V, V> >( 7 );
|
||||
test< boost::tuple<V, V, V, V, V, V, V, V> >( 8 );
|
||||
test< boost::tuple<V, V, V, V, V, V, V, V, V> >( 9 );
|
||||
test< boost::tuple<V, V, V, V, V, V, V, V, V, V> >( 10 );
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
|
||||
BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple())>::value, 0 );
|
||||
BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1))>::value, 1 );
|
||||
BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2))>::value, 2 );
|
||||
BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3))>::value, 3 );
|
||||
BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4))>::value, 4 );
|
||||
BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5))>::value, 5 );
|
||||
BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6))>::value, 6 );
|
||||
BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6, 7))>::value, 7 );
|
||||
BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6, 7, 8))>::value, 8 );
|
||||
BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6, 7, 8, 9))>::value, 9 );
|
||||
BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))>::value, 10 );
|
||||
|
||||
#endif
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,77 +0,0 @@
|
||||
// Copyright 2017 Peter Dimov.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
|
||||
#include <boost/tuple/tuple.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
|
||||
#if defined(BOOST_NO_CXX17_STRUCTURED_BINDINGS)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Skipping structured bindings test, not supported")
|
||||
int main() {}
|
||||
|
||||
#else
|
||||
|
||||
int main()
|
||||
{
|
||||
// make_tuple
|
||||
|
||||
{
|
||||
auto [x1] = boost::make_tuple( 1 );
|
||||
BOOST_TEST_EQ( x1, 1 );
|
||||
}
|
||||
|
||||
{
|
||||
auto [x1, x2] = boost::make_tuple( 1, 2 );
|
||||
BOOST_TEST_EQ( x1, 1 );
|
||||
BOOST_TEST_EQ( x2, 2 );
|
||||
}
|
||||
|
||||
{
|
||||
auto [x1, x2, x3] = boost::make_tuple( 1, 2, 3 );
|
||||
BOOST_TEST_EQ( x1, 1 );
|
||||
BOOST_TEST_EQ( x2, 2 );
|
||||
BOOST_TEST_EQ( x3, 3 );
|
||||
}
|
||||
|
||||
{
|
||||
auto [x1, x2, x3, x4] = boost::make_tuple( 1, 2, 3, 4 );
|
||||
BOOST_TEST_EQ( x1, 1 );
|
||||
BOOST_TEST_EQ( x2, 2 );
|
||||
BOOST_TEST_EQ( x3, 3 );
|
||||
BOOST_TEST_EQ( x4, 4 );
|
||||
}
|
||||
|
||||
// tuple
|
||||
|
||||
{
|
||||
auto [x1] = boost::tuple<int>( 1 );
|
||||
BOOST_TEST_EQ( x1, 1 );
|
||||
}
|
||||
|
||||
{
|
||||
auto [x1, x2] = boost::tuple<int, int>( 1, 2 );
|
||||
BOOST_TEST_EQ( x1, 1 );
|
||||
BOOST_TEST_EQ( x2, 2 );
|
||||
}
|
||||
|
||||
{
|
||||
auto [x1, x2, x3] = boost::tuple<int, int, int>( 1, 2, 3 );
|
||||
BOOST_TEST_EQ( x1, 1 );
|
||||
BOOST_TEST_EQ( x2, 2 );
|
||||
BOOST_TEST_EQ( x3, 3 );
|
||||
}
|
||||
|
||||
{
|
||||
auto [x1, x2, x3, x4] = boost::tuple<int, int, int, int>( 1, 2, 3, 4 );
|
||||
BOOST_TEST_EQ( x1, 1 );
|
||||
BOOST_TEST_EQ( x2, 2 );
|
||||
BOOST_TEST_EQ( x3, 3 );
|
||||
BOOST_TEST_EQ( x4, 4 );
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,4 +1,4 @@
|
||||
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
@ -8,18 +8,20 @@
|
||||
|
||||
// tuple_test_bench.cpp --------------------------------
|
||||
|
||||
#define BOOST_INCLUDE_MAIN // for testing, include rather than link
|
||||
#include <boost/test/test_tools.hpp> // see "Header Implementation Option"
|
||||
|
||||
#include "boost/tuple/tuple.hpp"
|
||||
|
||||
#include "boost/tuple/tuple_comparison.hpp"
|
||||
|
||||
#include "boost/type_traits/is_const.hpp"
|
||||
#include "boost/ref.hpp"
|
||||
#include "boost/core/lightweight_test.hpp"
|
||||
|
||||
#include "boost/ref.hpp"
|
||||
#include <string>
|
||||
#include <utility>
|
||||
|
||||
#define BOOST_CHECK BOOST_TEST
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
@ -81,7 +83,7 @@ typedef tuple<std::string, std::pair<A, B> > t4;
|
||||
typedef tuple<A*, tuple<const A*, const B&, C>, bool, void*> t5;
|
||||
typedef tuple<volatile int, const volatile char&, int(&)(float) > t6;
|
||||
|
||||
# if !defined(BOOST_BORLANDC) || BOOST_BORLANDC > 0x0551
|
||||
# if !defined(__BORLANDC__) || __BORLAND__ > 0x0551
|
||||
typedef tuple<B(A::*)(C&), A&> t7;
|
||||
#endif
|
||||
|
||||
@ -272,7 +274,7 @@ make_tuple_test()
|
||||
BOOST_CHECK(get<1>(t1) == 'a');
|
||||
|
||||
tuple<int, std::string> t2;
|
||||
t2 = boost::make_tuple((short int)2, std::string("Hi"));
|
||||
t2 = make_tuple((short int)2, std::string("Hi"));
|
||||
BOOST_CHECK(get<0>(t2) == 2);
|
||||
BOOST_CHECK(get<1>(t2) == "Hi");
|
||||
|
||||
@ -306,7 +308,7 @@ make_tuple_test()
|
||||
|
||||
// With function pointers, make_tuple works just fine
|
||||
|
||||
#if !defined(BOOST_BORLANDC) || BOOST_BORLANDC > 0x0551
|
||||
#if !defined(__BORLANDC__) || __BORLAND__ > 0x0551
|
||||
make_tuple(&make_tuple_test);
|
||||
#endif
|
||||
|
||||
@ -444,26 +446,6 @@ void tuple_length_test()
|
||||
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// - testing swap -----------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------
|
||||
void tuple_swap_test()
|
||||
{
|
||||
tuple<int, float, double> t1(1, 2.0f, 3.0), t2(4, 5.0f, 6.0);
|
||||
swap(t1, t2);
|
||||
BOOST_CHECK(get<0>(t1) == 4);
|
||||
BOOST_CHECK(get<1>(t1) == 5.0f);
|
||||
BOOST_CHECK(get<2>(t1) == 6.0);
|
||||
BOOST_CHECK(get<0>(t2) == 1);
|
||||
BOOST_CHECK(get<1>(t2) == 2.0f);
|
||||
BOOST_CHECK(get<2>(t2) == 3.0);
|
||||
|
||||
int i = 1,j = 2;
|
||||
boost::tuple<int&> t3(i), t4(j);
|
||||
swap(t3, t4);
|
||||
BOOST_CHECK(i == 2);
|
||||
BOOST_CHECK(j == 1);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -471,7 +453,7 @@ void tuple_swap_test()
|
||||
// - main ---------------------------------------------------------------------
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
int main() {
|
||||
int test_main(int, char *[]) {
|
||||
|
||||
construction_test();
|
||||
element_access_test();
|
||||
@ -484,7 +466,12 @@ int main() {
|
||||
cons_test();
|
||||
const_tuple_test();
|
||||
tuple_length_test();
|
||||
tuple_swap_test();
|
||||
|
||||
return boost::report_errors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user