mirror of
https://github.com/boostorg/array.git
synced 2025-06-25 20:11:45 +02:00
Compare commits
1 Commits
feature/re
...
boost-1.46
| Author | SHA1 | Date | |
|---|---|---|---|
| cd3f8508aa |
346
.drone.jsonnet
346
.drone.jsonnet
@ -1,346 +0,0 @@
|
||||
# Copyright 2022 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# https://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
local library = "array";
|
||||
|
||||
local triggers =
|
||||
{
|
||||
branch: [ "master", "develop", "feature/*" ]
|
||||
};
|
||||
|
||||
local ubsan = { UBSAN: '1', UBSAN_OPTIONS: 'print_stacktrace=1' };
|
||||
local asan = { ASAN: '1' };
|
||||
|
||||
local linux_pipeline(name, image, environment, packages = "", sources = [], arch = "amd64") =
|
||||
{
|
||||
name: name,
|
||||
kind: "pipeline",
|
||||
type: "docker",
|
||||
trigger: triggers,
|
||||
platform:
|
||||
{
|
||||
os: "linux",
|
||||
arch: arch
|
||||
},
|
||||
steps:
|
||||
[
|
||||
{
|
||||
name: "everything",
|
||||
image: image,
|
||||
environment: environment,
|
||||
commands:
|
||||
[
|
||||
'set -e',
|
||||
'uname -a',
|
||||
'echo $DRONE_STAGE_MACHINE',
|
||||
'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
|
||||
] +
|
||||
(if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
|
||||
(if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
|
||||
[
|
||||
'export LIBRARY=' + library,
|
||||
'./.drone/drone.sh',
|
||||
]
|
||||
}
|
||||
]
|
||||
};
|
||||
|
||||
local macos_pipeline(name, environment, xcode_version = "12.2", osx_version = "catalina", arch = "amd64") =
|
||||
{
|
||||
name: name,
|
||||
kind: "pipeline",
|
||||
type: "exec",
|
||||
trigger: triggers,
|
||||
platform: {
|
||||
"os": "darwin",
|
||||
"arch": arch
|
||||
},
|
||||
node: {
|
||||
"os": osx_version
|
||||
},
|
||||
steps: [
|
||||
{
|
||||
name: "everything",
|
||||
environment: environment + { "DEVELOPER_DIR": "/Applications/Xcode-" + xcode_version + ".app/Contents/Developer" },
|
||||
commands:
|
||||
[
|
||||
'export LIBRARY=' + library,
|
||||
'./.drone/drone.sh',
|
||||
]
|
||||
}
|
||||
]
|
||||
};
|
||||
|
||||
local windows_pipeline(name, image, environment, arch = "amd64") =
|
||||
{
|
||||
name: name,
|
||||
kind: "pipeline",
|
||||
type: "docker",
|
||||
trigger: triggers,
|
||||
platform:
|
||||
{
|
||||
os: "windows",
|
||||
arch: arch
|
||||
},
|
||||
"steps":
|
||||
[
|
||||
{
|
||||
name: "everything",
|
||||
image: image,
|
||||
environment: environment,
|
||||
commands:
|
||||
[
|
||||
'cmd /C .drone\\\\drone.bat ' + library,
|
||||
]
|
||||
}
|
||||
]
|
||||
};
|
||||
|
||||
[
|
||||
linux_pipeline(
|
||||
"Linux 16.04 GCC 4.6",
|
||||
"cppalliance/droneubuntu1604:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98' },
|
||||
"g++-4.6",
|
||||
[ "ppa:ubuntu-toolchain-r/test" ],
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 16.04 GCC 4.7",
|
||||
"cppalliance/droneubuntu1604:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98' },
|
||||
"g++-4.7",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 16.04 GCC 4.8",
|
||||
"cppalliance/droneubuntu1604:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++-4.8', CXXSTD: '03,11' },
|
||||
"g++-4.8",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 16.04 GCC 4.9",
|
||||
"cppalliance/droneubuntu1604:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11' },
|
||||
"g++-4.9",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 16.04 GCC 5*",
|
||||
"cppalliance/droneubuntu1604:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14' },
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 18.04 GCC 6",
|
||||
"cppalliance/droneubuntu1804:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '03,11,14' },
|
||||
"g++-6",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 18.04 GCC 7* 32/64",
|
||||
"cppalliance/droneubuntu1804:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 18.04 GCC 8",
|
||||
"cppalliance/droneubuntu1804:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '03,11,14,17' },
|
||||
"g++-8",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 20.04 GCC 9* 32/64",
|
||||
"cppalliance/droneubuntu2004:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 20.04 GCC 9* ARM64",
|
||||
"cppalliance/droneubuntu2004:multiarch",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
|
||||
arch="arm64",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 20.04 GCC 9* S390x",
|
||||
"cppalliance/droneubuntu2004:multiarch",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
|
||||
arch="s390x",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 20.04 GCC 10 32/64",
|
||||
"cppalliance/droneubuntu2004:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '32,64' },
|
||||
"g++-10-multilib",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 22.04 GCC 11* 32/64",
|
||||
"cppalliance/droneubuntu2204:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 22.04 GCC 12 32/64",
|
||||
"cppalliance/droneubuntu2204:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32,64' },
|
||||
"g++-12-multilib",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 24.04 GCC 13 32/64 UBSAN",
|
||||
"cppalliance/droneubuntu2404:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32,64' } + ubsan,
|
||||
"g++-13-multilib",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 24.04 GCC 14 32/64 ASAN",
|
||||
"cppalliance/droneubuntu2404:1",
|
||||
{ TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32,64' } + asan,
|
||||
"g++-14-multilib",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 16.04 Clang 3.5",
|
||||
"cppalliance/droneubuntu1604:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-3.5', CXXSTD: '03,11' },
|
||||
"clang-3.5",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 16.04 Clang 3.6",
|
||||
"cppalliance/droneubuntu1604:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-3.6', CXXSTD: '03,11,14' },
|
||||
"clang-3.6",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 16.04 Clang 3.7",
|
||||
"cppalliance/droneubuntu1604:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-3.7', CXXSTD: '03,11,14' },
|
||||
"clang-3.7",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 16.04 Clang 3.8",
|
||||
"cppalliance/droneubuntu1604:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-3.8', CXXSTD: '03,11,14' },
|
||||
"clang-3.8",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 22.04 Clang 13",
|
||||
"cppalliance/droneubuntu2204:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20' },
|
||||
"clang-13",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 22.04 Clang 14",
|
||||
"cppalliance/droneubuntu2204:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20' },
|
||||
"clang-14",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 22.04 Clang 15",
|
||||
"cppalliance/droneubuntu2204:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '03,11,14,17,20,2b' },
|
||||
"clang-15",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 24.04 Clang 16",
|
||||
"cppalliance/droneubuntu2404:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '03,11,14,17,20,2b' },
|
||||
"clang-16",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 24.04 Clang 17 UBSAN",
|
||||
"cppalliance/droneubuntu2404:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
|
||||
"clang-17",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 24.04 Clang 17 ASAN",
|
||||
"cppalliance/droneubuntu2404:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '03,11,14,17,20,2b' } + asan,
|
||||
"clang-17",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 24.04 Clang 18 UBSAN",
|
||||
"cppalliance/droneubuntu2404:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
|
||||
"clang-18",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 24.04 Clang 18 ASAN",
|
||||
"cppalliance/droneubuntu2404:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '03,11,14,17,20,2b' } + asan,
|
||||
"clang-18",
|
||||
),
|
||||
|
||||
linux_pipeline(
|
||||
"Linux 24.10 Clang 19",
|
||||
"cppalliance/droneubuntu2410:1",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++-19', CXXSTD: '03,11,14,17,20,2b' },
|
||||
"clang-19",
|
||||
),
|
||||
|
||||
macos_pipeline(
|
||||
"MacOS 10.15 Xcode 12.2 UBSAN",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + ubsan,
|
||||
),
|
||||
|
||||
macos_pipeline(
|
||||
"MacOS 10.15 Xcode 12.2 ASAN",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + asan,
|
||||
),
|
||||
|
||||
macos_pipeline(
|
||||
"MacOS 12.4 Xcode 13.4.1 UBSAN",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
|
||||
xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
|
||||
),
|
||||
|
||||
macos_pipeline(
|
||||
"MacOS 12.4 Xcode 13.4.1 ASAN",
|
||||
{ TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,20,2b' } + asan,
|
||||
xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
|
||||
),
|
||||
|
||||
windows_pipeline(
|
||||
"Windows VS2015 msvc-14.0",
|
||||
"cppalliance/dronevs2015",
|
||||
{ TOOLSET: 'msvc-14.0', CXXSTD: '14,latest', B2_DONT_EMBED_MANIFEST: '1' },
|
||||
),
|
||||
|
||||
windows_pipeline(
|
||||
"Windows VS2017 msvc-14.1",
|
||||
"cppalliance/dronevs2017",
|
||||
{ TOOLSET: 'msvc-14.1', CXXSTD: '14,17,latest' },
|
||||
),
|
||||
|
||||
windows_pipeline(
|
||||
"Windows VS2019 msvc-14.2",
|
||||
"cppalliance/dronevs2019",
|
||||
{ TOOLSET: 'msvc-14.2', CXXSTD: '14,17,20,latest' },
|
||||
),
|
||||
|
||||
windows_pipeline(
|
||||
"Windows VS2022 msvc-14.3",
|
||||
"cppalliance/dronevs2022:1",
|
||||
{ TOOLSET: 'msvc-14.3', CXXSTD: '14,17,20,latest' },
|
||||
),
|
||||
]
|
||||
@ -1,23 +0,0 @@
|
||||
@REM Copyright 2022 Peter Dimov
|
||||
@REM Distributed under the Boost Software License, Version 1.0.
|
||||
@REM https://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
@ECHO ON
|
||||
|
||||
set LIBRARY=%1
|
||||
set DRONE_BUILD_DIR=%CD%
|
||||
|
||||
set BOOST_BRANCH=develop
|
||||
if "%DRONE_BRANCH%" == "master" set BOOST_BRANCH=master
|
||||
cd ..
|
||||
git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
git submodule update --init tools/boostdep
|
||||
xcopy /s /e /q %DRONE_BUILD_DIR% libs\%LIBRARY%\
|
||||
python tools/boostdep/depinst/depinst.py %LIBRARY%
|
||||
cmd /c bootstrap
|
||||
b2 -d0 headers
|
||||
|
||||
if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
|
||||
if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
|
||||
b2 -j3 libs/%LIBRARY%/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
|
||||
@ -1,25 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
# Copyright 2022 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# https://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
set -ex
|
||||
export PATH=~/.local/bin:/usr/local/bin:$PATH
|
||||
|
||||
DRONE_BUILD_DIR=$(pwd)
|
||||
|
||||
BOOST_BRANCH=develop
|
||||
if [ "$DRONE_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
|
||||
|
||||
cd ..
|
||||
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
git submodule update --init tools/boostdep
|
||||
cp -r $DRONE_BUILD_DIR/* libs/$LIBRARY
|
||||
python tools/boostdep/depinst/depinst.py $LIBRARY
|
||||
./bootstrap.sh
|
||||
./b2 -d0 headers
|
||||
|
||||
echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
|
||||
./b2 -j3 libs/$LIBRARY/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${ADDRMD:+address-model=$ADDRMD} ${UBSAN:+undefined-sanitizer=norecover debug-symbols=on} ${ASAN:+address-sanitizer=norecover debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
|
||||
643
.github/workflows/ci.yml
vendored
643
.github/workflows/ci.yml
vendored
@ -1,643 +0,0 @@
|
||||
name: CI
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
push:
|
||||
branches:
|
||||
- master
|
||||
- develop
|
||||
- feature/**
|
||||
|
||||
env:
|
||||
UBSAN_OPTIONS: print_stacktrace=1
|
||||
|
||||
jobs:
|
||||
posix:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- toolset: gcc-4.8
|
||||
cxxstd: "03,11"
|
||||
os: ubuntu-latest
|
||||
container: ubuntu:18.04
|
||||
install: g++-4.8-multilib
|
||||
address-model: 32,64
|
||||
- toolset: gcc-4.9
|
||||
cxxstd: "03,11"
|
||||
os: ubuntu-latest
|
||||
container: ubuntu:16.04
|
||||
install: g++-4.9-multilib
|
||||
address-model: 32,64
|
||||
- toolset: gcc-5
|
||||
cxxstd: "03,11,14,1z"
|
||||
os: ubuntu-latest
|
||||
container: ubuntu:18.04
|
||||
install: g++-5-multilib
|
||||
address-model: 32,64
|
||||
- toolset: gcc-6
|
||||
cxxstd: "03,11,14,1z"
|
||||
os: ubuntu-latest
|
||||
container: ubuntu:18.04
|
||||
install: g++-6-multilib
|
||||
address-model: 32,64
|
||||
- toolset: gcc-7
|
||||
cxxstd: "03,11,14,17"
|
||||
os: ubuntu-20.04
|
||||
install: g++-7-multilib
|
||||
address-model: 32,64
|
||||
- toolset: gcc-8
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-20.04
|
||||
install: g++-8-multilib
|
||||
address-model: 32,64
|
||||
- toolset: gcc-9
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-20.04
|
||||
install: g++-9-multilib
|
||||
address-model: 32,64
|
||||
- toolset: gcc-10
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-22.04
|
||||
install: g++-10-multilib
|
||||
address-model: 32,64
|
||||
- toolset: gcc-11
|
||||
cxxstd: "03,11,14,17,20"
|
||||
os: ubuntu-22.04
|
||||
install: g++-11-multilib
|
||||
address-model: 32,64
|
||||
- toolset: gcc-12
|
||||
cxxstd: "03,11,14,17,20,2b"
|
||||
os: ubuntu-22.04
|
||||
install: g++-12-multilib
|
||||
address-model: 32,64
|
||||
- toolset: gcc-13
|
||||
cxxstd: "03,11,14,17,20,2b"
|
||||
os: ubuntu-24.04
|
||||
install: g++-13-multilib
|
||||
address-model: 32,64
|
||||
- toolset: gcc-14
|
||||
cxxstd: "03,11,14,17,20,2b"
|
||||
os: ubuntu-24.04
|
||||
install: g++-14-multilib
|
||||
address-model: 32,64
|
||||
- toolset: clang
|
||||
compiler: clang++-3.9
|
||||
cxxstd: "03,11,14"
|
||||
os: ubuntu-latest
|
||||
container: ubuntu:18.04
|
||||
install: clang-3.9
|
||||
- toolset: clang
|
||||
compiler: clang++-4.0
|
||||
cxxstd: "03,11,14"
|
||||
os: ubuntu-latest
|
||||
container: ubuntu:18.04
|
||||
install: clang-4.0
|
||||
- toolset: clang
|
||||
compiler: clang++-5.0
|
||||
cxxstd: "03,11,14,1z"
|
||||
os: ubuntu-latest
|
||||
container: ubuntu:18.04
|
||||
install: clang-5.0
|
||||
- toolset: clang
|
||||
compiler: clang++-6.0
|
||||
cxxstd: "03,11,14,17"
|
||||
os: ubuntu-20.04
|
||||
install: clang-6.0
|
||||
- toolset: clang
|
||||
compiler: clang++-7
|
||||
cxxstd: "03,11,14,17"
|
||||
os: ubuntu-20.04
|
||||
install: clang-7
|
||||
- toolset: clang
|
||||
compiler: clang++-8
|
||||
cxxstd: "03,11,14,17"
|
||||
os: ubuntu-20.04
|
||||
install: clang-8
|
||||
- toolset: clang
|
||||
compiler: clang++-9
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-20.04
|
||||
install: clang-9
|
||||
- toolset: clang
|
||||
compiler: clang++-10
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-20.04
|
||||
- toolset: clang
|
||||
compiler: clang++-11
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
os: ubuntu-20.04
|
||||
- toolset: clang
|
||||
compiler: clang++-12
|
||||
cxxstd: "03,11,14,17,20"
|
||||
os: ubuntu-20.04
|
||||
- toolset: clang
|
||||
compiler: clang++-13
|
||||
cxxstd: "03,11,14,17,20,2b"
|
||||
os: ubuntu-22.04
|
||||
install: clang-13
|
||||
- toolset: clang
|
||||
compiler: clang++-14
|
||||
cxxstd: "03,11,14,17,20,2b"
|
||||
os: ubuntu-22.04
|
||||
install: clang-14
|
||||
- toolset: clang
|
||||
compiler: clang++-15
|
||||
cxxstd: "03,11,14,17,20,2b"
|
||||
os: ubuntu-22.04
|
||||
install: clang-15
|
||||
- toolset: clang
|
||||
compiler: clang++-16
|
||||
cxxstd: "03,11,14,17,20,2b"
|
||||
os: ubuntu-24.04
|
||||
install: clang-16
|
||||
- toolset: clang
|
||||
compiler: clang++-17
|
||||
cxxstd: "03,11,14,17,20,2b"
|
||||
os: ubuntu-24.04
|
||||
install: clang-17
|
||||
- toolset: clang
|
||||
compiler: clang++-18
|
||||
cxxstd: "03,11,14,17,20,2b"
|
||||
os: ubuntu-24.04
|
||||
install: clang-18
|
||||
- toolset: clang
|
||||
cxxstd: "03,11,14,17,20,2b"
|
||||
os: macos-13
|
||||
- toolset: clang
|
||||
cxxstd: "03,11,14,17,20,2b"
|
||||
os: macos-14
|
||||
- toolset: clang
|
||||
cxxstd: "03,11,14,17,20,2b"
|
||||
os: macos-15
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
container:
|
||||
image: ${{matrix.container}}
|
||||
volumes:
|
||||
- /node20217:/node20217:rw,rshared
|
||||
- ${{ startsWith(matrix.container, 'ubuntu:1') && '/node20217:/__e/node20:ro,rshared' || ' ' }}
|
||||
|
||||
defaults:
|
||||
run:
|
||||
shell: bash
|
||||
|
||||
steps:
|
||||
- name: Setup container environment
|
||||
if: matrix.container
|
||||
run: |
|
||||
apt-get update
|
||||
apt-get -y install sudo python3 git g++ curl xz-utils
|
||||
|
||||
- name: Install nodejs20glibc2.17
|
||||
if: ${{ startsWith( matrix.container, 'ubuntu:1' ) }}
|
||||
run: |
|
||||
curl -LO https://archives.boost.io/misc/node/node-v20.9.0-linux-x64-glibc-217.tar.xz
|
||||
tar -xf node-v20.9.0-linux-x64-glibc-217.tar.xz --strip-components 1 -C /node20217
|
||||
ldd /__e/node20/bin/node
|
||||
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install packages
|
||||
if: matrix.install
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get -y install ${{matrix.install}}
|
||||
|
||||
- name: Setup Boost
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
|
||||
LIBRARY=${GITHUB_REPOSITORY#*/}
|
||||
echo LIBRARY: $LIBRARY
|
||||
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
|
||||
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
|
||||
echo GITHUB_REF: $GITHUB_REF
|
||||
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
|
||||
REF=${REF#refs/heads/}
|
||||
echo REF: $REF
|
||||
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
|
||||
echo BOOST_BRANCH: $BOOST_BRANCH
|
||||
cd ..
|
||||
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
|
||||
git submodule update --init tools/boostdep
|
||||
python3 tools/boostdep/depinst/depinst.py -I examples $LIBRARY
|
||||
./bootstrap.sh
|
||||
./b2 -d0 headers
|
||||
|
||||
- name: Create user-config.jam
|
||||
if: matrix.compiler
|
||||
run: |
|
||||
echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
|
||||
|
||||
- name: Run tests
|
||||
run: |
|
||||
cd ../boost-root
|
||||
export ADDRMD=${{matrix.address-model}}
|
||||
./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} variant=debug,release
|
||||
|
||||
windows:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- toolset: msvc-14.0
|
||||
cxxstd: 14,latest
|
||||
addrmd: 32,64
|
||||
os: windows-2019
|
||||
- toolset: msvc-14.2
|
||||
cxxstd: "14,17,20,latest"
|
||||
addrmd: 32,64
|
||||
os: windows-2019
|
||||
- toolset: msvc-14.3
|
||||
cxxstd: "14,17,20,latest"
|
||||
addrmd: 32,64
|
||||
os: windows-2022
|
||||
- toolset: clang-win
|
||||
cxxstd: "14,17,latest"
|
||||
addrmd: 32,64
|
||||
os: windows-2022
|
||||
- toolset: gcc
|
||||
cxxstd: "03,11,14,17,2a"
|
||||
addrmd: 64
|
||||
os: windows-2019
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Setup Boost
|
||||
shell: cmd
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
|
||||
for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
|
||||
echo LIBRARY: %LIBRARY%
|
||||
echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
|
||||
echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
|
||||
echo GITHUB_REF: %GITHUB_REF%
|
||||
if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
|
||||
set BOOST_BRANCH=develop
|
||||
for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
|
||||
echo BOOST_BRANCH: %BOOST_BRANCH%
|
||||
cd ..
|
||||
git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
|
||||
git submodule update --init tools/boostdep
|
||||
python tools/boostdep/depinst/depinst.py -I examples --git_args "--jobs 3" %LIBRARY%
|
||||
cmd /c bootstrap
|
||||
b2 -d0 headers
|
||||
|
||||
- name: Run tests
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root
|
||||
b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release embed-manifest-via=linker
|
||||
|
||||
posix-cmake-subdir:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- os: ubuntu-20.04
|
||||
- os: ubuntu-22.04
|
||||
- os: ubuntu-24.04
|
||||
- os: macos-13
|
||||
- os: macos-14
|
||||
- os: macos-15
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install packages
|
||||
if: matrix.install
|
||||
run: sudo apt-get -y install ${{matrix.install}}
|
||||
|
||||
- name: Setup Boost
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
|
||||
LIBRARY=${GITHUB_REPOSITORY#*/}
|
||||
echo LIBRARY: $LIBRARY
|
||||
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
|
||||
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
|
||||
echo GITHUB_REF: $GITHUB_REF
|
||||
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
|
||||
REF=${REF#refs/heads/}
|
||||
echo REF: $REF
|
||||
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
|
||||
echo BOOST_BRANCH: $BOOST_BRANCH
|
||||
cd ..
|
||||
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
|
||||
git submodule update --init tools/boostdep
|
||||
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
|
||||
|
||||
- name: Use library with add_subdirectory
|
||||
run: |
|
||||
cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
|
||||
mkdir __build__ && cd __build__
|
||||
cmake ..
|
||||
cmake --build .
|
||||
ctest --output-on-failure --no-tests=error
|
||||
|
||||
posix-cmake-install:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- os: ubuntu-20.04
|
||||
- os: ubuntu-22.04
|
||||
- os: ubuntu-24.04
|
||||
- os: macos-13
|
||||
- os: macos-14
|
||||
- os: macos-15
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install packages
|
||||
if: matrix.install
|
||||
run: sudo apt-get -y install ${{matrix.install}}
|
||||
|
||||
- name: Setup Boost
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
|
||||
LIBRARY=${GITHUB_REPOSITORY#*/}
|
||||
echo LIBRARY: $LIBRARY
|
||||
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
|
||||
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
|
||||
echo GITHUB_REF: $GITHUB_REF
|
||||
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
|
||||
REF=${REF#refs/heads/}
|
||||
echo REF: $REF
|
||||
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
|
||||
echo BOOST_BRANCH: $BOOST_BRANCH
|
||||
cd ..
|
||||
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
|
||||
git submodule update --init tools/boostdep
|
||||
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
|
||||
|
||||
- name: Configure
|
||||
run: |
|
||||
cd ../boost-root
|
||||
mkdir __build__ && cd __build__
|
||||
cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
|
||||
|
||||
- name: Install
|
||||
run: |
|
||||
cd ../boost-root/__build__
|
||||
cmake --build . --target install
|
||||
|
||||
- name: Use the installed library
|
||||
run: |
|
||||
cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
|
||||
cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
|
||||
cmake --build .
|
||||
ctest --output-on-failure --no-tests=error
|
||||
|
||||
posix-cmake-test:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- os: ubuntu-20.04
|
||||
- os: ubuntu-22.04
|
||||
- os: ubuntu-24.04
|
||||
- os: macos-13
|
||||
- os: macos-14
|
||||
- os: macos-15
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install packages
|
||||
if: matrix.install
|
||||
run: sudo apt-get -y install ${{matrix.install}}
|
||||
|
||||
- name: Setup Boost
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
|
||||
LIBRARY=${GITHUB_REPOSITORY#*/}
|
||||
echo LIBRARY: $LIBRARY
|
||||
echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
|
||||
echo GITHUB_BASE_REF: $GITHUB_BASE_REF
|
||||
echo GITHUB_REF: $GITHUB_REF
|
||||
REF=${GITHUB_BASE_REF:-$GITHUB_REF}
|
||||
REF=${REF#refs/heads/}
|
||||
echo REF: $REF
|
||||
BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
|
||||
echo BOOST_BRANCH: $BOOST_BRANCH
|
||||
cd ..
|
||||
git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
|
||||
git submodule update --init tools/boostdep
|
||||
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
|
||||
|
||||
- name: Configure
|
||||
run: |
|
||||
cd ../boost-root
|
||||
mkdir __build__ && cd __build__
|
||||
cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
|
||||
|
||||
- name: Build tests
|
||||
run: |
|
||||
cd ../boost-root/__build__
|
||||
cmake --build . --target tests
|
||||
|
||||
- name: Run tests
|
||||
run: |
|
||||
cd ../boost-root/__build__
|
||||
ctest --output-on-failure --no-tests=error
|
||||
|
||||
windows-cmake-subdir:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- os: windows-2019
|
||||
- os: windows-2022
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Setup Boost
|
||||
shell: cmd
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
|
||||
for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
|
||||
echo LIBRARY: %LIBRARY%
|
||||
echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
|
||||
echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
|
||||
echo GITHUB_REF: %GITHUB_REF%
|
||||
if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
|
||||
set BOOST_BRANCH=develop
|
||||
for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
|
||||
echo BOOST_BRANCH: %BOOST_BRANCH%
|
||||
cd ..
|
||||
git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
|
||||
git submodule update --init tools/boostdep
|
||||
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
|
||||
|
||||
- name: Use library with add_subdirectory (Debug)
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test
|
||||
mkdir __build__ && cd __build__
|
||||
cmake ..
|
||||
cmake --build . --config Debug
|
||||
ctest --output-on-failure --no-tests=error -C Debug
|
||||
|
||||
- name: Use library with add_subdirectory (Release)
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
|
||||
cmake --build . --config Release
|
||||
ctest --output-on-failure --no-tests=error -C Release
|
||||
|
||||
windows-cmake-install:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- os: windows-2019
|
||||
- os: windows-2022
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Setup Boost
|
||||
shell: cmd
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
|
||||
for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
|
||||
echo LIBRARY: %LIBRARY%
|
||||
echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
|
||||
echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
|
||||
echo GITHUB_REF: %GITHUB_REF%
|
||||
if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
|
||||
set BOOST_BRANCH=develop
|
||||
for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
|
||||
echo BOOST_BRANCH: %BOOST_BRANCH%
|
||||
cd ..
|
||||
git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
|
||||
git submodule update --init tools/boostdep
|
||||
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
|
||||
|
||||
- name: Configure
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root
|
||||
mkdir __build__ && cd __build__
|
||||
cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
|
||||
|
||||
- name: Install (Debug)
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root/__build__
|
||||
cmake --build . --target install --config Debug
|
||||
|
||||
- name: Install (Release)
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root/__build__
|
||||
cmake --build . --target install --config Release
|
||||
|
||||
- name: Use the installed library (Debug)
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
|
||||
cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
|
||||
cmake --build . --config Debug
|
||||
ctest --output-on-failure --no-tests=error -C Debug
|
||||
|
||||
- name: Use the installed library (Release)
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
|
||||
cmake --build . --config Release
|
||||
ctest --output-on-failure --no-tests=error -C Release
|
||||
|
||||
windows-cmake-test:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- os: windows-2019
|
||||
- os: windows-2022
|
||||
|
||||
runs-on: ${{matrix.os}}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Setup Boost
|
||||
shell: cmd
|
||||
run: |
|
||||
echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
|
||||
for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
|
||||
echo LIBRARY: %LIBRARY%
|
||||
echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
|
||||
echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
|
||||
echo GITHUB_REF: %GITHUB_REF%
|
||||
if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
|
||||
set BOOST_BRANCH=develop
|
||||
for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
|
||||
echo BOOST_BRANCH: %BOOST_BRANCH%
|
||||
cd ..
|
||||
git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
cd boost-root
|
||||
xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
|
||||
git submodule update --init tools/boostdep
|
||||
python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
|
||||
|
||||
- name: Configure
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root
|
||||
mkdir __build__ && cd __build__
|
||||
cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DBUILD_TESTING=ON ..
|
||||
|
||||
- name: Build tests (Debug)
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root/__build__
|
||||
cmake --build . --target tests --config Debug
|
||||
|
||||
- name: Run tests (Debug)
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root/__build__
|
||||
ctest --output-on-failure --no-tests=error -C Debug
|
||||
|
||||
- name: Build tests (Release)
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root/__build__
|
||||
cmake --build . --target tests --config Release
|
||||
|
||||
- name: Run tests (Release)
|
||||
shell: cmd
|
||||
run: |
|
||||
cd ../boost-root/__build__
|
||||
ctest --output-on-failure --no-tests=error -C Release
|
||||
217
.travis.yml
217
.travis.yml
@ -1,217 +0,0 @@
|
||||
# Copyright 2016, 2017 Peter Dimov
|
||||
# Copyright 2018, Mike-Dev
|
||||
# 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:
|
||||
|
||||
# cmake self-test
|
||||
- os: linux
|
||||
env: TEST_CMAKE=TRUE #Only for easier identification in travis web gui
|
||||
install:
|
||||
- BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
|
||||
- git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/assert.git ../assert
|
||||
- git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/config.git ../config
|
||||
- git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/core.git ../core
|
||||
- git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/static_assert.git ../static_assert
|
||||
- git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/throw_exception.git ../throw_exception
|
||||
|
||||
script:
|
||||
- mkdir __build__ && cd __build__
|
||||
- cmake ../test/test_cmake
|
||||
- cmake --build .
|
||||
|
||||
- os: linux
|
||||
compiler: g++
|
||||
env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
|
||||
|
||||
- os: linux
|
||||
compiler: g++-4.7
|
||||
env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
compiler: g++-4.8
|
||||
env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.8
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- os: linux
|
||||
compiler: g++-4.9
|
||||
env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- g++-4.9
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
|
||||
- os: linux
|
||||
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
|
||||
dist: trusty
|
||||
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++-3.5
|
||||
env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.5
|
||||
- libstdc++-4.9-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.5
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.6
|
||||
env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.6
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.6
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.7
|
||||
env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.7
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.7
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.8
|
||||
env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.8
|
||||
- libstdc++-4.9-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.8
|
||||
|
||||
- os: linux
|
||||
compiler: clang++-3.9
|
||||
env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
|
||||
addons:
|
||||
apt:
|
||||
packages:
|
||||
- clang-3.9
|
||||
- libstdc++-4.9-dev
|
||||
sources:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.9
|
||||
|
||||
- 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 --depth 1 https://github.com/boostorg/boost.git boost-root
|
||||
- cd boost-root
|
||||
- git submodule update --init tools/build
|
||||
- git submodule update --init libs/config
|
||||
- git submodule update --init tools/boostdep
|
||||
- cp -r $TRAVIS_BUILD_DIR/* libs/array
|
||||
- python tools/boostdep/depinst/depinst.py array
|
||||
- ./bootstrap.sh
|
||||
- ./b2 headers
|
||||
|
||||
script:
|
||||
- |-
|
||||
echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
|
||||
- ./b2 -j 3 libs/array/test toolset=$TOOLSET cxxstd=$CXXSTD
|
||||
|
||||
notifications:
|
||||
email:
|
||||
on_success: always
|
||||
@ -1,28 +0,0 @@
|
||||
# Generated by `boostdep --cmake array`
|
||||
# Copyright 2020, 2021 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# https://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
cmake_minimum_required(VERSION 3.5...3.20)
|
||||
|
||||
project(boost_array VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
|
||||
|
||||
add_library(boost_array INTERFACE)
|
||||
add_library(Boost::array ALIAS boost_array)
|
||||
|
||||
target_include_directories(boost_array INTERFACE include)
|
||||
|
||||
target_link_libraries(boost_array
|
||||
INTERFACE
|
||||
Boost::assert
|
||||
Boost::config
|
||||
Boost::core
|
||||
Boost::static_assert
|
||||
Boost::throw_exception
|
||||
)
|
||||
|
||||
if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
|
||||
|
||||
add_subdirectory(test)
|
||||
|
||||
endif()
|
||||
1
doc/.gitignore
vendored
1
doc/.gitignore
vendored
@ -1 +0,0 @@
|
||||
/html
|
||||
@ -1,22 +0,0 @@
|
||||
#~ Copyright Marshall Clow 2013
|
||||
#~ Copyright Christian Mazakas 2024
|
||||
#~ Distributed under the Boost Software License, Version 1.0.
|
||||
#~ (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
import asciidoctor ;
|
||||
|
||||
html array.html : array.adoc ;
|
||||
|
||||
install html_ : array.html : <location>html ;
|
||||
|
||||
pdf array.pdf : array.adoc ;
|
||||
explicit array.pdf ;
|
||||
|
||||
install pdf_ : array.pdf : <location>pdf ;
|
||||
explicit pdf_ ;
|
||||
|
||||
###############################################################################
|
||||
alias boostdoc ;
|
||||
explicit boostdoc ;
|
||||
alias boostrelease : html_ ;
|
||||
explicit boostrelease ;
|
||||
@ -1,28 +0,0 @@
|
||||
////
|
||||
Copyright 2001-2004 Nicolai M. Josuttis
|
||||
Copyright 2012 Marshall Clow
|
||||
Copyright 2024 Christian Mazakas
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
https://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
# Boost.Array
|
||||
Nicolai M. Josuttis
|
||||
:toc: left
|
||||
:toclevels: 4
|
||||
:idprefix:
|
||||
:docinfo: private-footer
|
||||
:source-highlighter: rouge
|
||||
:source-language: c++
|
||||
:sectanchors:
|
||||
|
||||
:leveloffset: +1
|
||||
|
||||
include::array/introduction.adoc[]
|
||||
include::array/changes.adoc[]
|
||||
include::array/reference.adoc[]
|
||||
include::array/design_rationale.adoc[]
|
||||
include::array/information.adoc[]
|
||||
include::array/copyright.adoc[]
|
||||
|
||||
:leveloffset: -1
|
||||
546
doc/array.xml
Normal file
546
doc/array.xml
Normal file
@ -0,0 +1,546 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
|
||||
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
|
||||
<library name="Array" dirname="array" id="array" last-revision="$Date$">
|
||||
<libraryinfo>
|
||||
<author>
|
||||
<firstname>Nicolai</firstname>
|
||||
<surname>Josuttis</surname>
|
||||
</author>
|
||||
|
||||
<copyright>
|
||||
<year>2001</year>
|
||||
<year>2002</year>
|
||||
<year>2003</year>
|
||||
<year>2004</year>
|
||||
<holder>Nicolai M. Josuttis</holder>
|
||||
</copyright>
|
||||
|
||||
<legalnotice>
|
||||
<para>Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file <filename>LICENSE_1_0.txt</filename> or copy at
|
||||
<ulink
|
||||
url="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</ulink>)
|
||||
</para>
|
||||
</legalnotice>
|
||||
|
||||
<librarypurpose>STL compliant container wrapper for arrays of constant size</librarypurpose>
|
||||
<librarycategory name="category:containers"/>
|
||||
</libraryinfo>
|
||||
|
||||
<title>Boost.Array</title>
|
||||
|
||||
<section id="array.intro">
|
||||
<title>Introduction</title>
|
||||
|
||||
<using-namespace name="boost"/>
|
||||
<using-class name="array"/>
|
||||
|
||||
<para>The C++ Standard Template Library STL as part of the C++
|
||||
Standard Library provides a framework for processing algorithms on
|
||||
different kind of containers. However, ordinary arrays don't
|
||||
provide the interface of STL containers (although, they provide
|
||||
the iterator interface of STL containers).</para>
|
||||
|
||||
<para>As replacement for ordinary arrays, the STL provides class
|
||||
<code><classname>std::vector</classname></code>. However,
|
||||
<code><classname>std::vector<></classname></code> provides
|
||||
the semantics of dynamic arrays. Thus, it manages data to be able
|
||||
to change the number of elements. This results in some overhead in
|
||||
case only arrays with static size are needed.</para>
|
||||
|
||||
<para>In his book, <emphasis>Generic Programming and the
|
||||
STL</emphasis>, Matthew H. Austern introduces a useful wrapper
|
||||
class for ordinary arrays with static size, called
|
||||
<code>block</code>. It is safer and has no worse performance than
|
||||
ordinary arrays. In <emphasis>The C++ Programming
|
||||
Language</emphasis>, 3rd edition, Bjarne Stroustrup introduces a
|
||||
similar class, called <code>c_array</code>, which I (<ulink
|
||||
url="http://www.josuttis.com">Nicolai Josuttis</ulink>) present
|
||||
slightly modified in my book <emphasis>The C++ Standard Library -
|
||||
A Tutorial and Reference</emphasis>, called
|
||||
<code>carray</code>. This is the essence of these approaches
|
||||
spiced with many feedback from <ulink
|
||||
url="http://www.boost.org">boost</ulink>.</para>
|
||||
|
||||
<para>After considering different names, we decided to name this
|
||||
class simply <code><classname>array</classname></code>.</para>
|
||||
|
||||
<para>Note that this class is suggested to be part of the next
|
||||
Technical Report, which will extend the C++ Standard (see
|
||||
<ulink url="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1548.htm">http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1548.htm</ulink>).</para>
|
||||
|
||||
<para>Class <code><classname>array</classname></code> fulfills most
|
||||
but not all of the requirements of "reversible containers" (see
|
||||
Section 23.1, [lib.container.requirements] of the C++
|
||||
Standard). The reasons array is not an reversible STL container is
|
||||
because:
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><simpara>No constructors are provided.</simpara></listitem>
|
||||
<listitem><simpara>Elements may have an undetermined initial value (see <xref linkend="array.rationale"/>).</simpara></listitem>
|
||||
<listitem><simpara><functionname>swap</functionname>() has no constant complexity.</simpara></listitem>
|
||||
<listitem><simpara><methodname>size</methodname>() is always constant, based on the second template argument of the type.</simpara></listitem>
|
||||
<listitem><simpara>The container provides no allocator support.</simpara></listitem>
|
||||
</itemizedlist>
|
||||
</para>
|
||||
|
||||
<para>It doesn't fulfill the requirements of a "sequence" (see Section 23.1.1, [lib.sequence.reqmts] of the C++ Standard), except that:
|
||||
<itemizedlist spacing="compact">
|
||||
<listitem><simpara><methodname>front</methodname>() and <methodname>back</methodname>() are provided.</simpara></listitem>
|
||||
<listitem><simpara><methodname>operator[]</methodname> and <methodname>at</methodname>() are provided.</simpara></listitem>
|
||||
</itemizedlist>
|
||||
</para>
|
||||
</section>
|
||||
|
||||
<library-reference>
|
||||
<header name="boost/array.hpp">
|
||||
<namespace name="boost">
|
||||
<class name="array">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
<template-nontype-parameter name="N">
|
||||
<type>std::size_t</type>
|
||||
</template-nontype-parameter>
|
||||
</template>
|
||||
|
||||
<purpose><para>STL compliant container wrapper for arrays of constant size</para></purpose>
|
||||
<typedef name="value_type">
|
||||
<type>T</type>
|
||||
</typedef>
|
||||
<typedef name="iterator">
|
||||
<type>T*</type>
|
||||
</typedef>
|
||||
<typedef name="const_iterator">
|
||||
<type>const T*</type>
|
||||
</typedef>
|
||||
<typedef name="reverse_iterator">
|
||||
<type><classname>std::reverse_iterator</classname><iterator></type>
|
||||
</typedef>
|
||||
<typedef name="const_reverse_iterator">
|
||||
<type><classname>std::reverse_iterator</classname><const_iterator></type>
|
||||
</typedef>
|
||||
<typedef name="reference">
|
||||
<type>T&</type>
|
||||
</typedef>
|
||||
<typedef name="const_reference">
|
||||
<type>const T&</type>
|
||||
</typedef>
|
||||
<typedef name="size_type">
|
||||
<type>std::size_t</type>
|
||||
</typedef>
|
||||
<typedef name="difference_type">
|
||||
<type>std::ptrdiff_t</type>
|
||||
</typedef>
|
||||
|
||||
<static-constant name="static_size">
|
||||
<type>size_type</type>
|
||||
<default>N</default>
|
||||
</static-constant>
|
||||
|
||||
<copy-assignment>
|
||||
<template>
|
||||
<template-type-parameter name="U"/>
|
||||
</template>
|
||||
<parameter name="other">
|
||||
<paramtype>const <classname>array</classname><U, N>&</paramtype>
|
||||
</parameter>
|
||||
<effects><simpara><code>std::copy(rhs.<methodname>begin</methodname>(),rhs.<methodname>end</methodname>(), <methodname>begin</methodname>())</code></simpara></effects>
|
||||
</copy-assignment>
|
||||
|
||||
<method-group name="iterator support">
|
||||
<overloaded-method name="begin">
|
||||
<signature>
|
||||
<type>iterator</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<type>const_iterator</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>iterator for the first element</simpara></returns>
|
||||
<throws><simpara>will not throw</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<overloaded-method name="end">
|
||||
<signature>
|
||||
<type>iterator</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<type>const_iterator</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>iterator for position after the last element</simpara></returns>
|
||||
<throws><simpara>will not throw</simpara></throws>
|
||||
</overloaded-method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="reverse iterator support">
|
||||
<overloaded-method name="rbegin">
|
||||
<signature>
|
||||
<type>reverse_iterator</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<type>const_reverse_iterator</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>reverse iterator for the first element of reverse iteration</simpara></returns>
|
||||
</overloaded-method>
|
||||
|
||||
<overloaded-method name="rend">
|
||||
<signature>
|
||||
<type>reverse_iterator</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<type>const_reverse_iterator</type>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>reverse iterator for position after the last element in reverse iteration</simpara></returns>
|
||||
</overloaded-method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="capacity">
|
||||
<method name="size">
|
||||
<type>size_type</type>
|
||||
<returns><simpara><code>N</code></simpara></returns>
|
||||
</method>
|
||||
<method name="empty">
|
||||
<type>bool</type>
|
||||
<returns><simpara><code>N==0</code></simpara></returns>
|
||||
<throws><simpara>will not throw</simpara></throws>
|
||||
</method>
|
||||
<method name="max_size">
|
||||
<type>size_type</type>
|
||||
<returns><simpara><code>N</code></simpara></returns>
|
||||
<throws><simpara>will not throw</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="element access">
|
||||
<overloaded-method name="operator[]">
|
||||
<signature>
|
||||
<type>reference</type>
|
||||
<parameter name="i">
|
||||
<paramtype>size_type</paramtype>
|
||||
</parameter>
|
||||
</signature>
|
||||
|
||||
<signature cv="const">
|
||||
<type>const_reference</type>
|
||||
<parameter name="i">
|
||||
<paramtype>size_type</paramtype>
|
||||
</parameter>
|
||||
</signature>
|
||||
|
||||
<requires><simpara><code>i < N</code></simpara></requires>
|
||||
<returns><simpara>element with index <code>i</code></simpara></returns>
|
||||
<throws><simpara>will not throw.</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<overloaded-method name="at">
|
||||
<signature>
|
||||
<type>reference</type>
|
||||
<parameter name="i">
|
||||
<paramtype>size_type</paramtype>
|
||||
</parameter>
|
||||
</signature>
|
||||
|
||||
<signature cv="const">
|
||||
<type>const_reference</type>
|
||||
<parameter name="i">
|
||||
<paramtype>size_type</paramtype>
|
||||
</parameter>
|
||||
</signature>
|
||||
|
||||
<returns><simpara>element with index <code>i</code></simpara></returns>
|
||||
<throws><simpara><code><classname>std::range_error</classname></code> if <code>i >= N</code></simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<overloaded-method name="front">
|
||||
<signature>
|
||||
<type>reference</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<type>const_reference</type>
|
||||
</signature>
|
||||
<requires><simpara><code>N > 0</code></simpara></requires>
|
||||
<returns><simpara>the first element</simpara></returns>
|
||||
<throws><simpara>will not throw</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<overloaded-method name="back">
|
||||
<signature>
|
||||
<type>reference</type>
|
||||
</signature>
|
||||
<signature cv="const">
|
||||
<type>const_reference</type>
|
||||
</signature>
|
||||
<requires><simpara><code>N > 0</code></simpara></requires>
|
||||
<returns><simpara>the last element</simpara></returns>
|
||||
<throws><simpara>will not throw</simpara></throws>
|
||||
</overloaded-method>
|
||||
|
||||
<method name="data" cv="const">
|
||||
<type>const T*</type>
|
||||
<returns><simpara><code>elems</code></simpara></returns>
|
||||
<throws><simpara>will not throw</simpara></throws>
|
||||
</method>
|
||||
|
||||
<method name="c_array">
|
||||
<type>T*</type>
|
||||
<returns><simpara><code>elems</code></simpara></returns>
|
||||
<throws><simpara>will not throw</simpara></throws>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<method-group name="modifiers">
|
||||
<method name="swap">
|
||||
<type>void</type>
|
||||
<parameter name="other">
|
||||
<paramtype><classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
<effects><simpara><code>std::swap_ranges(<methodname>begin</methodname>(), <methodname>end</methodname>(), other.<methodname>begin</methodname>())</code></simpara></effects>
|
||||
<complexity><simpara>linear in <code>N</code></simpara></complexity>
|
||||
</method>
|
||||
<method name="assign">
|
||||
<type>void</type>
|
||||
<parameter name="value">
|
||||
<paramtype>const T&</paramtype>
|
||||
</parameter>
|
||||
<effects><simpara><code>std::fill_n(<methodname>begin</methodname>(), N, value)</code></simpara></effects>
|
||||
</method>
|
||||
</method-group>
|
||||
|
||||
<data-member name="elems[N]"> <!-- HACK -->
|
||||
<type>T</type>
|
||||
</data-member>
|
||||
|
||||
<free-function-group name="specialized algorithms">
|
||||
<function name="swap">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
<template-nontype-parameter name="N">
|
||||
<type>std::size_t</type>
|
||||
</template-nontype-parameter>
|
||||
</template>
|
||||
|
||||
<type>void</type>
|
||||
|
||||
<parameter name="x">
|
||||
<paramtype><classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
<parameter name="y">
|
||||
<paramtype><classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<effects><simpara><code>x.<methodname>swap</methodname>(y)</code></simpara></effects>
|
||||
<throws><simpara>will not throw.</simpara></throws>
|
||||
</function>
|
||||
</free-function-group>
|
||||
|
||||
<free-function-group name="comparisons">
|
||||
<function name="operator==">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
<template-nontype-parameter name="N">
|
||||
<type>std::size_t</type>
|
||||
</template-nontype-parameter>
|
||||
</template>
|
||||
|
||||
<type>bool</type>
|
||||
|
||||
<parameter name="x">
|
||||
<paramtype>const <classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
<parameter name="y">
|
||||
<paramtype>const <classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<returns><simpara><code>std::equal(x.<methodname>begin</methodname>(), x.<methodname>end</methodname>(), y.<methodname>begin</methodname>())</code></simpara>
|
||||
</returns>
|
||||
</function>
|
||||
|
||||
<function name="operator!=">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
<template-nontype-parameter name="N">
|
||||
<type>std::size_t</type>
|
||||
</template-nontype-parameter>
|
||||
</template>
|
||||
|
||||
<type>bool</type>
|
||||
|
||||
<parameter name="x">
|
||||
<paramtype>const <classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
<parameter name="y">
|
||||
<paramtype>const <classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<returns><simpara><code>!(x == y)</code></simpara>
|
||||
</returns>
|
||||
</function>
|
||||
|
||||
<function name="operator<">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
<template-nontype-parameter name="N">
|
||||
<type>std::size_t</type>
|
||||
</template-nontype-parameter>
|
||||
</template>
|
||||
|
||||
<type>bool</type>
|
||||
|
||||
<parameter name="x">
|
||||
<paramtype>const <classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
<parameter name="y">
|
||||
<paramtype>const <classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<returns><simpara><code>std::lexicographical_compare(x.<methodname>begin</methodname>(), x.<methodname>end</methodname>(), y.<methodname>begin</methodname>(), y.<methodname>end</methodname>())</code></simpara>
|
||||
</returns>
|
||||
</function>
|
||||
|
||||
<function name="operator>">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
<template-nontype-parameter name="N">
|
||||
<type>std::size_t</type>
|
||||
</template-nontype-parameter>
|
||||
</template>
|
||||
|
||||
<type>bool</type>
|
||||
|
||||
<parameter name="x">
|
||||
<paramtype>const <classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
<parameter name="y">
|
||||
<paramtype>const <classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<returns><simpara><code>y < x</code></simpara></returns>
|
||||
</function>
|
||||
|
||||
<function name="operator<=">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
<template-nontype-parameter name="N">
|
||||
<type>std::size_t</type>
|
||||
</template-nontype-parameter>
|
||||
</template>
|
||||
|
||||
<type>bool</type>
|
||||
|
||||
<parameter name="x">
|
||||
<paramtype>const <classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
<parameter name="y">
|
||||
<paramtype>const <classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<returns><simpara><code>!(y < x)</code></simpara></returns>
|
||||
</function>
|
||||
|
||||
<function name="operator>=">
|
||||
<template>
|
||||
<template-type-parameter name="T"/>
|
||||
<template-nontype-parameter name="N">
|
||||
<type>std::size_t</type>
|
||||
</template-nontype-parameter>
|
||||
</template>
|
||||
|
||||
<type>bool</type>
|
||||
|
||||
<parameter name="x">
|
||||
<paramtype>const <classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
<parameter name="y">
|
||||
<paramtype>const <classname>array</classname><T, N>&</paramtype>
|
||||
</parameter>
|
||||
|
||||
<returns><simpara><code>!(x < y)</code></simpara></returns>
|
||||
</function>
|
||||
</free-function-group>
|
||||
</class>
|
||||
</namespace>
|
||||
</header>
|
||||
</library-reference>
|
||||
|
||||
<section id="array.rationale">
|
||||
<title>Design Rationale</title>
|
||||
|
||||
<para>There was an important design tradeoff regarding the
|
||||
constructors: We could implement array as an "aggregate" (see
|
||||
Section 8.5.1, [dcl.init.aggr], of the C++ Standard). This would
|
||||
mean:
|
||||
<itemizedlist>
|
||||
<listitem><simpara>An array can be initialized with a
|
||||
brace-enclosing, comma-separated list of initializers for the
|
||||
elements of the container, written in increasing subscript
|
||||
order:</simpara>
|
||||
|
||||
<programlisting><classname>boost::array</classname><int,4> a = { { 1, 2, 3 } };</programlisting>
|
||||
|
||||
<simpara>Note that if there are fewer elements in the
|
||||
initializer list, then each remaining element gets
|
||||
default-initialized (thus, it has a defined value).</simpara>
|
||||
</listitem></itemizedlist></para>
|
||||
|
||||
<para>However, this approach has its drawbacks: <emphasis
|
||||
role="bold"> passing no initializer list means that the elements
|
||||
have an indetermined initial value</emphasis>, because the rule says
|
||||
that aggregates may have:
|
||||
<itemizedlist>
|
||||
<listitem><simpara>No user-declared constructors.</simpara></listitem>
|
||||
<listitem><simpara>No private or protected non-static data members.</simpara></listitem>
|
||||
<listitem><simpara>No base classes.</simpara></listitem>
|
||||
<listitem><simpara>No virtual functions.</simpara></listitem>
|
||||
</itemizedlist>
|
||||
</para>
|
||||
|
||||
<para>Nevertheless, The current implementation uses this approach.</para>
|
||||
|
||||
<para>Note that for standard conforming compilers it is possible to
|
||||
use fewer braces (according to 8.5.1 (11) of the Standard). That is,
|
||||
you can initialize an array as follows:</para>
|
||||
|
||||
<programlisting>
|
||||
<classname>boost::array</classname><int,4> a = { 1, 2, 3 };
|
||||
</programlisting>
|
||||
|
||||
<para>I'd appreciate any constructive feedback. <emphasis
|
||||
role="bold">Please note: I don't have time to read all boost
|
||||
mails. Thus, to make sure that feedback arrives to me, please send
|
||||
me a copy of each mail regarding this class.</emphasis></para>
|
||||
|
||||
<para>The code is provided "as is" without expressed or implied
|
||||
warranty.</para>
|
||||
|
||||
</section>
|
||||
|
||||
<section id="array.more.info">
|
||||
<title>For more information...</title>
|
||||
<para>To find more details about using ordinary arrays in C++ and
|
||||
the framework of the STL, see e.g.
|
||||
|
||||
<literallayout>The C++ Standard Library - A Tutorial and Reference
|
||||
by Nicolai M. Josuttis
|
||||
Addison Wesley Longman, 1999
|
||||
ISBN 0-201-37926-0</literallayout>
|
||||
</para>
|
||||
|
||||
<para><ulink url="http://www.josuttis.com/">Home Page of Nicolai
|
||||
Josuttis</ulink></para>
|
||||
</section>
|
||||
|
||||
<section id="array.ack">
|
||||
<title>Acknowledgements</title>
|
||||
|
||||
<para>Doug Gregor ported the documentation to the BoostBook format.</para>
|
||||
</section>
|
||||
|
||||
<!-- Notes:
|
||||
empty() should return N != 0
|
||||
size(), empty(), max_size() should be const
|
||||
-->
|
||||
|
||||
</library>
|
||||
@ -1,16 +0,0 @@
|
||||
////
|
||||
Copyright 2025 Peter Dimov
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
http://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#changes]
|
||||
# Revision History
|
||||
:toc:
|
||||
:toc-title:
|
||||
:idprefix:
|
||||
|
||||
## Changes in 1.88.0
|
||||
|
||||
* Converted documentation to AsciiDoc (Christian Mazakas).
|
||||
* Added `noexcept` and `constexpr` as appropriate.
|
||||
@ -1,15 +0,0 @@
|
||||
////
|
||||
Copyright 2024 Christian Mazakas
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
https://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#copyright]
|
||||
# Copyright and License
|
||||
:idprefix: copyright
|
||||
|
||||
Copyright (C) 2001-2004 Nicolai M. Josuttis
|
||||
|
||||
Copyright (C) 2012 Marshall Clow
|
||||
|
||||
Distributed under the https://www.boost.org/LICENSE_1_0.txt[Boost Software License, Version 1.0].
|
||||
@ -1,39 +0,0 @@
|
||||
////
|
||||
Copyright 2001-2004 Nicolai M. Josuttis
|
||||
Copyright 2012 Marshall Clow
|
||||
Copyright 2024 Christian Mazakas
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
https://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#design]
|
||||
# Design Rationale
|
||||
:idprefix: design_
|
||||
:cpp: C++
|
||||
|
||||
There was an important design tradeoff regarding the constructors: We could implement array as an "aggregate" (see Section 8.5.1, [dcl.init.aggr], of the C++ Standard). This would mean:
|
||||
|
||||
* An array can be initialized with a brace-enclosing, comma-separated list of initializers for the elements of the container, written in increasing subscript order:
|
||||
+
|
||||
--
|
||||
```cpp
|
||||
boost::array<int,4> a = { { 1, 2, 3 } };
|
||||
```
|
||||
|
||||
Note that if there are fewer elements in the initializer list, then each remaining element gets default-initialized (thus, it has a defined value).
|
||||
--
|
||||
|
||||
However, this approach has its drawbacks: **passing no initializer list means that the elements have an indetermined initial value**, because the rule says that aggregates may have:
|
||||
|
||||
* No user-declared constructors.
|
||||
* No private or protected non-static data members.
|
||||
* No base classes.
|
||||
* No virtual functions.
|
||||
|
||||
Nevertheless, the current implementation uses this approach.
|
||||
|
||||
Note that for standard conforming compilers it is possible to use fewer braces (according to 8.5.1 (11) of the Standard). That is, you can initialize an array as follows:
|
||||
|
||||
```cpp
|
||||
boost::array<int,4> a = { 1, 2, 3 };
|
||||
```
|
||||
@ -1,22 +0,0 @@
|
||||
////
|
||||
Copyright 2001-2004 Nicolai M. Josuttis
|
||||
Copyright 2012 Marshall Clow
|
||||
Copyright 2024 Christian Mazakas
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
https://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#information]
|
||||
# For more information...
|
||||
:idprefix: information_
|
||||
:cpp: C++
|
||||
|
||||
To find more details about using ordinary arrays in C++ and the framework of the STL, see e.g.
|
||||
|
||||
The C++ Standard Library - A Tutorial and Reference +
|
||||
by Nicolai M. Josuttis +
|
||||
Addison Wesley Longman, 1999 +
|
||||
ISBN 0-201-37926-0
|
||||
|
||||
|
||||
http://www.josuttis.com/[Home Page of Nicolai Josuttis]
|
||||
@ -1,44 +0,0 @@
|
||||
////
|
||||
Copyright 2001-2004 Nicolai M. Josuttis
|
||||
Copyright 2012 Marshall Clow
|
||||
Copyright 2024 Christian Mazakas
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
https://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#introduction]
|
||||
# Introduction
|
||||
:idprefix: introduction_
|
||||
:cpp: C++
|
||||
|
||||
The {cpp} Standard Template Library STL as part of the {cpp} Standard Library provides a framework for processing algorithms on different kind of containers.
|
||||
However, ordinary arrays don't provide the interface of STL containers (although, they provide the iterator interface of STL containers).
|
||||
|
||||
As replacement for ordinary arrays, the STL provides class `std::vector`.
|
||||
However, `std::vector<>` provides the semantics of dynamic arrays.
|
||||
Thus, it manages data to be able to change the number of elements.
|
||||
This results in some overhead in case only arrays with static size are needed.
|
||||
|
||||
In his book, _Generic Programming and the STL_, Matthew H. Austern introduces a useful wrapper class for ordinary arrays with static size, called `block`.
|
||||
It is safer and has no worse performance than ordinary arrays.
|
||||
In _The {cpp} Programming Language_, 3rd edition, Bjarne Stroustrup introduces a similar class, called c_array, which I (http://www.josuttis.com/[Nicolai Josuttis]) present slightly modified in my book _The {cpp} Standard Library - A Tutorial and Reference_, called `carray`.
|
||||
This is the essence of these approaches spiced with many feedback from https://www.boost.org/[Boost].
|
||||
|
||||
After considering different names, we decided to name this class simply `array`.
|
||||
|
||||
Note that this class is suggested to be part of the next Technical Report, which will extend the {cpp} Standard (see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1548.htm).
|
||||
|
||||
Update: `std::array` is (as of {cpp}11) part of the {cpp} standard. The differences between `boost::array` and `std::array` are minimal. If you are using {cpp}11, you should consider using `std::array` instead of `boost::array`.
|
||||
|
||||
Class `array` fulfills most but not all of the requirements of "reversible containers" (see Section 23.1, [lib.container.requirements] of the {cpp} Standard). The reasons array is not an reversible STL container is because:
|
||||
|
||||
* No constructors are provided.
|
||||
* Elements may have an undetermined initial value (see the <<design, section called "Design Rationale">>).
|
||||
* `swap()` has no constant complexity.
|
||||
* `size()` is always constant, based on the second template argument of the type.
|
||||
* The container provides no allocator support.
|
||||
|
||||
It doesn't fulfill the requirements of a "sequence" (see Section 23.1.1, [lib.sequence.reqmts] of the {cpp} Standard), except that:
|
||||
|
||||
* `front()` and `back()` are provided.
|
||||
* `operator[]` and `at()` are provided.
|
||||
@ -1,405 +0,0 @@
|
||||
////
|
||||
Copyright 2001-2004 Nicolai M. Josuttis
|
||||
Copyright 2012 Marshall Clow
|
||||
Copyright 2024 Christian Mazakas
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
https://www.boost.org/LICENSE_1_0.txt
|
||||
////
|
||||
|
||||
[#reference]
|
||||
# Reference
|
||||
:idprefix: reference_
|
||||
:cpp: C++
|
||||
|
||||
## Header <boost/array.hpp>
|
||||
|
||||
```cpp
|
||||
namespace boost {
|
||||
|
||||
template<typename T, std::size_t N> class array;
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
void swap(array<T, N>&, array<T, N>&);
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
constexpr bool operator==(const array<T, N>&, const array<T, N>&);
|
||||
template<typename T, std::size_t N>
|
||||
constexpr bool operator!=(const array<T, N>&, const array<T, N>&);
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
constexpr bool operator<(const array<T, N>&, const array<T, N>&);
|
||||
template<typename T, std::size_t N>
|
||||
constexpr bool operator>(const array<T, N>&, const array<T, N>&);
|
||||
template<typename T, std::size_t N>
|
||||
constexpr bool operator<=(const array<T, N>&, const array<T, N>&);
|
||||
template<typename T, std::size_t N>
|
||||
constexpr bool operator>=(const array<T, N>&, const array<T, N>&);
|
||||
|
||||
template<std::size_t Idx, typename T, std::size_t N>
|
||||
constexpr T& get(array<T, N>&) noexcept;
|
||||
template<std::size_t Idx, typename T, std::size_t N>
|
||||
constexpr const T& get(const array<T, N>&) noexcept;
|
||||
}
|
||||
```
|
||||
|
||||
## Class template array
|
||||
|
||||
### Synopsis
|
||||
|
||||
```cpp
|
||||
// In header: <boost/array.hpp>
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
class array {
|
||||
public:
|
||||
|
||||
// types
|
||||
|
||||
typedef T value_type;
|
||||
typedef T* iterator;
|
||||
typedef const T* const_iterator;
|
||||
typedef std::reverse_iterator<iterator> reverse_iterator;
|
||||
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef std::size_t size_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
|
||||
// static constants
|
||||
|
||||
static const size_type static_size = N;
|
||||
|
||||
// construct/copy/destroy
|
||||
|
||||
template<typename U> array& operator=(const array<U, N>&);
|
||||
|
||||
// iterator support
|
||||
|
||||
constexpr iterator begin() noexcept;
|
||||
constexpr const_iterator begin() const noexcept;
|
||||
constexpr const_iterator cbegin() const noexcept;
|
||||
|
||||
constexpr iterator end() noexcept;
|
||||
constexpr const_iterator end() const noexcept;
|
||||
constexpr const_iterator cend() const noexcept;
|
||||
|
||||
// reverse iterator support
|
||||
|
||||
reverse_iterator rbegin() noexcept;
|
||||
const_reverse_iterator rbegin() const noexcept;
|
||||
const_reverse_iterator crbegin() const noexcept;
|
||||
|
||||
reverse_iterator rend() noexcept;
|
||||
const_reverse_iterator rend() const noexcept;
|
||||
const_reverse_iterator crend() const noexcept;
|
||||
|
||||
// capacity
|
||||
|
||||
static constexpr size_type size() noexcept;
|
||||
static constexpr bool empty() noexcept;
|
||||
static constexpr size_type max_size() noexcept;
|
||||
|
||||
// element access
|
||||
|
||||
constexpr reference operator[](size_type);
|
||||
constexpr const_reference operator[](size_type) const;
|
||||
|
||||
constexpr reference at(size_type);
|
||||
constexpr const_reference at(size_type) const;
|
||||
|
||||
constexpr reference front();
|
||||
constexpr const_reference front() const;
|
||||
|
||||
constexpr reference back();
|
||||
constexpr const_reference back() const;
|
||||
|
||||
constexpr T* data() noexcept;
|
||||
constexpr const T* data() const noexcept;
|
||||
|
||||
T* c_array() noexcept; // deprecated
|
||||
|
||||
// modifiers
|
||||
|
||||
swap(array<T, N>&);
|
||||
|
||||
constexpr void fill(const T&);
|
||||
void assign(const T&); // deprecated
|
||||
|
||||
// public data members
|
||||
T elems[N];
|
||||
};
|
||||
```
|
||||
|
||||
### Construct/Copy/Destroy
|
||||
|
||||
```
|
||||
template<typename U> array& operator=(const array<U, N>& other);
|
||||
```
|
||||
[horizontal]
|
||||
Effects: :: `std::copy(rhs.begin(), rhs.end(), begin())`.
|
||||
|
||||
---
|
||||
|
||||
### Iterator Support
|
||||
|
||||
```
|
||||
constexpr iterator begin() noexcept;
|
||||
constexpr const_iterator begin() const noexcept;
|
||||
constexpr const_iterator cbegin() const noexcept;
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `data()`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
constexpr iterator end() noexcept;
|
||||
constexpr const_iterator end() const noexcept;
|
||||
constexpr const_iterator cend() const noexcept;
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `data() + size()`.
|
||||
|
||||
---
|
||||
|
||||
### Reverse Iterator Support
|
||||
|
||||
```
|
||||
reverse_iterator rbegin() noexcept;
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `reverse_iterator(end())`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
const_reverse_iterator rbegin() const noexcept;
|
||||
const_reverse_iterator crbegin() const noexcept;
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `const_reverse_iterator(end())`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
reverse_iterator rend() noexcept;
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `reverse_iterator(begin())`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
const_reverse_iterator rend() const noexcept;
|
||||
const_reverse_iterator crend() const noexcept;
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `const_reverse_iterator(begin())`.
|
||||
|
||||
---
|
||||
|
||||
### Capacity
|
||||
|
||||
```
|
||||
static constexpr size_type size() noexcept;
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `N`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
static constexpr bool empty() noexcept;
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `N == 0`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
static constexpr size_type max_size() noexcept;
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `N`.
|
||||
|
||||
---
|
||||
|
||||
### Element Access
|
||||
|
||||
```
|
||||
constexpr reference operator[](size_type i);
|
||||
constexpr const_reference operator[](size_type i) const;
|
||||
```
|
||||
[horizontal]
|
||||
Requires: :: `i < N`.
|
||||
Returns: :: `elems[i]`.
|
||||
Throws: :: nothing.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
constexpr reference at(size_type i);
|
||||
constexpr const_reference at(size_type i) const;
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `elems[i]`.
|
||||
Throws: :: `std::out_of_range` if `i >= N`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
constexpr reference front();
|
||||
constexpr const_reference front() const;
|
||||
```
|
||||
[horizontal]
|
||||
Requires: :: `N > 0`.
|
||||
Returns: :: `elems[0]`.
|
||||
Throws: :: nothing.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
constexpr reference back();
|
||||
constexpr const_reference back() const;
|
||||
```
|
||||
[horizontal]
|
||||
Requires: :: `N > 0`.
|
||||
Returns: :: `elems[N-1]`.
|
||||
Throws: :: nothing.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
constexpr T* data() noexcept;
|
||||
constexpr const T* data() const noexcept;
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `elems`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
T* c_array() noexcept; // deprecated
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `data()`.
|
||||
Remarks: :: This function is deprecated. Use `data()` instead.
|
||||
|
||||
---
|
||||
|
||||
### Modifiers
|
||||
|
||||
```
|
||||
void swap(array<T, N>& other);
|
||||
```
|
||||
[horizontal]
|
||||
Effects: :: `std::swap(elems, other.elems)`.
|
||||
Complexity: :: linear in `N`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
void fill(const T& value);
|
||||
```
|
||||
[horizontal]
|
||||
Effects: :: for each `i` in `[0..N)`, performs `elems[i] = value;`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
void assign(const T& value); // deprecated
|
||||
```
|
||||
[horizontal]
|
||||
Effects: :: `fill(value)`.
|
||||
Remarks: :: An obsolete and deprecated spelling of `fill`. Use `fill` instead.
|
||||
|
||||
---
|
||||
|
||||
### Specialized Algorithms
|
||||
|
||||
```
|
||||
template<typename T, std::size_t N>
|
||||
void swap(array<T, N>& x, array<T, N>& y);
|
||||
```
|
||||
[horizontal]
|
||||
Effects: :: `x.swap(y)`.
|
||||
|
||||
---
|
||||
|
||||
### Comparisons
|
||||
|
||||
```
|
||||
template<typename T, std::size_t N>
|
||||
constexpr bool operator==(const array<T, N>& x, const array<T, N>& y);
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `std::equal(x.begin(), x.end(), y.begin())`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
template<typename T, std::size_t N>
|
||||
constexpr bool operator!=(const array<T, N>& x, const array<T, N>& y);
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `!(x == y)`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
template<typename T, std::size_t N>
|
||||
constexpr bool operator<(const array<T, N>& x, const array<T, N>& y);
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end())`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
template<typename T, std::size_t N>
|
||||
constexpr bool operator>(const array<T, N>& x, const array<T, N>& y);
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `y < x`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
template<typename T, std::size_t N>
|
||||
constexpr bool operator<=(const array<T, N>& x, const array<T, N>& y);
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `!(y < x)`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
template<typename T, std::size_t N>
|
||||
constexpr bool operator>=(const array<T, N>& x, const array<T, N>& y);
|
||||
```
|
||||
[horizontal]
|
||||
Returns: :: `!(x < y)`.
|
||||
|
||||
---
|
||||
|
||||
### Specializations
|
||||
|
||||
```
|
||||
template<std::size_t Idx, typename T, std::size_t N>
|
||||
constexpr T& get(array<T, N>& arr) noexcept;
|
||||
```
|
||||
[horizontal]
|
||||
Mandates: :: `Idx < N`.
|
||||
Returns: :: `arr[Idx]`.
|
||||
|
||||
---
|
||||
|
||||
```
|
||||
template<std::size_t Idx, typename T, std::size_t N>
|
||||
constexpr const T& get(const array<T, N>& arr) noexcept;
|
||||
```
|
||||
[horizontal]
|
||||
Mandates: :: `Idx < N`.
|
||||
Returns: :: `arr[Idx]`.
|
||||
|
||||
---
|
||||
@ -1,6 +1,3 @@
|
||||
#ifndef BOOST_ARRAY_HPP_INCLUDED
|
||||
#define BOOST_ARRAY_HPP_INCLUDED
|
||||
|
||||
/* The following code declares class array,
|
||||
* an STL container (as wrapper) for arrays of constant size.
|
||||
*
|
||||
@ -16,8 +13,6 @@
|
||||
* accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* 9 Jan 2013 - (mtc) Added constexpr
|
||||
* 14 Apr 2012 - (mtc) Added support for boost::hash
|
||||
* 28 Dec 2010 - (mtc) Added cbegin and cend (and crbegin and crend) for C++Ox compatibility.
|
||||
* 10 Mar 2010 - (mtc) fill method added, matching resolution of the standard library working group.
|
||||
* See <http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776> or Trac issue #3168
|
||||
@ -31,24 +26,31 @@
|
||||
*
|
||||
* Jan 29, 2004
|
||||
*/
|
||||
#ifndef BOOST_ARRAY_HPP
|
||||
#define BOOST_ARRAY_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable:4510) // boost::array<T,N>' : default constructor could not be generated
|
||||
# pragma warning(disable:4512) // boost::array<T,N>' : assignment operator could not be generated
|
||||
# pragma warning(disable:4610) // class 'boost::array<T,N>' can never be instantiated - user defined constructor required
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable:4996) // 'std::equal': Function call with parameters that may be unsafe
|
||||
# pragma warning(disable:4510) // boost::array<T,N>' : default constructor could not be generated
|
||||
# pragma warning(disable:4610) // warning C4610: class 'boost::array<T,N>' can never be instantiated - user defined constructor required
|
||||
#endif
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <iterator>
|
||||
#include <stdexcept>
|
||||
#include <utility>
|
||||
#include <cstddef>
|
||||
#include <stdexcept>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/swap.hpp>
|
||||
|
||||
// Handles broken standard libraries better than <iterator>
|
||||
#include <boost/detail/iterator.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <algorithm>
|
||||
|
||||
// FIXES for broken compilers
|
||||
#include <boost/config.hpp>
|
||||
|
||||
|
||||
namespace boost {
|
||||
|
||||
@ -68,131 +70,133 @@ namespace boost {
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
|
||||
// iterator support
|
||||
BOOST_CXX14_CONSTEXPR iterator begin() BOOST_NOEXCEPT { return elems; }
|
||||
BOOST_CONSTEXPR const_iterator begin() const BOOST_NOEXCEPT { return elems; }
|
||||
BOOST_CONSTEXPR const_iterator cbegin() const BOOST_NOEXCEPT { return elems; }
|
||||
|
||||
BOOST_CXX14_CONSTEXPR iterator end() BOOST_NOEXCEPT { return elems+N; }
|
||||
BOOST_CONSTEXPR const_iterator end() const BOOST_NOEXCEPT { return elems+N; }
|
||||
BOOST_CONSTEXPR const_iterator cend() const BOOST_NOEXCEPT { return elems+N; }
|
||||
iterator begin() { return elems; }
|
||||
const_iterator begin() const { return elems; }
|
||||
const_iterator cbegin() const { return elems; }
|
||||
|
||||
iterator end() { return elems+N; }
|
||||
const_iterator end() const { return elems+N; }
|
||||
const_iterator cend() const { return elems+N; }
|
||||
|
||||
// reverse iterator support
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
|
||||
typedef std::reverse_iterator<iterator> reverse_iterator;
|
||||
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
||||
#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
|
||||
// workaround for broken reverse_iterator in VC7
|
||||
typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
|
||||
reference, iterator, reference> > reverse_iterator;
|
||||
typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
|
||||
const_reference, iterator, reference> > const_reverse_iterator;
|
||||
#elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
|
||||
typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
|
||||
value_type, reference, iterator, difference_type> reverse_iterator;
|
||||
typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
|
||||
value_type, const_reference, const_iterator, difference_type> const_reverse_iterator;
|
||||
#else
|
||||
// workaround for broken reverse_iterator implementations
|
||||
typedef std::reverse_iterator<iterator,T> reverse_iterator;
|
||||
typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
|
||||
#endif
|
||||
|
||||
reverse_iterator rbegin() BOOST_NOEXCEPT { return reverse_iterator(end()); }
|
||||
const_reverse_iterator rbegin() const BOOST_NOEXCEPT {
|
||||
reverse_iterator rbegin() { return reverse_iterator(end()); }
|
||||
const_reverse_iterator rbegin() const {
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
const_reverse_iterator crbegin() const BOOST_NOEXCEPT {
|
||||
const_reverse_iterator crbegin() const {
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
|
||||
reverse_iterator rend() BOOST_NOEXCEPT { return reverse_iterator(begin()); }
|
||||
const_reverse_iterator rend() const BOOST_NOEXCEPT {
|
||||
reverse_iterator rend() { return reverse_iterator(begin()); }
|
||||
const_reverse_iterator rend() const {
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
const_reverse_iterator crend() const BOOST_NOEXCEPT {
|
||||
const_reverse_iterator crend() const {
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
|
||||
// operator[]
|
||||
BOOST_CXX14_CONSTEXPR reference operator[](size_type i)
|
||||
{
|
||||
return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i];
|
||||
reference operator[](size_type i)
|
||||
{
|
||||
BOOST_ASSERT( i < N && "out of range" );
|
||||
return elems[i];
|
||||
}
|
||||
|
||||
#if !BOOST_WORKAROUND(BOOST_GCC, < 50000)
|
||||
BOOST_CONSTEXPR
|
||||
#endif
|
||||
const_reference operator[](size_type i) const
|
||||
{
|
||||
return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i];
|
||||
|
||||
const_reference operator[](size_type i) const
|
||||
{
|
||||
BOOST_ASSERT( i < N && "out of range" );
|
||||
return elems[i];
|
||||
}
|
||||
|
||||
// at() with range check
|
||||
BOOST_CXX14_CONSTEXPR reference at(size_type i) { return rangecheck(i), elems[i]; }
|
||||
BOOST_CONSTEXPR const_reference at(size_type i) const { return rangecheck(i), elems[i]; }
|
||||
|
||||
reference at(size_type i) { rangecheck(i); return elems[i]; }
|
||||
const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
|
||||
|
||||
// front() and back()
|
||||
BOOST_CXX14_CONSTEXPR reference front()
|
||||
reference front()
|
||||
{
|
||||
return elems[0];
|
||||
}
|
||||
|
||||
const_reference front() const
|
||||
{
|
||||
return elems[0];
|
||||
}
|
||||
|
||||
BOOST_CONSTEXPR const_reference front() const
|
||||
{
|
||||
return elems[0];
|
||||
|
||||
reference back()
|
||||
{
|
||||
return elems[N-1];
|
||||
}
|
||||
|
||||
BOOST_CXX14_CONSTEXPR reference back()
|
||||
{
|
||||
return elems[N-1];
|
||||
}
|
||||
|
||||
BOOST_CONSTEXPR const_reference back() const
|
||||
{
|
||||
return elems[N-1];
|
||||
|
||||
const_reference back() const
|
||||
{
|
||||
return elems[N-1];
|
||||
}
|
||||
|
||||
// size is constant
|
||||
static BOOST_CONSTEXPR size_type size() BOOST_NOEXCEPT { return N; }
|
||||
static BOOST_CONSTEXPR bool empty() BOOST_NOEXCEPT { return false; }
|
||||
static BOOST_CONSTEXPR size_type max_size() BOOST_NOEXCEPT { return N; }
|
||||
static size_type size() { return N; }
|
||||
static bool empty() { return false; }
|
||||
static size_type max_size() { return N; }
|
||||
enum { static_size = N };
|
||||
|
||||
// swap (note: linear complexity)
|
||||
BOOST_CXX14_CONSTEXPR void swap (array<T,N>& y)
|
||||
{
|
||||
std::swap( elems, y.elems );
|
||||
void swap (array<T,N>& y) {
|
||||
for (size_type i = 0; i < N; ++i)
|
||||
boost::swap(elems[i],y.elems[i]);
|
||||
}
|
||||
|
||||
// direct access to data
|
||||
BOOST_CONSTEXPR const T* data() const BOOST_NOEXCEPT { return elems; }
|
||||
BOOST_CXX14_CONSTEXPR T* data() BOOST_NOEXCEPT { return elems; }
|
||||
// direct access to data (read-only)
|
||||
const T* data() const { return elems; }
|
||||
T* data() { return elems; }
|
||||
|
||||
// obsolete
|
||||
BOOST_DEPRECATED( "please use `data()` instead" )
|
||||
T* c_array() BOOST_NOEXCEPT { return elems; }
|
||||
// use array as C array (direct read/write access to data)
|
||||
T* c_array() { return elems; }
|
||||
|
||||
// assignment with type conversion
|
||||
template <typename T2>
|
||||
array<T,N>& operator= (const array<T2,N>& rhs)
|
||||
{
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
elems[ i ] = rhs.elems[ i ];
|
||||
}
|
||||
|
||||
array<T,N>& operator= (const array<T2,N>& rhs) {
|
||||
std::copy(rhs.begin(),rhs.end(), begin());
|
||||
return *this;
|
||||
}
|
||||
|
||||
// fill with one value
|
||||
BOOST_CXX14_CONSTEXPR void fill (const T& value)
|
||||
// assign one value to all elements
|
||||
void assign (const T& value) { fill ( value ); } // A synonym for fill
|
||||
void fill (const T& value)
|
||||
{
|
||||
// using elems[ 0 ] as a temporary copy
|
||||
// avoids the aliasing opportunity betw.
|
||||
// `value` and `elems`
|
||||
|
||||
elems[ 0 ] = value;
|
||||
|
||||
for( std::size_t i = 1; i < N; ++i )
|
||||
{
|
||||
elems[ i ] = elems[ 0 ];
|
||||
}
|
||||
std::fill_n(begin(),size(),value);
|
||||
}
|
||||
|
||||
// an obsolete synonym for fill
|
||||
BOOST_DEPRECATED( "please use `fill` instead" )
|
||||
void assign (const T& value) { fill ( value ); }
|
||||
|
||||
// check range (may be private because it is static)
|
||||
static BOOST_CONSTEXPR bool rangecheck (size_type i) {
|
||||
return i >= size() ? boost::throw_exception(std::out_of_range ("array<>: index out of range")), true : true;
|
||||
static void rangecheck (size_type i) {
|
||||
if (i >= size()) {
|
||||
std::out_of_range e("array<>: index out of range");
|
||||
boost::throw_exception(e);
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
template< class T >
|
||||
class array< T, 0 > {
|
||||
|
||||
@ -207,31 +211,48 @@ namespace boost {
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
|
||||
// iterator support
|
||||
iterator begin() BOOST_NOEXCEPT { return iterator( reinterpret_cast< T * >( this ) ); }
|
||||
const_iterator begin() const BOOST_NOEXCEPT { return const_iterator( reinterpret_cast< const T * >( this ) ); }
|
||||
const_iterator cbegin() const BOOST_NOEXCEPT { return const_iterator( reinterpret_cast< const T * >( this ) ); }
|
||||
iterator begin() { return iterator( reinterpret_cast< T * >( this ) ); }
|
||||
const_iterator begin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
|
||||
const_iterator cbegin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
|
||||
|
||||
iterator end() BOOST_NOEXCEPT { return begin(); }
|
||||
const_iterator end() const BOOST_NOEXCEPT { return begin(); }
|
||||
const_iterator cend() const BOOST_NOEXCEPT { return cbegin(); }
|
||||
iterator end() { return begin(); }
|
||||
const_iterator end() const { return begin(); }
|
||||
const_iterator cend() const { return cbegin(); }
|
||||
|
||||
// reverse iterator support
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
|
||||
typedef std::reverse_iterator<iterator> reverse_iterator;
|
||||
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
||||
#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
|
||||
// workaround for broken reverse_iterator in VC7
|
||||
typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
|
||||
reference, iterator, reference> > reverse_iterator;
|
||||
typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
|
||||
const_reference, iterator, reference> > const_reverse_iterator;
|
||||
#elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
|
||||
typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
|
||||
value_type, reference, iterator, difference_type> reverse_iterator;
|
||||
typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
|
||||
value_type, const_reference, const_iterator, difference_type> const_reverse_iterator;
|
||||
#else
|
||||
// workaround for broken reverse_iterator implementations
|
||||
typedef std::reverse_iterator<iterator,T> reverse_iterator;
|
||||
typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
|
||||
#endif
|
||||
|
||||
reverse_iterator rbegin() BOOST_NOEXCEPT { return reverse_iterator(end()); }
|
||||
const_reverse_iterator rbegin() const BOOST_NOEXCEPT {
|
||||
reverse_iterator rbegin() { return reverse_iterator(end()); }
|
||||
const_reverse_iterator rbegin() const {
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
const_reverse_iterator crbegin() const BOOST_NOEXCEPT {
|
||||
const_reverse_iterator crbegin() const {
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
|
||||
reverse_iterator rend() BOOST_NOEXCEPT { return reverse_iterator(begin()); }
|
||||
const_reverse_iterator rend() const BOOST_NOEXCEPT {
|
||||
reverse_iterator rend() { return reverse_iterator(begin()); }
|
||||
const_reverse_iterator rend() const {
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
const_reverse_iterator crend() const BOOST_NOEXCEPT {
|
||||
const_reverse_iterator crend() const {
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
|
||||
@ -247,8 +268,8 @@ namespace boost {
|
||||
}
|
||||
|
||||
// at() with range check
|
||||
reference at(size_type /*i*/) { return failed_rangecheck(); }
|
||||
const_reference at(size_type /*i*/) const { return failed_rangecheck(); }
|
||||
reference at(size_type /*i*/) { return failed_rangecheck(); }
|
||||
const_reference at(size_type /*i*/) const { return failed_rangecheck(); }
|
||||
|
||||
// front() and back()
|
||||
reference front()
|
||||
@ -272,22 +293,20 @@ namespace boost {
|
||||
}
|
||||
|
||||
// size is constant
|
||||
static BOOST_CONSTEXPR size_type size() BOOST_NOEXCEPT { return 0; }
|
||||
static BOOST_CONSTEXPR bool empty() BOOST_NOEXCEPT { return true; }
|
||||
static BOOST_CONSTEXPR size_type max_size() BOOST_NOEXCEPT { return 0; }
|
||||
static size_type size() { return 0; }
|
||||
static bool empty() { return true; }
|
||||
static size_type max_size() { return 0; }
|
||||
enum { static_size = 0 };
|
||||
|
||||
BOOST_CXX14_CONSTEXPR void swap (array<T,0>& /*y*/)
|
||||
{
|
||||
void swap (array<T,0>& /*y*/) {
|
||||
}
|
||||
|
||||
// direct access to data
|
||||
BOOST_CONSTEXPR const T* data() const BOOST_NOEXCEPT { return 0; }
|
||||
BOOST_CXX14_CONSTEXPR T* data() BOOST_NOEXCEPT { return 0; }
|
||||
// direct access to data (read-only)
|
||||
const T* data() const { return 0; }
|
||||
T* data() { return 0; }
|
||||
|
||||
// obsolete
|
||||
BOOST_DEPRECATED( "please use `data()` instead" )
|
||||
T* c_array() BOOST_NOEXCEPT { return 0; }
|
||||
// use array as C array (direct read/write access to data)
|
||||
T* c_array() { return 0; }
|
||||
|
||||
// assignment with type conversion
|
||||
template <typename T2>
|
||||
@ -295,18 +314,15 @@ namespace boost {
|
||||
return *this;
|
||||
}
|
||||
|
||||
// an obsolete synonym for fill
|
||||
BOOST_DEPRECATED( "please use `fill` instead" )
|
||||
// assign one value to all elements
|
||||
void assign (const T& value) { fill ( value ); }
|
||||
|
||||
// fill with one value
|
||||
BOOST_CXX14_CONSTEXPR void fill (const T& ) {}
|
||||
|
||||
void fill (const T& ) {}
|
||||
|
||||
// check range (may be private because it is static)
|
||||
static reference failed_rangecheck () {
|
||||
std::out_of_range e("attempt to access element of an empty array");
|
||||
boost::throw_exception(e);
|
||||
#if defined(BOOST_NO_EXCEPTIONS) || (!defined(BOOST_MSVC) && !defined(__PATHSCALE__))
|
||||
#if defined(BOOST_NO_EXCEPTIONS) || !defined(BOOST_MSVC)
|
||||
//
|
||||
// We need to return something here to keep
|
||||
// some compilers happy: however we will never
|
||||
@ -317,136 +333,105 @@ namespace boost {
|
||||
#endif
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
// comparisons
|
||||
template<class T, std::size_t N>
|
||||
BOOST_CXX14_CONSTEXPR bool operator== (const array<T,N>& x, const array<T,N>& y)
|
||||
{
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
if( !( x[ i ] == y[ i ] ) ) return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
bool operator== (const array<T,N>& x, const array<T,N>& y) {
|
||||
return std::equal(x.begin(), x.end(), y.begin());
|
||||
}
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_GCC, < 90000)
|
||||
|
||||
template<class T>
|
||||
BOOST_CXX14_CONSTEXPR bool operator== (const array<T, 0>& x, const array<T, 0>& y)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
template<class T, std::size_t N>
|
||||
BOOST_CXX14_CONSTEXPR bool operator!= (const array<T,N>& x, const array<T,N>& y) {
|
||||
bool operator< (const array<T,N>& x, const array<T,N>& y) {
|
||||
return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
|
||||
}
|
||||
template<class T, std::size_t N>
|
||||
bool operator!= (const array<T,N>& x, const array<T,N>& y) {
|
||||
return !(x==y);
|
||||
}
|
||||
|
||||
template<class T, std::size_t N>
|
||||
BOOST_CXX14_CONSTEXPR bool operator< (const array<T,N>& x, const array<T,N>& y)
|
||||
{
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
if( x[ i ] < y[ i ] ) return true;
|
||||
if( y[ i ] < x[ i ] ) return false;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_GCC, < 90000)
|
||||
|
||||
template<class T>
|
||||
BOOST_CXX14_CONSTEXPR bool operator< (const array<T, 0>& x, const array<T, 0>& y)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
template<class T, std::size_t N>
|
||||
BOOST_CXX14_CONSTEXPR bool operator> (const array<T,N>& x, const array<T,N>& y) {
|
||||
bool operator> (const array<T,N>& x, const array<T,N>& y) {
|
||||
return y<x;
|
||||
}
|
||||
|
||||
template<class T, std::size_t N>
|
||||
BOOST_CXX14_CONSTEXPR bool operator<= (const array<T,N>& x, const array<T,N>& y) {
|
||||
bool operator<= (const array<T,N>& x, const array<T,N>& y) {
|
||||
return !(y<x);
|
||||
}
|
||||
|
||||
template<class T, std::size_t N>
|
||||
BOOST_CXX14_CONSTEXPR bool operator>= (const array<T,N>& x, const array<T,N>& y) {
|
||||
bool operator>= (const array<T,N>& x, const array<T,N>& y) {
|
||||
return !(x<y);
|
||||
}
|
||||
|
||||
// global swap()
|
||||
template<class T, std::size_t N>
|
||||
BOOST_CXX14_CONSTEXPR inline void swap (array<T,N>& x, array<T,N>& y) {
|
||||
inline void swap (array<T,N>& x, array<T,N>& y) {
|
||||
x.swap(y);
|
||||
}
|
||||
|
||||
// undocumented and obsolete
|
||||
#if defined(__SUNPRO_CC)
|
||||
// Trac ticket #4757; the Sun Solaris compiler can't handle
|
||||
// syntax like 'T(&get_c_array(boost::array<T,N>& arg))[N]'
|
||||
//
|
||||
// We can't just use this for all compilers, because the
|
||||
// borland compilers can't handle this form.
|
||||
namespace detail {
|
||||
template <typename T, std::size_t N> struct c_array
|
||||
{
|
||||
typedef T type[N];
|
||||
};
|
||||
}
|
||||
|
||||
// Specific for boost::array: simply returns its elems data member.
|
||||
template <typename T, std::size_t N>
|
||||
typename detail::c_array<T,N>::type& get_c_array(boost::array<T,N>& arg)
|
||||
{
|
||||
return arg.elems;
|
||||
}
|
||||
|
||||
// Specific for boost::array: simply returns its elems data member.
|
||||
template <typename T, std::size_t N>
|
||||
typename const detail::c_array<T,N>::type& get_c_array(const boost::array<T,N>& arg)
|
||||
{
|
||||
return arg.elems;
|
||||
}
|
||||
#else
|
||||
// Specific for boost::array: simply returns its elems data member.
|
||||
template <typename T, std::size_t N>
|
||||
BOOST_DEPRECATED( "please use `elems` instead" )
|
||||
T(&get_c_array(boost::array<T,N>& arg))[N]
|
||||
{
|
||||
return arg.elems;
|
||||
}
|
||||
|
||||
|
||||
// Const version.
|
||||
template <typename T, std::size_t N>
|
||||
BOOST_DEPRECATED( "please use `elems` instead" )
|
||||
const T(&get_c_array(const boost::array<T,N>& arg))[N]
|
||||
{
|
||||
return arg.elems;
|
||||
}
|
||||
|
||||
template <class It> std::size_t hash_range(It, It);
|
||||
|
||||
template<class T, std::size_t N>
|
||||
std::size_t hash_value(const array<T,N>& arr)
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
// Overload for std::array, assuming that std::array will have
|
||||
// explicit conversion functions as discussed at the WG21 meeting
|
||||
// in Summit, March 2009.
|
||||
template <typename T, std::size_t N>
|
||||
T(&get_c_array(std::array<T,N>& arg))[N]
|
||||
{
|
||||
return boost::hash_range(arr.begin(), arr.end());
|
||||
return static_cast<T(&)[N]>(arg);
|
||||
}
|
||||
|
||||
template <size_t Idx, typename T, size_t N>
|
||||
BOOST_CXX14_CONSTEXPR T &get(boost::array<T,N> &arr) BOOST_NOEXCEPT {
|
||||
BOOST_STATIC_ASSERT_MSG ( Idx < N, "boost::get<>(boost::array &) index out of range" );
|
||||
return arr[Idx];
|
||||
}
|
||||
|
||||
template <size_t Idx, typename T, size_t N>
|
||||
BOOST_CONSTEXPR const T &get(const boost::array<T,N> &arr) BOOST_NOEXCEPT {
|
||||
BOOST_STATIC_ASSERT_MSG ( Idx < N, "boost::get<>(const boost::array &) index out of range" );
|
||||
return arr[Idx];
|
||||
}
|
||||
|
||||
// Const version.
|
||||
template <typename T, std::size_t N>
|
||||
const T(&get_c_array(const std::array<T,N>& arg))[N]
|
||||
{
|
||||
return static_cast<T(&)[N]>(arg);
|
||||
}
|
||||
#endif
|
||||
|
||||
} /* namespace boost */
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
// If we don't have std::array, I'm assuming that we don't have std::get
|
||||
namespace std {
|
||||
template <size_t Idx, typename T, size_t N>
|
||||
BOOST_DEPRECATED( "please use `boost::get` instead" )
|
||||
T &get(boost::array<T,N> &arr) BOOST_NOEXCEPT {
|
||||
BOOST_STATIC_ASSERT_MSG ( Idx < N, "std::get<>(boost::array &) index out of range" );
|
||||
return arr[Idx];
|
||||
}
|
||||
|
||||
template <size_t Idx, typename T, size_t N>
|
||||
BOOST_DEPRECATED( "please use `boost::get` instead" )
|
||||
const T &get(const boost::array<T,N> &arr) BOOST_NOEXCEPT {
|
||||
BOOST_STATIC_ASSERT_MSG ( Idx < N, "std::get<>(const boost::array &) index out of range" );
|
||||
return arr[Idx];
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // #ifndef BOOST_ARRAY_HPP_INCLUDED
|
||||
#endif /*BOOST_ARRAY_HPP*/
|
||||
|
||||
@ -1,13 +1,13 @@
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=doc/html/array.html">
|
||||
<meta http-equiv="refresh" content="0; URL=../../doc/html/array.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="../../doc/html/array.html">doc/html/array.html</a> <hr>
|
||||
<a href="../../doc/html/array.html">../../doc/html/array.html</a> <hr>
|
||||
<p><EFBFBD> Copyright Beman Dawes, 2001</p>
|
||||
<p>Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy
|
||||
at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
|
||||
</body>
|
||||
</html>
|
||||
</html>
|
||||
@ -1,18 +0,0 @@
|
||||
{
|
||||
"key": "array",
|
||||
"name": "Array",
|
||||
"authors": [
|
||||
"Nicolai Josuttis"
|
||||
],
|
||||
"description": "STL compliant container wrapper for arrays of constant size.",
|
||||
"std": [
|
||||
"tr1"
|
||||
],
|
||||
"category": [
|
||||
"Containers"
|
||||
],
|
||||
"maintainers": [
|
||||
"Marshall Clow <marshall -at- idio.com>"
|
||||
],
|
||||
"cxxstd": "03"
|
||||
}
|
||||
@ -1,12 +0,0 @@
|
||||
# Copyright 2018, 2019, 2021, 2022 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
|
||||
|
||||
if(HAVE_BOOST_TEST)
|
||||
|
||||
boost_test_jamfile(FILE Jamfile.v2
|
||||
LINK_LIBRARIES Boost::array Boost::container_hash Boost::core)
|
||||
|
||||
endif()
|
||||
@ -2,66 +2,14 @@
|
||||
#~ 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)
|
||||
|
||||
require-b2 5.0.1 ;
|
||||
import testing ;
|
||||
import-search /boost/config/checks ;
|
||||
import config : requires ;
|
||||
|
||||
#
|
||||
|
||||
run array0.cpp ;
|
||||
run array1.cpp ;
|
||||
run array2.cpp ;
|
||||
run array3.cpp ;
|
||||
run array4.cpp ;
|
||||
run array5.cpp ;
|
||||
run array6.cpp ;
|
||||
run array7.cpp ;
|
||||
|
||||
compile array_constexpr.cpp ;
|
||||
|
||||
compile-fail array_getfail1.cpp ;
|
||||
compile-fail array_getfail2.cpp ;
|
||||
|
||||
run array_hash.cpp
|
||||
: : : [ requires cxx11_noexcept ] ;
|
||||
|
||||
#
|
||||
|
||||
run array_typedef_test.cpp ;
|
||||
run array_elems_test.cpp ;
|
||||
run array_init_test.cpp ;
|
||||
run array_copy_test.cpp ;
|
||||
run array_convert_test.cpp ;
|
||||
run array_data_test.cpp ;
|
||||
run array_iterator_test.cpp ;
|
||||
run array_reverse_test.cpp ;
|
||||
run array_size_test.cpp ;
|
||||
run array_access_test.cpp ;
|
||||
run array_c_array_test.cpp ;
|
||||
run array_fill_test.cpp ;
|
||||
run array_assign_test.cpp ;
|
||||
run array_swap_test.cpp ;
|
||||
run array_swap_test2.cpp ;
|
||||
run array_eq_test.cpp ;
|
||||
run array_lt_test.cpp ;
|
||||
run array_get_test.cpp ;
|
||||
|
||||
# C++11 constexpr
|
||||
|
||||
compile array_init_test_cx.cpp ;
|
||||
compile array_copy_test_cx.cpp ;
|
||||
compile array_data_test_cx.cpp ;
|
||||
compile array_iterator_test_cx.cpp ;
|
||||
compile array_size_test_cx.cpp ;
|
||||
compile array_access_test_cx.cpp ;
|
||||
compile array_get_test_cx.cpp ;
|
||||
|
||||
# C++14 constexpr
|
||||
|
||||
compile array_eq_test_cx.cpp ;
|
||||
compile array_lt_test_cx.cpp ;
|
||||
|
||||
#
|
||||
|
||||
run quick.cpp ;
|
||||
test-suite array :
|
||||
[ run array0.cpp ]
|
||||
[ run array1.cpp ]
|
||||
[ run array2.cpp ]
|
||||
[ run array3.cpp ]
|
||||
[ run array4.cpp ]
|
||||
[ run array5.cpp ]
|
||||
[ run array6.cpp ]
|
||||
;
|
||||
|
||||
@ -5,18 +5,22 @@
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test_trait.hpp>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <boost/array.hpp>
|
||||
|
||||
namespace {
|
||||
unsigned int failed_tests = 0;
|
||||
|
||||
void fail_test( const char * reason ) {
|
||||
++failed_tests;
|
||||
std::cerr << "Test failure " << failed_tests << ": " << reason << std::endl;
|
||||
}
|
||||
|
||||
template< class T >
|
||||
void BadValue( const T & )
|
||||
{
|
||||
BOOST_TEST ( false );
|
||||
fail_test( "Unexpected value" );
|
||||
}
|
||||
|
||||
template< class T >
|
||||
@ -32,24 +36,46 @@ void RunTests()
|
||||
|
||||
// front/back and operator[] must compile, but calling them is undefined
|
||||
// Likewise, all tests below should evaluate to false, avoiding undefined behaviour
|
||||
BOOST_TEST ( test_case.empty());
|
||||
BOOST_TEST ( const_test_case.empty());
|
||||
if( !test_case.empty() ) {
|
||||
BadValue( test_case.front() );
|
||||
}
|
||||
|
||||
BOOST_TEST ( test_case.size() == 0 );
|
||||
BOOST_TEST ( const_test_case.size() == 0 );
|
||||
if( !const_test_case.empty() ) {
|
||||
BadValue( const_test_case.back() );
|
||||
}
|
||||
|
||||
if( test_case.size() > 0 ) {
|
||||
BadValue( test_case[ 0 ] );
|
||||
}
|
||||
|
||||
if( const_test_case.max_size() > 0 ) {
|
||||
BadValue( const_test_case[ 0 ] );
|
||||
}
|
||||
|
||||
// Assert requirements of TR1 6.2.2.4
|
||||
BOOST_TEST ( test_case.begin() == test_case.end());
|
||||
BOOST_TEST ( test_case.cbegin() == test_case.cend());
|
||||
BOOST_TEST ( const_test_case.begin() == const_test_case.end());
|
||||
BOOST_TEST ( const_test_case.cbegin() == const_test_case.cend());
|
||||
if( test_case.begin() != test_case.end() ) {
|
||||
fail_test( "Not an empty range" );
|
||||
}
|
||||
if( test_case.cbegin() != test_case.cend() ) {
|
||||
fail_test( "Not an empty range" );
|
||||
}
|
||||
if( const_test_case.begin() != const_test_case.end() ) {
|
||||
fail_test( "Not an empty range" );
|
||||
}
|
||||
if( const_test_case.cbegin() != const_test_case.cend() ) {
|
||||
fail_test( "Not an empty range" );
|
||||
}
|
||||
|
||||
if( test_case.begin() == const_test_case.begin() ) {
|
||||
fail_test( "iterators for different containers are not distinct" );
|
||||
}
|
||||
|
||||
BOOST_TEST ( test_case.begin() != const_test_case.begin() );
|
||||
if( test_case.data() == const_test_case.data() ) {
|
||||
// Value of data is unspecified in TR1, so no requirement this test pass or fail
|
||||
// However, it must compile!
|
||||
}
|
||||
|
||||
|
||||
// Check can safely use all iterator types with std algorithms
|
||||
std::for_each( test_case.begin(), test_case.end(), BadValue< T > );
|
||||
std::for_each( test_case.rbegin(), test_case.rend(), BadValue< T > );
|
||||
@ -61,12 +87,12 @@ void RunTests()
|
||||
// Check swap is well formed
|
||||
std::swap( test_case, test_case );
|
||||
|
||||
// Check assignment operator and overloads are well formed
|
||||
// Check assigment operator and overloads are well formed
|
||||
test_case = const_test_case;
|
||||
|
||||
// Confirm at() throws the std lib defined exception
|
||||
try {
|
||||
BadValue( test_case.at( 0 ));
|
||||
BadValue( test_case.at( 0 ) );
|
||||
} catch ( const std::out_of_range & ) {
|
||||
}
|
||||
|
||||
@ -84,6 +110,6 @@ int main()
|
||||
RunTests< void * >();
|
||||
RunTests< long double >();
|
||||
RunTests< std::string >();
|
||||
|
||||
return boost::report_errors();
|
||||
return failed_tests;
|
||||
}
|
||||
|
||||
|
||||
@ -15,11 +15,12 @@
|
||||
#include <boost/array.hpp>
|
||||
#include "print.hpp"
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
int main()
|
||||
{
|
||||
// create and initialize array
|
||||
boost::array<int,10> a = { { 1, 2, 3, 4, 5 } };
|
||||
array<int,10> a = { { 1, 2, 3, 4, 5 } };
|
||||
|
||||
print_elements(a);
|
||||
|
||||
|
||||
@ -10,51 +10,39 @@
|
||||
#include <boost/array.hpp>
|
||||
#include <algorithm>
|
||||
|
||||
#include <boost/core/lightweight_test_trait.hpp>
|
||||
|
||||
namespace {
|
||||
template< class T >
|
||||
void RunTests()
|
||||
{
|
||||
typedef boost::array< T, 5 > test_type;
|
||||
typedef T arr[5];
|
||||
test_type test_case; // = { 1, 1, 2, 3, 5 };
|
||||
|
||||
arr &aRef = get_c_array ( test_case );
|
||||
BOOST_TEST ( &*test_case.begin () == &aRef[0] );
|
||||
|
||||
const arr &caRef = get_c_array ( test_case );
|
||||
typename test_type::const_iterator iter = test_case.begin ();
|
||||
BOOST_TEST ( &*iter == &caRef[0] );
|
||||
unsigned int failed_tests = 0;
|
||||
|
||||
// Confirm at() throws the std lib defined exception
|
||||
try {
|
||||
test_case.at( test_case.size());
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
catch ( const std::out_of_range & ) {}
|
||||
|
||||
try {
|
||||
test_case.at( test_case.size() + 1);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
catch ( const std::out_of_range & ) {}
|
||||
|
||||
try {
|
||||
test_case.at( test_case.size() + 100);
|
||||
BOOST_TEST(false);
|
||||
}
|
||||
catch ( const std::out_of_range & ) {}
|
||||
}
|
||||
void fail_test( const char * reason ) {
|
||||
++failed_tests;
|
||||
std::cerr << "Test failure " << failed_tests << ": " << reason << std::endl;
|
||||
}
|
||||
|
||||
int main ()
|
||||
template< class T >
|
||||
void RunTests()
|
||||
{
|
||||
typedef boost::array< T, 5 > test_type;
|
||||
typedef T arr[5];
|
||||
test_type test_case; // = { 1, 1, 2, 3, 5 };
|
||||
|
||||
arr &aRef = get_c_array ( test_case );
|
||||
if ( &*test_case.begin () != &aRef[0] )
|
||||
fail_test ( "Array6: Same thing not equal?(1)" );
|
||||
|
||||
const arr &caRef = get_c_array ( test_case );
|
||||
typename test_type::const_iterator iter = test_case.begin ();
|
||||
if ( &*iter != &caRef[0] )
|
||||
fail_test ( "Array6: Same thing not equal?(2)" );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
RunTests< bool >();
|
||||
RunTests< void * >();
|
||||
RunTests< long double >();
|
||||
RunTests< std::string >();
|
||||
|
||||
return boost::report_errors();
|
||||
return failed_tests;
|
||||
}
|
||||
|
||||
|
||||
@ -1,66 +0,0 @@
|
||||
/* tests using std::get on boost:array
|
||||
* (C) Copyright Marshall Clow 2012
|
||||
* Distributed under the Boost Software License, Version 1.0. (See
|
||||
* accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <boost/array.hpp>
|
||||
#include <algorithm>
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
#include <array>
|
||||
#endif
|
||||
|
||||
#include <boost/core/lightweight_test_trait.hpp>
|
||||
|
||||
namespace {
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
template< class T >
|
||||
void RunStdTests()
|
||||
{
|
||||
typedef boost::array< T, 5 > test_type;
|
||||
test_type test_case; // = { 1, 1, 2, 3, 5 };
|
||||
|
||||
T &aRef = std::get<0> ( test_case );
|
||||
BOOST_TEST ( &*test_case.begin () == &aRef );
|
||||
|
||||
const T &caRef = std::get<0> ( test_case );
|
||||
BOOST_TEST ( &*test_case.cbegin () == &caRef );
|
||||
}
|
||||
#endif
|
||||
|
||||
template< class T >
|
||||
void RunBoostTests()
|
||||
{
|
||||
typedef boost::array< T, 5 > test_type;
|
||||
test_type test_case; // = { 1, 1, 2, 3, 5 };
|
||||
|
||||
T &aRef = boost::get<0> ( test_case );
|
||||
BOOST_TEST ( &*test_case.begin () == &aRef );
|
||||
|
||||
const T &caRef = boost::get<0> ( test_case );
|
||||
BOOST_TEST ( &*test_case.cbegin () == &caRef );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
RunBoostTests< bool >();
|
||||
RunBoostTests< void * >();
|
||||
RunBoostTests< long double >();
|
||||
RunBoostTests< std::string >();
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
RunStdTests< bool >();
|
||||
RunStdTests< void * >();
|
||||
RunStdTests< long double >();
|
||||
RunStdTests< std::string >();
|
||||
#endif
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@ -1,117 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#define BOOST_ENABLE_ASSERT_HANDLER
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
struct assertion_failure
|
||||
{
|
||||
};
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
void assertion_failed( char const* /*expr*/, char const* /*function*/, char const* /*file*/, long /*line*/ )
|
||||
{
|
||||
throw assertion_failure();
|
||||
}
|
||||
|
||||
void assertion_failed_msg( char const* /*expr*/, char const* /*msg*/, char const* /*function*/, char const* /*file*/, long /*line*/ )
|
||||
{
|
||||
throw assertion_failure();
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
{
|
||||
boost::array<T, N> a = {{}};
|
||||
|
||||
T* p1 = a.data();
|
||||
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
T* p2 = &a[ i ];
|
||||
T* p3 = &a.at( i );
|
||||
|
||||
BOOST_TEST_EQ( p2, p1 + i );
|
||||
BOOST_TEST_EQ( p3, p1 + i );
|
||||
}
|
||||
|
||||
{
|
||||
T* p2 = &a.front();
|
||||
T* p3 = &a.back();
|
||||
|
||||
BOOST_TEST_EQ( p2, p1 + 0 );
|
||||
BOOST_TEST_EQ( p3, p1 + N - 1 );
|
||||
}
|
||||
|
||||
BOOST_TEST_THROWS( a.at( N ), std::out_of_range );
|
||||
BOOST_TEST_THROWS( a[ N ], assertion_failure );
|
||||
}
|
||||
|
||||
{
|
||||
boost::array<T, N> const a = {{}};
|
||||
|
||||
T const* p1 = a.data();
|
||||
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
T const* p2 = &a[ i ];
|
||||
T const* p3 = &a.at( i );
|
||||
|
||||
BOOST_TEST_EQ( p2, p1 + i );
|
||||
BOOST_TEST_EQ( p3, p1 + i );
|
||||
}
|
||||
|
||||
{
|
||||
T const* p2 = &a.front();
|
||||
T const* p3 = &a.back();
|
||||
|
||||
BOOST_TEST_EQ( p2, p1 + 0 );
|
||||
BOOST_TEST_EQ( p3, p1 + N - 1 );
|
||||
}
|
||||
|
||||
BOOST_TEST_THROWS( a.at( N ), std::out_of_range );
|
||||
BOOST_TEST_THROWS( a[ N ], assertion_failure );
|
||||
}
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
{
|
||||
boost::array<T, 0> a = {};
|
||||
|
||||
BOOST_TEST_THROWS( a.at( 0 ), std::out_of_range );
|
||||
BOOST_TEST_THROWS( a[ 0 ], std::out_of_range );
|
||||
BOOST_TEST_THROWS( a.front(), std::out_of_range );
|
||||
BOOST_TEST_THROWS( a.back(), std::out_of_range );
|
||||
}
|
||||
|
||||
{
|
||||
boost::array<T, 0> const a = {};
|
||||
|
||||
BOOST_TEST_THROWS( a.at( 0 ), std::out_of_range );
|
||||
BOOST_TEST_THROWS( a[ 0 ], std::out_of_range );
|
||||
BOOST_TEST_THROWS( a.front(), std::out_of_range );
|
||||
BOOST_TEST_THROWS( a.back(), std::out_of_range );
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
test<int const, 1>();
|
||||
test<int const, 7>();
|
||||
|
||||
test2<int>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,50 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
#if defined(BOOST_NO_CXX11_CONSTEXPR)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_NO_CXX11_CONSTEXPR is defined")
|
||||
|
||||
#elif BOOST_WORKAROUND(BOOST_MSVC, < 1910)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_MSVC < 1910")
|
||||
|
||||
#elif BOOST_WORKAROUND(BOOST_GCC, < 50000)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_GCC < 50000")
|
||||
|
||||
#else
|
||||
|
||||
#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
|
||||
|
||||
template<class T> void test()
|
||||
{
|
||||
constexpr boost::array<T, 4> a = {{}};
|
||||
|
||||
STATIC_ASSERT( &a[ 0 ] == a.data() + 0 );
|
||||
STATIC_ASSERT( &a[ 1 ] == a.data() + 1 );
|
||||
STATIC_ASSERT( &a[ 2 ] == a.data() + 2 );
|
||||
STATIC_ASSERT( &a[ 3 ] == a.data() + 3 );
|
||||
|
||||
STATIC_ASSERT( &a.at( 0 ) == a.data() + 0 );
|
||||
STATIC_ASSERT( &a.at( 1 ) == a.data() + 1 );
|
||||
STATIC_ASSERT( &a.at( 2 ) == a.data() + 2 );
|
||||
STATIC_ASSERT( &a.at( 3 ) == a.data() + 3 );
|
||||
|
||||
STATIC_ASSERT( &a.front() == a.data() );
|
||||
STATIC_ASSERT( &a.back() == a.data() + 3 );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int>();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,60 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
// assign is a nonstandard equivalent of fill
|
||||
// it probably needs to be deprecated and removed
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
boost::array<T, N> a = {};
|
||||
|
||||
a.assign( 1 );
|
||||
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
BOOST_TEST_EQ( a[i], 1 );
|
||||
}
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
boost::array<T, 4> a = {{ 1, 2, 3, 4 }};
|
||||
|
||||
a.assign( 5 );
|
||||
|
||||
for( std::size_t i = 0; i < 4; ++i )
|
||||
{
|
||||
BOOST_TEST_EQ( a[i], 5 );
|
||||
}
|
||||
}
|
||||
|
||||
template<class T> void test3()
|
||||
{
|
||||
boost::array<T, 4> a = {{ 1, 2, 3, 4 }};
|
||||
|
||||
// aliasing
|
||||
a.assign( a[ 1 ] );
|
||||
|
||||
for( std::size_t i = 0; i < 4; ++i )
|
||||
{
|
||||
BOOST_TEST_EQ( a[i], 2 );
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int, 0>();
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
test2<int>();
|
||||
|
||||
test3<int>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,70 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
// c_array and get_c_array are nonstandard extensions
|
||||
// probably need to be deprecated and removed
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
boost::array<T, N> a = {};
|
||||
|
||||
T* p1 = a.c_array();
|
||||
T* p2 = a.data();
|
||||
|
||||
BOOST_TEST_EQ( p1, p2 );
|
||||
}
|
||||
|
||||
template<class T, std::size_t N> void test2()
|
||||
{
|
||||
{
|
||||
boost::array<T, N> a = {{}};
|
||||
|
||||
T (&e1)[ N ] = boost::get_c_array( a );
|
||||
T (&e2)[ N ] = a.elems;
|
||||
|
||||
BOOST_TEST_EQ( static_cast<T*>( e1 ), static_cast<T*>( e2 ) );
|
||||
}
|
||||
{
|
||||
boost::array<T, N> const a = {{}};
|
||||
|
||||
T const (&e1)[ N ] = boost::get_c_array( a );
|
||||
T const (&e2)[ N ] = a.elems;
|
||||
|
||||
BOOST_TEST_EQ( static_cast<T const*>( e1 ), static_cast<T const*>( e2 ) );
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int, 0>();
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
test<int const, 0>();
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1910) || BOOST_WORKAROUND(BOOST_GCC, < 50000)
|
||||
|
||||
// = {} doesn't work for const T
|
||||
|
||||
#else
|
||||
|
||||
test<int const, 1>();
|
||||
test<int const, 7>();
|
||||
|
||||
#endif
|
||||
|
||||
test2<int, 1>();
|
||||
test2<int, 7>();
|
||||
|
||||
test2<int const, 1>();
|
||||
test2<int const, 7>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,29 +0,0 @@
|
||||
/* tests using constexpr on boost:array
|
||||
* (C) Copyright Marshall Clow 2012
|
||||
* Distributed under the Boost Software License, Version 1.0. (See
|
||||
* accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#ifndef BOOST_NO_CXX11_CONSTEXPR
|
||||
|
||||
constexpr boost::array<int, 10> arr {{ 0,1,2,3,4,5,6,7,8,9 }};
|
||||
|
||||
int main()
|
||||
{
|
||||
constexpr int three = arr.at (3);
|
||||
int whatever [ arr.at(4) ];
|
||||
(void)three;
|
||||
(void) whatever;
|
||||
}
|
||||
|
||||
#else // no constexpr means no constexpr tests!
|
||||
|
||||
int main()
|
||||
{
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,38 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, class U, std::size_t N> void test2()
|
||||
{
|
||||
boost::array<T, N> a1 = {};
|
||||
|
||||
boost::array<U, N> a2;
|
||||
a2 = a1;
|
||||
|
||||
BOOST_TEST_ALL_EQ( a1.begin(), a1.end(), a2.begin(), a2.end() );
|
||||
}
|
||||
|
||||
template<class T, class U> void test4()
|
||||
{
|
||||
boost::array<T, 4> a1 = { 1, 2, 3, 4 };
|
||||
|
||||
boost::array<U, 4> a2;
|
||||
a2 = a1;
|
||||
|
||||
BOOST_TEST_ALL_EQ( a1.begin(), a1.end(), a2.begin(), a2.end() );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test2<int, long, 0>();
|
||||
test2<int, long, 1>();
|
||||
test2<int, long, 7>();
|
||||
|
||||
test4<int, long>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,65 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test1()
|
||||
{
|
||||
boost::array<T, N> a1 = {{}};
|
||||
boost::array<T, N> a2 = a1;
|
||||
|
||||
BOOST_TEST_ALL_EQ( a1.begin(), a1.end(), a2.begin(), a2.end() );
|
||||
}
|
||||
|
||||
template<class T, std::size_t N> void test2()
|
||||
{
|
||||
boost::array<T, N> a1 = {};
|
||||
|
||||
boost::array<T, N> a2;
|
||||
a2 = a1;
|
||||
|
||||
BOOST_TEST_ALL_EQ( a1.begin(), a1.end(), a2.begin(), a2.end() );
|
||||
}
|
||||
|
||||
template<class T> void test3()
|
||||
{
|
||||
boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
|
||||
boost::array<T, 4> a2 = a1;
|
||||
|
||||
BOOST_TEST_ALL_EQ( a1.begin(), a1.end(), a2.begin(), a2.end() );
|
||||
}
|
||||
|
||||
template<class T> void test4()
|
||||
{
|
||||
boost::array<T, 4> a1 = { 1, 2, 3, 4 };
|
||||
|
||||
boost::array<T, 4> a2;
|
||||
a2 = a1;
|
||||
|
||||
BOOST_TEST_ALL_EQ( a1.begin(), a1.end(), a2.begin(), a2.end() );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// test1<int, 0>();
|
||||
test1<int, 1>();
|
||||
test1<int, 7>();
|
||||
|
||||
// test1<int const, 0>();
|
||||
test1<int const, 1>();
|
||||
test1<int const, 7>();
|
||||
|
||||
test2<int, 0>();
|
||||
test2<int, 1>();
|
||||
test2<int, 7>();
|
||||
|
||||
test3<int>();
|
||||
test3<int const>();
|
||||
|
||||
test4<int>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,58 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
#if defined(BOOST_NO_CXX11_CONSTEXPR)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_NO_CXX11_CONSTEXPR is defined")
|
||||
|
||||
#elif BOOST_WORKAROUND(BOOST_GCC, < 50000)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_GCC < 50000")
|
||||
|
||||
#else
|
||||
|
||||
#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
|
||||
|
||||
template<class T> void test1()
|
||||
{
|
||||
constexpr boost::array<T, 2> a1 = {};
|
||||
constexpr boost::array<T, 2> a2 = a1;
|
||||
|
||||
STATIC_ASSERT( a1[0] == a2[0] );
|
||||
STATIC_ASSERT( a1[1] == a2[1] );
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
constexpr boost::array<T, 3> a1 = {{ 1, 2, 3 }};
|
||||
constexpr boost::array<T, 3> a2 = a1;
|
||||
|
||||
STATIC_ASSERT( a1[0] == a2[0] );
|
||||
STATIC_ASSERT( a1[1] == a2[1] );
|
||||
STATIC_ASSERT( a1[2] == a2[2] );
|
||||
}
|
||||
|
||||
template<class T> void test3()
|
||||
{
|
||||
constexpr boost::array<T, 0> a1 = {};
|
||||
constexpr boost::array<T, 0> a2 = a1;
|
||||
|
||||
(void)a1;
|
||||
(void)a2;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test1<int>();
|
||||
test2<int>();
|
||||
test3<int>();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,41 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
{
|
||||
boost::array<T, N> a = {{}};
|
||||
|
||||
T* p1 = a.data();
|
||||
T* p2 = a.elems;
|
||||
|
||||
BOOST_TEST_EQ( p1, p2 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::array<T, N> const a = {{}};
|
||||
|
||||
T const* p1 = a.data();
|
||||
T const* p2 = a.elems;
|
||||
|
||||
BOOST_TEST_EQ( p1, p2 );
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// test<int, 0>();
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
// test<int const, 0>();
|
||||
test<int const, 1>();
|
||||
test<int const, 7>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,47 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
#if defined(BOOST_NO_CXX11_CONSTEXPR)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_NO_CXX11_CONSTEXPR is defined")
|
||||
|
||||
#elif BOOST_WORKAROUND(BOOST_MSVC, < 1910)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_MSVC < 1910")
|
||||
|
||||
#elif BOOST_WORKAROUND(BOOST_GCC, < 50000)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_GCC < 50000")
|
||||
|
||||
#else
|
||||
|
||||
#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
|
||||
|
||||
template<class T, std::size_t N> void test1()
|
||||
{
|
||||
constexpr boost::array<T, N> a = {};
|
||||
STATIC_ASSERT( a.data() == a.elems );
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
constexpr boost::array<T, 0> a = {};
|
||||
STATIC_ASSERT( a.data() == 0 );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test1<int, 1>();
|
||||
test1<int, 7>();
|
||||
|
||||
test2<int>();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,27 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
boost::array<T, N> a = {{}};
|
||||
|
||||
T (&e)[ N ] = a.elems;
|
||||
|
||||
BOOST_TEST_EQ( static_cast<void const*>( e ), static_cast<void const*>( &a ) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
test<int const, 1>();
|
||||
test<int const, 7>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,83 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
{
|
||||
boost::array<T, N> const a1 = {};
|
||||
boost::array<T, N> const a2 = {};
|
||||
|
||||
BOOST_TEST( a1 == a2 );
|
||||
BOOST_TEST_NOT( a1 != a2 );
|
||||
}
|
||||
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
boost::array<T, N> const a1 = {};
|
||||
|
||||
boost::array<T, N> a2 = a1;
|
||||
a2[ i ] = 1;
|
||||
|
||||
BOOST_TEST( a1 != a2 );
|
||||
BOOST_TEST_NOT( a1 == a2 );
|
||||
|
||||
boost::array<T, N> const a3 = a2;
|
||||
|
||||
BOOST_TEST( a1 != a3 );
|
||||
BOOST_TEST_NOT( a1 == a3 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::array<T, N> a1 = {};
|
||||
boost::array<T, N> a2 = {};
|
||||
|
||||
a1.fill( 1 );
|
||||
a2.fill( 1 );
|
||||
|
||||
BOOST_TEST( a1 == a2 );
|
||||
BOOST_TEST_NOT( a1 != a2 );
|
||||
}
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
{
|
||||
boost::array<T, 4> const a1 = {{ 1, 2, 3, 4 }};
|
||||
boost::array<T, 4> const a2 = {{ 1, 2, 3, 4 }};
|
||||
|
||||
BOOST_TEST( a1 == a2 );
|
||||
BOOST_TEST_NOT( a1 != a2 );
|
||||
}
|
||||
|
||||
for( std::size_t i = 0; i < 4; ++i )
|
||||
{
|
||||
boost::array<T, 4> const a1 = {{ 1, 2, 3, 4 }};
|
||||
|
||||
boost::array<T, 4> a2 = a1;
|
||||
a2[ i ] = 0;
|
||||
|
||||
BOOST_TEST( a1 != a2 );
|
||||
BOOST_TEST_NOT( a1 == a2 );
|
||||
|
||||
boost::array<T, 4> const a3 = a2;
|
||||
|
||||
BOOST_TEST( a1 != a3 );
|
||||
BOOST_TEST_NOT( a1 == a3 );
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int, 0>();
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
test2<int>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,55 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
#if defined(BOOST_NO_CXX14_CONSTEXPR)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined")
|
||||
|
||||
#else
|
||||
|
||||
#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
|
||||
|
||||
template<class T, std::size_t N> void test1()
|
||||
{
|
||||
constexpr boost::array<T, N> a1 = {};
|
||||
constexpr boost::array<T, N> a2 = {};
|
||||
|
||||
STATIC_ASSERT( a1 == a2 );
|
||||
STATIC_ASSERT( !( a1 != a2 ) );
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
{
|
||||
constexpr boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
|
||||
constexpr boost::array<T, 4> a2 = {{ 1, 2, 3, 4 }};
|
||||
|
||||
STATIC_ASSERT( a1 == a2 );
|
||||
STATIC_ASSERT( !( a1 != a2 ) );
|
||||
}
|
||||
{
|
||||
constexpr boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
|
||||
constexpr boost::array<T, 4> a2 = {{ 1, 2, 3, 5 }};
|
||||
|
||||
STATIC_ASSERT( !( a1 == a2 ) );
|
||||
STATIC_ASSERT( a1 != a2 );
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test1<int, 0>();
|
||||
test1<int, 1>();
|
||||
test1<int, 7>();
|
||||
|
||||
test2<int>();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,57 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
boost::array<T, N> a = {};
|
||||
|
||||
a.fill( 1 );
|
||||
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
BOOST_TEST_EQ( a[i], 1 );
|
||||
}
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
boost::array<T, 4> a = {{ 1, 2, 3, 4 }};
|
||||
|
||||
a.fill( 5 );
|
||||
|
||||
for( std::size_t i = 0; i < 4; ++i )
|
||||
{
|
||||
BOOST_TEST_EQ( a[i], 5 );
|
||||
}
|
||||
}
|
||||
|
||||
template<class T> void test3()
|
||||
{
|
||||
boost::array<T, 4> a = {{ 1, 2, 3, 4 }};
|
||||
|
||||
// aliasing
|
||||
a.fill( a[ 1 ] );
|
||||
|
||||
for( std::size_t i = 0; i < 4; ++i )
|
||||
{
|
||||
BOOST_TEST_EQ( a[i], 2 );
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int, 0>();
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
test2<int>();
|
||||
|
||||
test3<int>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,40 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T> void test()
|
||||
{
|
||||
{
|
||||
boost::array<T, 4> const a = {{ 1, 2, 3, 4 }};
|
||||
|
||||
BOOST_TEST_EQ( boost::get<0>( a ), 1 );
|
||||
BOOST_TEST_EQ( boost::get<1>( a ), 2 );
|
||||
BOOST_TEST_EQ( boost::get<2>( a ), 3 );
|
||||
BOOST_TEST_EQ( boost::get<3>( a ), 4 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::array<T, 4> a = {{ 1, 2, 3, 4 }};
|
||||
|
||||
boost::get<0>( a ) += 1;
|
||||
boost::get<1>( a ) += 2;
|
||||
boost::get<2>( a ) += 3;
|
||||
boost::get<3>( a ) += 4;
|
||||
|
||||
BOOST_TEST_EQ( boost::get<0>( a ), 2 );
|
||||
BOOST_TEST_EQ( boost::get<1>( a ), 4 );
|
||||
BOOST_TEST_EQ( boost::get<2>( a ), 6 );
|
||||
BOOST_TEST_EQ( boost::get<3>( a ), 8 );
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,42 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
#if defined(BOOST_NO_CXX11_CONSTEXPR)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_NO_CXX11_CONSTEXPR is defined")
|
||||
|
||||
#elif BOOST_WORKAROUND(BOOST_MSVC, < 1910)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_MSVC < 1910")
|
||||
|
||||
#elif BOOST_WORKAROUND(BOOST_GCC, < 50000)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_GCC < 50000")
|
||||
|
||||
#else
|
||||
|
||||
#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
|
||||
|
||||
template<class T> void test()
|
||||
{
|
||||
constexpr boost::array<T, 4> a = {{ 1, 2, 3, 4 }};
|
||||
|
||||
STATIC_ASSERT( boost::get<0>( a ) == 1 );
|
||||
STATIC_ASSERT( boost::get<1>( a ) == 2 );
|
||||
STATIC_ASSERT( boost::get<2>( a ) == 3 );
|
||||
STATIC_ASSERT( boost::get<3>( a ) == 4 );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int>();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,50 +0,0 @@
|
||||
/* tests using std::get on boost:array
|
||||
* (C) Copyright Marshall Clow 2012
|
||||
* Distributed under the Boost Software License, Version 1.0. (See
|
||||
* accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
#include <array>
|
||||
#endif
|
||||
|
||||
#include <boost/core/lightweight_test_trait.hpp>
|
||||
|
||||
namespace {
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
template< class T >
|
||||
void RunStdTests()
|
||||
{
|
||||
typedef boost::array< T, 5 > test_type;
|
||||
typedef T arr[5];
|
||||
test_type test_case; // = { 1, 1, 2, 3, 5 };
|
||||
|
||||
T &aRef = std::get<5> ( test_case ); // should fail to compile
|
||||
BOOST_TEST ( &*test_case.begin () == &aRef );
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
RunStdTests< bool >();
|
||||
RunStdTests< void * >();
|
||||
RunStdTests< long double >();
|
||||
RunStdTests< std::string >();
|
||||
#else
|
||||
BOOST_STATIC_ASSERT ( false ); // fail on C++03 systems.
|
||||
#endif
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,65 +0,0 @@
|
||||
/* tests using std::get on boost:array
|
||||
* (C) Copyright Marshall Clow 2012
|
||||
* Distributed under the Boost Software License, Version 1.0. (See
|
||||
* accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <boost/array.hpp>
|
||||
#include <algorithm>
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
#include <array>
|
||||
#endif
|
||||
|
||||
#include <boost/core/lightweight_test_trait.hpp>
|
||||
|
||||
namespace {
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
template< class T >
|
||||
void RunStdTests()
|
||||
{
|
||||
typedef boost::array< T, 5 > test_type;
|
||||
typedef T arr[5];
|
||||
test_type test_case; // = { 1, 1, 2, 3, 5 };
|
||||
|
||||
T &aRef = std::get<0> ( test_case );
|
||||
BOOST_TEST ( &*test_case.begin () == &aRef );
|
||||
|
||||
const T &caRef = std::get<0> ( test_case );
|
||||
BOOST_TEST ( &*test_case.cbegin () == &caRef );
|
||||
}
|
||||
#endif
|
||||
|
||||
template< class T >
|
||||
void RunBoostTests()
|
||||
{
|
||||
typedef boost::array< T, 5 > test_type;
|
||||
typedef T arr[5];
|
||||
test_type test_case; // = { 1, 1, 2, 3, 5 };
|
||||
|
||||
T &aRef = boost::get<5> ( test_case );
|
||||
BOOST_TEST ( &*test_case.begin () == &aRef );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
RunBoostTests< bool >();
|
||||
RunBoostTests< void * >();
|
||||
RunBoostTests< long double >();
|
||||
RunBoostTests< std::string >();
|
||||
|
||||
#ifndef BOOST_NO_CXX11_HDR_ARRAY
|
||||
RunStdTests< bool >();
|
||||
RunStdTests< void * >();
|
||||
RunStdTests< long double >();
|
||||
RunStdTests< std::string >();
|
||||
#endif
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@ -1,44 +0,0 @@
|
||||
/* tests for using boost::hash with boost::array
|
||||
* (C) Copyright Marshall Clow 2012
|
||||
* Distributed under the Boost Software License, Version 1.0. (See
|
||||
* accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <boost/array.hpp>
|
||||
#include <algorithm>
|
||||
#include <boost/functional/hash.hpp>
|
||||
|
||||
#include <boost/core/lightweight_test_trait.hpp>
|
||||
|
||||
namespace {
|
||||
|
||||
template< class T >
|
||||
void RunTests()
|
||||
{
|
||||
// std::size_t hash0 = boost::hash<boost::array<T,0> > () ( boost::array<T, 0> ());
|
||||
// std::size_t hash1 = boost::hash<boost::array<T,1> > () ( boost::array<T, 1> ());
|
||||
|
||||
typedef boost::array< T, 5 > barr;
|
||||
typedef T arr[5];
|
||||
barr test_barr = {{ 1, 1, 2, 3, 5 }};
|
||||
arr test_arr = { 1, 1, 2, 3, 5 };
|
||||
|
||||
std::size_t bhash = boost::hash<barr> () ( test_barr );
|
||||
std::size_t ahash = boost::hash<arr> () ( test_arr );
|
||||
BOOST_TEST ( ahash == bhash );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
RunTests< int >();
|
||||
RunTests< long >();
|
||||
RunTests< long double >();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@ -1,81 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test1()
|
||||
{
|
||||
boost::array<T, N> a = {{}};
|
||||
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
BOOST_TEST_EQ( a[i], T() );
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, std::size_t N> void test2()
|
||||
{
|
||||
boost::array<T, N> a = {};
|
||||
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
BOOST_TEST_EQ( a[i], T() );
|
||||
}
|
||||
}
|
||||
|
||||
template<class T> void test3()
|
||||
{
|
||||
boost::array<T, 4> a = {{ 1, 2, 3, 4 }};
|
||||
T b[ 4 ] = { 1, 2, 3, 4 };
|
||||
|
||||
BOOST_TEST_ALL_EQ( a.begin(), a.end(), b + 0, b + 4 );
|
||||
}
|
||||
|
||||
template<class T> void test4()
|
||||
{
|
||||
boost::array<T, 4> a = { 1, 2, 3, 4 };
|
||||
T b[ 4 ] = { 1, 2, 3, 4 };
|
||||
|
||||
BOOST_TEST_ALL_EQ( a.begin(), a.end(), b + 0, b + 4 );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// test1<int, 0>();
|
||||
test1<int, 1>();
|
||||
test1<int, 7>();
|
||||
|
||||
// test1<int const, 0>();
|
||||
test1<int const, 1>();
|
||||
test1<int const, 7>();
|
||||
|
||||
test2<int, 0>();
|
||||
test2<int, 1>();
|
||||
test2<int, 7>();
|
||||
|
||||
// test2<int const, 0>();
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, < 1910) || BOOST_WORKAROUND(BOOST_GCC, < 50000)
|
||||
|
||||
// = {} doesn't work for const T
|
||||
|
||||
#else
|
||||
|
||||
test2<int const, 1>();
|
||||
test2<int const, 7>();
|
||||
|
||||
#endif
|
||||
|
||||
test3<int>();
|
||||
test3<int const>();
|
||||
|
||||
test4<int>();
|
||||
test4<int const>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,78 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
#if defined(BOOST_NO_CXX11_CONSTEXPR)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_NO_CXX11_CONSTEXPR is defined")
|
||||
|
||||
#elif BOOST_WORKAROUND(BOOST_GCC, < 50000)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_GCC < 50000")
|
||||
|
||||
#else
|
||||
|
||||
#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
|
||||
|
||||
template<class T> void test1()
|
||||
{
|
||||
constexpr boost::array<T, 1> a = {{}};
|
||||
|
||||
STATIC_ASSERT( a[0] == 0 );
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
constexpr boost::array<T, 2> a = {};
|
||||
|
||||
STATIC_ASSERT( a[0] == 0 );
|
||||
STATIC_ASSERT( a[1] == 0 );
|
||||
}
|
||||
|
||||
template<class T> void test3()
|
||||
{
|
||||
constexpr boost::array<T, 3> a = {{ 1, 2, 3 }};
|
||||
|
||||
STATIC_ASSERT( a[0] == 1 );
|
||||
STATIC_ASSERT( a[1] == 2 );
|
||||
STATIC_ASSERT( a[2] == 3 );
|
||||
}
|
||||
|
||||
template<class T> void test4()
|
||||
{
|
||||
constexpr boost::array<T, 4> a = { 1, 2, 3, 4 };
|
||||
|
||||
STATIC_ASSERT( a[0] == 1 );
|
||||
STATIC_ASSERT( a[1] == 2 );
|
||||
STATIC_ASSERT( a[2] == 3 );
|
||||
STATIC_ASSERT( a[3] == 4 );
|
||||
}
|
||||
|
||||
template<class T> void test5()
|
||||
{
|
||||
// constexpr boost::array<T, 0> a = {{}};
|
||||
}
|
||||
|
||||
template<class T> void test6()
|
||||
{
|
||||
constexpr boost::array<T, 0> a = {};
|
||||
(void)a;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test1<int>();
|
||||
test2<int>();
|
||||
test3<int>();
|
||||
test4<int>();
|
||||
test5<int>();
|
||||
test6<int>();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,108 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
{
|
||||
boost::array<T, N> a = {{}};
|
||||
|
||||
T* p1 = a.data();
|
||||
|
||||
{
|
||||
T* p2 = a.begin();
|
||||
T* p3 = a.end();
|
||||
|
||||
BOOST_TEST_EQ( p2, p1 );
|
||||
BOOST_TEST_EQ( p3, p1 + N );
|
||||
}
|
||||
|
||||
{
|
||||
T const* p2 = a.cbegin();
|
||||
T const* p3 = a.cend();
|
||||
|
||||
BOOST_TEST_EQ( p2, p1 );
|
||||
BOOST_TEST_EQ( p3, p1 + N );
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
boost::array<T, N> const a = {{}};
|
||||
|
||||
T const* p1 = a.data();
|
||||
|
||||
{
|
||||
T const* p2 = a.begin();
|
||||
T const* p3 = a.end();
|
||||
|
||||
BOOST_TEST_EQ( p2, p1 );
|
||||
BOOST_TEST_EQ( p3, p1 + N );
|
||||
}
|
||||
|
||||
{
|
||||
T const* p2 = a.cbegin();
|
||||
T const* p3 = a.cend();
|
||||
|
||||
BOOST_TEST_EQ( p2, p1 );
|
||||
BOOST_TEST_EQ( p3, p1 + N );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
{
|
||||
boost::array<T, 0> a = {};
|
||||
|
||||
{
|
||||
T* p2 = a.begin();
|
||||
T* p3 = a.end();
|
||||
|
||||
BOOST_TEST_EQ( p2, p3 );
|
||||
}
|
||||
|
||||
{
|
||||
T const* p2 = a.cbegin();
|
||||
T const* p3 = a.cend();
|
||||
|
||||
BOOST_TEST_EQ( p2, p3 );
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
boost::array<T, 0> const a = {};
|
||||
|
||||
{
|
||||
T const* p2 = a.begin();
|
||||
T const* p3 = a.end();
|
||||
|
||||
BOOST_TEST_EQ( p2, p3 );
|
||||
}
|
||||
|
||||
{
|
||||
T const* p2 = a.cbegin();
|
||||
T const* p3 = a.cend();
|
||||
|
||||
BOOST_TEST_EQ( p2, p3 );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// test<int, 0>();
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
// test<int const, 0>();
|
||||
test<int const, 1>();
|
||||
test<int const, 7>();
|
||||
|
||||
test2<int>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,58 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
#if defined(BOOST_NO_CXX11_CONSTEXPR)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_NO_CXX11_CONSTEXPR is defined")
|
||||
|
||||
#elif BOOST_WORKAROUND(BOOST_MSVC, < 1910)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_MSVC < 1910")
|
||||
|
||||
#elif BOOST_WORKAROUND(BOOST_GCC, < 50000)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_GCC < 50000")
|
||||
|
||||
#else
|
||||
|
||||
#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
|
||||
|
||||
template<class T, std::size_t N> void test1()
|
||||
{
|
||||
constexpr boost::array<T, N> a = {};
|
||||
|
||||
STATIC_ASSERT( a.begin() == a.data() );
|
||||
STATIC_ASSERT( a.end() == a.data() + N );
|
||||
|
||||
STATIC_ASSERT( a.cbegin() == a.data() );
|
||||
STATIC_ASSERT( a.cend() == a.data() + N );
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
constexpr boost::array<T, 0> a = {};
|
||||
|
||||
// iterator access is not constexpr for boost::array<T, 0>
|
||||
// it is for std::array<T, 0>, though, so we should change it
|
||||
|
||||
STATIC_ASSERT( a.begin() == a.end() );
|
||||
STATIC_ASSERT( a.cbegin() == a.cend() );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// test1<int, 0>();
|
||||
test1<int, 1>();
|
||||
test1<int, 7>();
|
||||
|
||||
// test2<int>();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,85 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
{
|
||||
boost::array<T, N> const a1 = {};
|
||||
boost::array<T, N> const a2 = {};
|
||||
|
||||
BOOST_TEST_NOT( a1 < a2 );
|
||||
BOOST_TEST_NOT( a1 > a2 );
|
||||
BOOST_TEST( a1 <= a2 );
|
||||
BOOST_TEST( a1 >= a2 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::array<T, N> a1;
|
||||
boost::array<T, N> a2;
|
||||
|
||||
a1.fill( 1 );
|
||||
a2.fill( 1 );
|
||||
|
||||
BOOST_TEST_NOT( a1 < a2 );
|
||||
BOOST_TEST_NOT( a1 > a2 );
|
||||
BOOST_TEST( a1 <= a2 );
|
||||
BOOST_TEST( a1 >= a2 );
|
||||
}
|
||||
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
boost::array<T, N> a1;
|
||||
boost::array<T, N> a2;
|
||||
|
||||
a1.fill( 1 );
|
||||
a2.fill( 1 );
|
||||
|
||||
a1[ i ] = 0;
|
||||
|
||||
BOOST_TEST( a1 < a2 );
|
||||
BOOST_TEST( a1 <= a2 );
|
||||
BOOST_TEST_NOT( a1 > a2 );
|
||||
BOOST_TEST_NOT( a1 >= a2 );
|
||||
|
||||
{
|
||||
boost::array<T, N> const a3 = a1;
|
||||
boost::array<T, N> const a4 = a2;
|
||||
|
||||
BOOST_TEST( a3 < a4 );
|
||||
BOOST_TEST( a3 <= a4 );
|
||||
BOOST_TEST_NOT( a3 > a4 );
|
||||
BOOST_TEST_NOT( a3 >= a4 );
|
||||
}
|
||||
|
||||
a1[ i ] = 2;
|
||||
|
||||
BOOST_TEST( a1 > a2 );
|
||||
BOOST_TEST( a1 >= a2 );
|
||||
BOOST_TEST_NOT( a1 < a2 );
|
||||
BOOST_TEST_NOT( a1 <= a2 );
|
||||
|
||||
{
|
||||
boost::array<T, N> const a3 = a1;
|
||||
boost::array<T, N> const a4 = a2;
|
||||
|
||||
BOOST_TEST( a3 > a4 );
|
||||
BOOST_TEST( a3 >= a4 );
|
||||
BOOST_TEST_NOT( a3 < a4 );
|
||||
BOOST_TEST_NOT( a3 <= a4 );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int, 0>();
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,74 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
#if defined(BOOST_NO_CXX14_CONSTEXPR)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined")
|
||||
|
||||
#else
|
||||
|
||||
#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
|
||||
|
||||
template<class T, std::size_t N> void test1()
|
||||
{
|
||||
constexpr boost::array<T, N> a1 = {};
|
||||
constexpr boost::array<T, N> a2 = {};
|
||||
|
||||
STATIC_ASSERT( !( a1 < a2 ) );
|
||||
STATIC_ASSERT( !( a1 > a2 ) );
|
||||
|
||||
STATIC_ASSERT( a1 <= a2 );
|
||||
STATIC_ASSERT( a1 >= a2 );
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
{
|
||||
constexpr boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
|
||||
constexpr boost::array<T, 4> a2 = {{ 1, 2, 3, 4 }};
|
||||
|
||||
STATIC_ASSERT( !( a1 < a2 ) );
|
||||
STATIC_ASSERT( !( a1 > a2 ) );
|
||||
|
||||
STATIC_ASSERT( a1 <= a2 );
|
||||
STATIC_ASSERT( a1 >= a2 );
|
||||
}
|
||||
{
|
||||
constexpr boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
|
||||
constexpr boost::array<T, 4> a2 = {{ 1, 2, 3, 5 }};
|
||||
|
||||
STATIC_ASSERT( a1 < a2 );
|
||||
STATIC_ASSERT( !( a1 > a2 ) );
|
||||
|
||||
STATIC_ASSERT( a1 <= a2 );
|
||||
STATIC_ASSERT( !( a1 >= a2 ) );
|
||||
}
|
||||
{
|
||||
constexpr boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
|
||||
constexpr boost::array<T, 4> a2 = {{ 1, 2, 3, 2 }};
|
||||
|
||||
STATIC_ASSERT( !( a1 < a2 ) );
|
||||
STATIC_ASSERT( a1 > a2 );
|
||||
|
||||
STATIC_ASSERT( !( a1 <= a2 ) );
|
||||
STATIC_ASSERT( a1 >= a2 );
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test1<int, 0>();
|
||||
test1<int, 1>();
|
||||
test1<int, 7>();
|
||||
|
||||
test2<int>();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,88 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <iterator>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
{
|
||||
boost::array<T, N> a = {{}};
|
||||
|
||||
{
|
||||
std::reverse_iterator<T*> r1( a.rbegin() );
|
||||
std::reverse_iterator<T*> r2( a.end() );
|
||||
|
||||
BOOST_TEST( r1 == r2 );
|
||||
}
|
||||
|
||||
{
|
||||
std::reverse_iterator<T*> r1( a.rend() );
|
||||
std::reverse_iterator<T*> r2( a.begin() );
|
||||
|
||||
BOOST_TEST( r1 == r2 );
|
||||
}
|
||||
|
||||
{
|
||||
std::reverse_iterator<T const*> r1( a.crbegin() );
|
||||
std::reverse_iterator<T const*> r2( a.cend() );
|
||||
|
||||
BOOST_TEST( r1 == r2 );
|
||||
}
|
||||
|
||||
{
|
||||
std::reverse_iterator<T const*> r1( a.crend() );
|
||||
std::reverse_iterator<T const*> r2( a.cbegin() );
|
||||
|
||||
BOOST_TEST( r1 == r2 );
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
boost::array<T, N> const a = {{}};
|
||||
|
||||
{
|
||||
std::reverse_iterator<T const*> r1( a.rbegin() );
|
||||
std::reverse_iterator<T const*> r2( a.end() );
|
||||
|
||||
BOOST_TEST( r1 == r2 );
|
||||
}
|
||||
|
||||
{
|
||||
std::reverse_iterator<T const*> r1( a.rend() );
|
||||
std::reverse_iterator<T const*> r2( a.begin() );
|
||||
|
||||
BOOST_TEST( r1 == r2 );
|
||||
}
|
||||
|
||||
{
|
||||
std::reverse_iterator<T const*> r1( a.crbegin() );
|
||||
std::reverse_iterator<T const*> r2( a.cend() );
|
||||
|
||||
BOOST_TEST( r1 == r2 );
|
||||
}
|
||||
|
||||
{
|
||||
std::reverse_iterator<T const*> r1( a.crend() );
|
||||
std::reverse_iterator<T const*> r2( a.cbegin() );
|
||||
|
||||
BOOST_TEST( r1 == r2 );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// test<int, 0>();
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
// test<int const, 0>();
|
||||
test<int const, 1>();
|
||||
test<int const, 7>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,73 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <iterator>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test1()
|
||||
{
|
||||
{
|
||||
boost::array<T, N> a = {{}};
|
||||
|
||||
BOOST_TEST_EQ( a.size(), N );
|
||||
BOOST_TEST_EQ( a.empty(), N == 0 );
|
||||
BOOST_TEST_EQ( a.max_size(), N );
|
||||
}
|
||||
|
||||
{
|
||||
boost::array<T, N> const a = {{}};
|
||||
|
||||
BOOST_TEST_EQ( a.size(), N );
|
||||
BOOST_TEST_EQ( a.empty(), N == 0 );
|
||||
BOOST_TEST_EQ( a.max_size(), N );
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, std::size_t N> void test2()
|
||||
{
|
||||
typedef boost::array<T, N> A;
|
||||
|
||||
BOOST_TEST_EQ( A().size(), N );
|
||||
BOOST_TEST_EQ( A().empty(), N == 0 );
|
||||
BOOST_TEST_EQ( A().max_size(), N );
|
||||
}
|
||||
|
||||
// the functions are static, which deviates from the standard
|
||||
template<class T, std::size_t N> void test3()
|
||||
{
|
||||
typedef boost::array<T, N> A;
|
||||
|
||||
BOOST_TEST_EQ( A::size(), N );
|
||||
BOOST_TEST_EQ( A::empty(), N == 0 );
|
||||
BOOST_TEST_EQ( A::max_size(), N );
|
||||
|
||||
BOOST_TEST_EQ( A::static_size, N );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
// test1<int, 0>();
|
||||
test1<int, 1>();
|
||||
test1<int, 7>();
|
||||
|
||||
// test1<int const, 0>();
|
||||
test1<int const, 1>();
|
||||
test1<int const, 7>();
|
||||
|
||||
test2<int, 0>();
|
||||
test2<int, 1>();
|
||||
test2<int, 7>();
|
||||
|
||||
test3<int, 0>();
|
||||
test3<int, 1>();
|
||||
test3<int, 7>();
|
||||
|
||||
test3<int const, 0>();
|
||||
test3<int const, 1>();
|
||||
test3<int const, 7>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,64 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/config/pragma_message.hpp>
|
||||
#include <boost/config/workaround.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
#if defined(BOOST_NO_CXX11_CONSTEXPR)
|
||||
|
||||
BOOST_PRAGMA_MESSAGE("Test skipped because BOOST_NO_CXX11_CONSTEXPR is defined")
|
||||
|
||||
#else
|
||||
|
||||
#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
|
||||
|
||||
template<class T, std::size_t N> void test1()
|
||||
{
|
||||
constexpr boost::array<T, N> a = {};
|
||||
|
||||
STATIC_ASSERT( a.size() == N );
|
||||
STATIC_ASSERT( a.empty() == (N == 0) );
|
||||
STATIC_ASSERT( a.max_size() == N );
|
||||
}
|
||||
|
||||
template<class T, std::size_t N> void test2()
|
||||
{
|
||||
typedef boost::array<T, N> A;
|
||||
|
||||
STATIC_ASSERT( A().size() == N );
|
||||
STATIC_ASSERT( A().empty() == (N == 0) );
|
||||
STATIC_ASSERT( A().max_size() == N );
|
||||
}
|
||||
|
||||
// the functions are static, which deviates from the standard
|
||||
template<class T, std::size_t N> void test3()
|
||||
{
|
||||
typedef boost::array<T, N> A;
|
||||
|
||||
STATIC_ASSERT( A::size() == N );
|
||||
STATIC_ASSERT( A::empty() == (N == 0) );
|
||||
STATIC_ASSERT( A::max_size() == N );
|
||||
|
||||
STATIC_ASSERT( A::static_size == N );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test1<int, 0>();
|
||||
test1<int, 1>();
|
||||
test1<int, 7>();
|
||||
|
||||
test2<int, 0>();
|
||||
test2<int, 1>();
|
||||
test2<int, 7>();
|
||||
|
||||
test3<int, 0>();
|
||||
test3<int, 1>();
|
||||
test3<int, 7>();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,49 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
boost::array<T, N> a1 = {};
|
||||
boost::array<T, N> a2 = {};
|
||||
|
||||
a1.fill( 1 );
|
||||
a2.fill( 2 );
|
||||
|
||||
a1.swap( a2 );
|
||||
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
BOOST_TEST_EQ( a1[i], 2 );
|
||||
BOOST_TEST_EQ( a2[i], 1 );
|
||||
}
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
|
||||
boost::array<T, 4> a2 = {{ 5, 6, 7, 8 }};
|
||||
|
||||
a1.swap( a2 );
|
||||
|
||||
for( int i = 0; i < 4; ++i )
|
||||
{
|
||||
BOOST_TEST_EQ( a1[i], i+5 );
|
||||
BOOST_TEST_EQ( a2[i], i+1 );
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int, 0>();
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
test2<int>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,49 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
boost::array<T, N> a1 = {};
|
||||
boost::array<T, N> a2 = {};
|
||||
|
||||
a1.fill( 1 );
|
||||
a2.fill( 2 );
|
||||
|
||||
swap( a1, a2 );
|
||||
|
||||
for( std::size_t i = 0; i < N; ++i )
|
||||
{
|
||||
BOOST_TEST_EQ( a1[i], 2 );
|
||||
BOOST_TEST_EQ( a2[i], 1 );
|
||||
}
|
||||
}
|
||||
|
||||
template<class T> void test2()
|
||||
{
|
||||
boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
|
||||
boost::array<T, 4> a2 = {{ 5, 6, 7, 8 }};
|
||||
|
||||
swap( a1, a2 );
|
||||
|
||||
for( int i = 0; i < 4; ++i )
|
||||
{
|
||||
BOOST_TEST_EQ( a1[i], i+5 );
|
||||
BOOST_TEST_EQ( a2[i], i+1 );
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int, 0>();
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
test2<int>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,43 +0,0 @@
|
||||
// Copyright 2025 Peter Dimov
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/lightweight_test_trait.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
#include <iterator>
|
||||
#include <cstddef>
|
||||
|
||||
template<class T, std::size_t N> void test()
|
||||
{
|
||||
typedef boost::array<T, N> A;
|
||||
|
||||
BOOST_TEST_TRAIT_SAME(typename A::value_type, T);
|
||||
|
||||
BOOST_TEST_TRAIT_SAME(typename A::iterator, T*);
|
||||
BOOST_TEST_TRAIT_SAME(typename A::const_iterator, T const*);
|
||||
|
||||
BOOST_TEST_TRAIT_SAME(typename A::reverse_iterator, std::reverse_iterator<T*>);
|
||||
BOOST_TEST_TRAIT_SAME(typename A::const_reverse_iterator, std::reverse_iterator<T const*>);
|
||||
|
||||
BOOST_TEST_TRAIT_SAME(typename A::reference, T&);
|
||||
BOOST_TEST_TRAIT_SAME(typename A::const_reference, T const&);
|
||||
|
||||
BOOST_TEST_TRAIT_SAME(typename A::size_type, std::size_t);
|
||||
BOOST_TEST_TRAIT_SAME(typename A::difference_type, std::ptrdiff_t);
|
||||
|
||||
BOOST_TEST_EQ(A::static_size, N);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test<int, 0>();
|
||||
test<int, 1>();
|
||||
test<int, 7>();
|
||||
|
||||
test<int const, 0>();
|
||||
test<int const, 1>();
|
||||
test<int const, 7>();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
# Copyright 2018, 2019, 2021 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
cmake_minimum_required(VERSION 3.5...3.20)
|
||||
|
||||
project(cmake_install_test LANGUAGES CXX)
|
||||
|
||||
find_package(boost_array REQUIRED)
|
||||
|
||||
add_executable(quick ../quick.cpp)
|
||||
target_link_libraries(quick Boost::array)
|
||||
|
||||
enable_testing()
|
||||
add_test(quick quick)
|
||||
|
||||
add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
|
||||
@ -1,23 +0,0 @@
|
||||
# Copyright 2018, 2019, 2021 Peter Dimov
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
cmake_minimum_required(VERSION 3.5...3.20)
|
||||
|
||||
project(cmake_subdir_test LANGUAGES CXX)
|
||||
|
||||
add_subdirectory(../.. boostorg/array)
|
||||
|
||||
add_subdirectory(../../../assert boostorg/assert)
|
||||
add_subdirectory(../../../config boostorg/config)
|
||||
add_subdirectory(../../../core boostorg/core)
|
||||
add_subdirectory(../../../static_assert boostorg/static_assert)
|
||||
add_subdirectory(../../../throw_exception boostorg/throw_exception)
|
||||
|
||||
add_executable(quick ../quick.cpp)
|
||||
target_link_libraries(quick Boost::array)
|
||||
|
||||
enable_testing()
|
||||
add_test(quick quick)
|
||||
|
||||
add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
|
||||
@ -1,11 +0,0 @@
|
||||
// Copyright 2023 Peter Dimov.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <boost/array.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::array<int, 2> a = {{ 0, 1 }};
|
||||
return a[0];
|
||||
}
|
||||
Reference in New Issue
Block a user