Remove inclusion of <algorithm>

refactor documentation to use asciidoc

.drone.jsonnet

@@ -0,0 +1,346 @@
+# 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' },
+    ),
+]

.drone/drone.bat

@@ -0,0 +1,23 @@
+@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

.drone/drone.sh

@@ -0,0 +1,25 @@
+#!/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}

.github/workflows/ci.yml

@@ -0,0 +1,643 @@
+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

.travis.yml

@@ -0,0 +1,217 @@
+# 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

CMakeLists.txt

@@ -0,0 +1,28 @@
+# 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()

doc/.gitignore

@@ -0,0 +1 @@
+/html

doc/Jamfile.v2

@@ -0,0 +1,22 @@
+#~ 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 ;

doc/array.adoc

@@ -0,0 +1,28 @@
+////
+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

doc/array.xml

@@ -1,546 +0,0 @@
-<?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&lt;&gt;</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>&lt;iterator&gt;</type>
-          </typedef>
-          <typedef name="const_reverse_iterator">
-             <type><classname>std::reverse_iterator</classname>&lt;const_iterator&gt;</type>
-          </typedef>
-          <typedef name="reference">
-             <type>T&amp;</type>
-          </typedef>
-          <typedef name="const_reference">
-             <type>const T&amp;</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>&lt;U, N&gt;&amp;</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 &lt; 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 &gt;= 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 &gt; 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 &gt; 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>&lt;T, N&gt;&amp;</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&amp;</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>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-              <parameter name="y">
-                <paramtype><classname>array</classname>&lt;T, N&gt;&amp;</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>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-              <parameter name="y">
-                <paramtype>const <classname>array</classname>&lt;T, N&gt;&amp;</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>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-              <parameter name="y">
-                <paramtype>const <classname>array</classname>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-
-              <returns><simpara><code>!(x == y)</code></simpara>
-              </returns>
-            </function>
-
-            <function name="operator&lt;">
-              <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>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-              <parameter name="y">
-                <paramtype>const <classname>array</classname>&lt;T, N&gt;&amp;</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&gt;">
-              <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>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-              <parameter name="y">
-                <paramtype>const <classname>array</classname>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-
-              <returns><simpara><code>y &lt; x</code></simpara></returns>
-            </function>
-
-            <function name="operator&lt;=">
-              <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>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-              <parameter name="y">
-                <paramtype>const <classname>array</classname>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-
-              <returns><simpara><code>!(y &lt; x)</code></simpara></returns>
-            </function>
-
-            <function name="operator&gt;=">
-              <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>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-              <parameter name="y">
-                <paramtype>const <classname>array</classname>&lt;T, N&gt;&amp;</paramtype>
-              </parameter>
-
-              <returns><simpara><code>!(x &lt; 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>&lt;int,4&gt; 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>&lt;int,4&gt; 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>

doc/array/changes.adoc

@@ -0,0 +1,16 @@
+////
+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.

doc/array/copyright.adoc

@@ -0,0 +1,15 @@
+////
+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].

doc/array/design_rationale.adoc

@@ -0,0 +1,39 @@
+////
+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 };
+```

doc/array/information.adoc

@@ -0,0 +1,22 @@
+////
+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]

doc/array/introduction.adoc

@@ -0,0 +1,44 @@
+////
+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.

doc/array/reference.adoc

@@ -0,0 +1,405 @@
+////
+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]`.
+
+---

include/boost/array.hpp

@@ -1,3 +1,6 @@
+#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.
  *
@@ -13,6 +16,13 @@
  * 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
+ *      Eventually, we should remove "assign" which is now a synonym for "fill" (Marshall Clow)
+ * 10 Mar 2010 - added workaround for SUNCC and !STLPort [trac #3893] (Marshall Clow)
  * 29 Jan 2004 - c_array() added, BOOST_NO_PRIVATE_IN_AGGREGATE removed (Nico Josuttis)
  * 23 Aug 2002 - fix for Non-MSVC compilers combined with MSVC libraries.
  * 05 Aug 2001 - minor update (Nico Josuttis)
@@ -21,22 +31,24 @@
  *
  * Jan 29, 2004
  */
-#ifndef BOOST_ARRAY_HPP
-#define BOOST_ARRAY_HPP
 
-#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>
+#include <boost/config/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
+#endif
+
+#include <boost/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <iterator>
+#include <stdexcept>
+#include <utility>
+#include <cstddef>
 
 namespace boost {
 
@@ -56,116 +68,131 @@ namespace boost {
         typedef std::ptrdiff_t difference_type;
 
         // iterator support
-        iterator begin() { return elems; }
-        const_iterator begin() const { return elems; }
-        iterator end() { return elems+N; }
-        const_iterator end() const { return elems+N; }
+        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; }
 
         // 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;
-#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() { return reverse_iterator(end()); }
-        const_reverse_iterator rbegin() const {
+        reverse_iterator rbegin() BOOST_NOEXCEPT { return reverse_iterator(end()); }
+        const_reverse_iterator rbegin() const BOOST_NOEXCEPT {
             return const_reverse_iterator(end());
         }
-        reverse_iterator rend() { return reverse_iterator(begin()); }
-        const_reverse_iterator rend() const {
+        const_reverse_iterator crbegin() const BOOST_NOEXCEPT {
+            return const_reverse_iterator(end());
+        }
+
+        reverse_iterator rend() BOOST_NOEXCEPT { return reverse_iterator(begin()); }
+        const_reverse_iterator rend() const BOOST_NOEXCEPT {
+            return const_reverse_iterator(begin());
+        }
+        const_reverse_iterator crend() const BOOST_NOEXCEPT {
             return const_reverse_iterator(begin());
         }
 
         // operator[]
-        reference operator[](size_type i) 
+        BOOST_CXX14_CONSTEXPR reference operator[](size_type i)
         {
-            BOOST_ASSERT( i < N && "out of range" ); 
-            return elems[i];
+            return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i];
         }
 
+#if !BOOST_WORKAROUND(BOOST_GCC, < 50000)
+        BOOST_CONSTEXPR
+#endif
         const_reference operator[](size_type i) const
         {
-            BOOST_ASSERT( i < N && "out of range" ); 
-            return elems[i]; 
+            return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i];
         }
 
         // at() with range check
-        reference at(size_type i) { rangecheck(i); return elems[i]; }
-        const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
+        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]; }
 
         // front() and back()
-        reference front() 
+        BOOST_CXX14_CONSTEXPR reference front()
         {
             return elems[0];
         }
 
-        const_reference front() const 
+        BOOST_CONSTEXPR const_reference front() const
         {
             return elems[0];
         }
 
-        reference back() 
+        BOOST_CXX14_CONSTEXPR reference back()
         {
             return elems[N-1];
         }
 
-        const_reference back() const 
+        BOOST_CONSTEXPR const_reference back() const
         {
             return elems[N-1];
         }
 
         // size is constant
-        static size_type size() { return N; }
-        static bool empty() { return false; }
-        static size_type max_size() { return N; }
+        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; }
         enum { static_size = N };
 
         // swap (note: linear complexity)
-        void swap (array<T,N>& y) {
-            for (size_type i = 0; i < N; ++i)
-                boost::swap(elems[i],y.elems[i]);
+        BOOST_CXX14_CONSTEXPR void swap (array<T,N>& y)
+        {
+            std::swap( elems, y.elems );
         }
 
-        // direct access to data (read-only)
-        const T* data() const { return elems; }
-        T* data() { return elems; }
+        // direct access to data
+        BOOST_CONSTEXPR const T* data() const BOOST_NOEXCEPT { return elems; }
+        BOOST_CXX14_CONSTEXPR T* data() BOOST_NOEXCEPT { return elems; }
 
-        // use array as C array (direct read/write access to data)
-        T* c_array() { return elems; }
+        // obsolete
+        BOOST_DEPRECATED( "please use `data()` instead" )
+        T* c_array() BOOST_NOEXCEPT { return elems; }
 
         // assignment with type conversion
         template <typename T2>
-        array<T,N>& operator= (const array<T2,N>& rhs) {
-            std::copy(rhs.begin(),rhs.end(), begin());
+        array<T,N>& operator= (const array<T2,N>& rhs)
+        {
+            for( std::size_t i = 0; i < N; ++i )
+            {
+                elems[ i ] = rhs.elems[ i ];
+            }
+
             return *this;
         }
 
-        // assign one value to all elements
-        void assign (const T& value)
+        // fill with one value
+        BOOST_CXX14_CONSTEXPR void fill (const T& value)
         {
-            std::fill_n(begin(),size(),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 ];
+            }
         }
 
+        // 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 void rangecheck (size_type i) {
-            if (i >= size()) {
-                throw std::out_of_range("array<>: index out of range");
-            }
+        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;
         }
 
     };
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
     template< class T >
     class array< T, 0 > {
 
@@ -180,33 +207,31 @@ namespace boost {
         typedef std::ptrdiff_t difference_type;
 
         // iterator support
-        iterator begin() { return iterator( reinterpret_cast< T * >( this ) ); }
-        const_iterator begin() const { return const_iterator(  reinterpret_cast< const T * >( this ) ); }
-        iterator end() { return begin(); }
-        const_iterator end() const { return begin(); }
+        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        end()       BOOST_NOEXCEPT { return  begin(); }
+        const_iterator  end() const BOOST_NOEXCEPT { return  begin(); }
+        const_iterator cend() const BOOST_NOEXCEPT { 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;
-#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() { return reverse_iterator(end()); }
-        const_reverse_iterator rbegin() const {
+        reverse_iterator rbegin() BOOST_NOEXCEPT { return reverse_iterator(end()); }
+        const_reverse_iterator rbegin() const BOOST_NOEXCEPT {
             return const_reverse_iterator(end());
         }
-        reverse_iterator rend() { return reverse_iterator(begin()); }
-        const_reverse_iterator rend() const {
+        const_reverse_iterator crbegin() const BOOST_NOEXCEPT {
+            return const_reverse_iterator(end());
+        }
+
+        reverse_iterator rend() BOOST_NOEXCEPT { return reverse_iterator(begin()); }
+        const_reverse_iterator rend() const BOOST_NOEXCEPT {
+            return const_reverse_iterator(begin());
+        }
+        const_reverse_iterator crend() const BOOST_NOEXCEPT {
             return const_reverse_iterator(begin());
         }
 
@@ -247,20 +272,22 @@ namespace boost {
         }
 
         // size is constant
-        static size_type size() { return 0; }
-        static bool empty() { return true; }
-        static size_type max_size() { return 0; }
+        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; }
         enum { static_size = 0 };
 
-        void swap (array<T,0>& /*y*/) {
+        BOOST_CXX14_CONSTEXPR void swap (array<T,0>& /*y*/)
+        {
         }
 
-        // direct access to data (read-only)
-        const T* data() const { return 0; }
-        T* data() { return 0; }
+        // direct access to data
+        BOOST_CONSTEXPR const T* data() const BOOST_NOEXCEPT { return 0; }
+        BOOST_CXX14_CONSTEXPR T* data() BOOST_NOEXCEPT { return 0; }
 
-        // use array as C array (direct read/write access to data)
-        T* c_array() { return 0; }
+        // obsolete
+        BOOST_DEPRECATED( "please use `data()` instead" )
+        T* c_array() BOOST_NOEXCEPT { return 0; }
 
         // assignment with type conversion
         template <typename T2>
@@ -268,13 +295,18 @@ namespace boost {
             return *this;
         }
 
-        // assign one value to all elements
-        void assign (const T& ) {   }
+        // an obsolete synonym for fill
+        BOOST_DEPRECATED( "please use `fill` instead" )
+        void assign (const T& value) { fill ( value ); }
+
+        // fill with one value
+        BOOST_CXX14_CONSTEXPR 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__))
                 //
                 // We need to return something here to keep
                 // some compilers happy: however we will never
@@ -282,42 +314,139 @@ namespace boost {
                 //
                 static T placeholder;
                 return placeholder;
+#endif
             }
     };
-#endif
 
     // comparisons
     template<class T, std::size_t N>
-    bool operator== (const array<T,N>& x, const array<T,N>& y) {
-        return std::equal(x.begin(), x.end(), y.begin());
+    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;
         }
-    template<class T, std::size_t N>
-    bool operator< (const array<T,N>& x, const array<T,N>& y) {
-        return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
+
+        return true;
     }
+
+#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>
-    bool operator!= (const array<T,N>& x, const array<T,N>& y) {
+    BOOST_CXX14_CONSTEXPR bool operator!= (const array<T,N>& x, const array<T,N>& y) {
         return !(x==y);
     }
+
     template<class T, std::size_t N>
-    bool operator> (const array<T,N>& x, const array<T,N>& y) {
+    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) {
         return y<x;
     }
+
     template<class T, std::size_t N>
-    bool operator<= (const array<T,N>& x, const array<T,N>& y) {
+    BOOST_CXX14_CONSTEXPR bool operator<= (const array<T,N>& x, const array<T,N>& y) {
         return !(y<x);
     }
+
     template<class T, std::size_t N>
-    bool operator>= (const array<T,N>& x, const array<T,N>& y) {
+    BOOST_CXX14_CONSTEXPR bool operator>= (const array<T,N>& x, const array<T,N>& y) {
         return !(x<y);
     }
 
     // global swap()
     template<class T, std::size_t N>
-    inline void swap (array<T,N>& x, array<T,N>& y) {
+    BOOST_CXX14_CONSTEXPR inline void swap (array<T,N>& x, array<T,N>& y) {
         x.swap(y);
     }
 
+    // undocumented and obsolete
+    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)
+    {
+        return boost::hash_range(arr.begin(), arr.end());
+    }
+
+   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];
+       }
+
 } /* namespace boost */
 
-#endif /*BOOST_ARRAY_HPP*/
+#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
+
+#endif // #ifndef BOOST_ARRAY_HPP_INCLUDED

index.html

@@ -1,10 +1,10 @@
 <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> &nbsp;<hr>
+<a href="../../doc/html/array.html">doc/html/array.html</a> &nbsp;<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 

meta/libraries.json

@@ -0,0 +1,18 @@
+{
+    "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"
+}

test/CMakeLists.txt

@@ -0,0 +1,12 @@
+# 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()

test/Jamfile.v2

@@ -2,13 +2,66 @@
 #~ 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 ;
 
-test-suite array :
-    [ run array0.cpp ]
-    [ run array1.cpp ]
-    [ run array2.cpp ]
-    [ run array3.cpp ]
-    [ run array4.cpp ]
-    [ run array5.cpp ]
-    ;
+#
+
+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/array0.cpp

@@ -5,22 +5,18 @@
  * 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 &  )
 {
-    fail_test( "Unexpected value" );
+    BOOST_TEST ( false );
 }
 
 template< class T >
@@ -32,59 +28,45 @@ void    RunTests()
     test_type                   test_case   =   {};
     const boost::array< T, 0 >  const_test_case = test_type();
 
-    test_case.assign( T() );
+    test_case.fill ( T() );
 
     //  front/back and operator[] must compile, but calling them is undefined
     //  Likewise, all tests below should evaluate to false, avoiding undefined behaviour
-    if( !test_case.empty() ) {
-        BadValue( test_case.front() );
-    }
+    BOOST_TEST (       test_case.empty());
+    BOOST_TEST ( const_test_case.empty());
 
-    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 ] );
-    }
+    BOOST_TEST (       test_case.size() == 0 );
+    BOOST_TEST ( const_test_case.size() == 0 );
 
     //  Assert requirements of TR1 6.2.2.4
-    if( test_case.begin() != test_case.end() ) {
-        fail_test( "Not an empty range" );
-    }
-    if( const_test_case.begin() != const_test_case.end() ) {
-        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()  == 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());
 
+    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 > );
+    std::for_each( test_case.cbegin(), test_case.cend(), BadValue< T > );
     std::for_each( const_test_case.begin(), const_test_case.end(), BadValue< T > );
     std::for_each( const_test_case.rbegin(), const_test_case.rend(), BadValue< T > );
+    std::for_each( const_test_case.cbegin(), const_test_case.cend(), BadValue< T > );
 
     //  Check swap is well formed
     std::swap( test_case, test_case );
 
-    //  Check assigment operator and overloads are well formed
+    //  Check assignment 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 & ) {
     }
 
@@ -102,6 +84,6 @@ int main()
     RunTests< void * >();
     RunTests< long double >();
     RunTests< std::string >();
-    return failed_tests;
-}
 
+    return boost::report_errors();
+}

test/array2.cpp

@@ -5,17 +5,21 @@
  * http://www.boost.org/LICENSE_1_0.txt)
  */
 
+#ifndef _SCL_SECURE_NO_WARNINGS
+// Suppress warnings from the std lib:
+#  define _SCL_SECURE_NO_WARNINGS
+#endif
+
 #include <algorithm>
 #include <functional>
 #include <boost/array.hpp>
 #include "print.hpp"
 using namespace std;
-using namespace boost;
 
 int main()
 {
     // create and initialize array
-    array<int,10> a = { { 1, 2, 3, 4, 5 } };
+    boost::array<int,10> a = { { 1, 2, 3, 4, 5 } };
 
     print_elements(a);
 

test/array3.cpp

@@ -39,6 +39,13 @@ int main()
            =seasons.rbegin(); pos<seasons.rend(); ++pos) {
         std::cout << " " << *pos;
     }
+
+    // try constant reverse iterators
+    std::cout << "reverse:   ";
+    for (boost::array<std::string,4>::const_reverse_iterator pos
+           =seasons.crbegin(); pos<seasons.crend(); ++pos) {
+        std::cout << " " << *pos;
+    }
     std::cout << std::endl;
 
     return 0;  // makes Visual-C++ compiler happy

test/array6.cpp

@@ -0,0 +1,60 @@
+/* tests for using class array<> specialization for size 0
+ * (C) Copyright Alisdair Meredith 2006.
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#include <string>
+#include <iostream>
+#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] );
+
+    //  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 & ) {}
+    }
+}
+
+int main ()
+{
+    RunTests< bool >();
+    RunTests< void * >();
+    RunTests< long double >();
+    RunTests< std::string >();
+
+    return boost::report_errors();
+}
+

test/array7.cpp

@@ -0,0 +1,66 @@
+/* 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();
+}
+

test/array_access_test.cpp

@@ -0,0 +1,117 @@
+// 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();
+}

test/array_access_test_cx.cpp

@@ -0,0 +1,50 @@
+// 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

test/array_assign_test.cpp

@@ -0,0 +1,60 @@
+// 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();
+}

test/array_c_array_test.cpp

@@ -0,0 +1,70 @@
+// 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();
+}

test/array_constexpr.cpp

@@ -0,0 +1,29 @@
+/* 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

test/array_convert_test.cpp

@@ -0,0 +1,38 @@
+// 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();
+}

test/array_copy_test.cpp

@@ -0,0 +1,65 @@
+// 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();
+}

test/array_copy_test_cx.cpp

@@ -0,0 +1,58 @@
+// 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

test/array_data_test.cpp

@@ -0,0 +1,41 @@
+// 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();
+}

test/array_data_test_cx.cpp

@@ -0,0 +1,47 @@
+// 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

test/array_elems_test.cpp

@@ -0,0 +1,27 @@
+// 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();
+}

test/array_eq_test.cpp

@@ -0,0 +1,83 @@
+// 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();
+}

test/array_eq_test_cx.cpp

@@ -0,0 +1,55 @@
+// 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

test/array_fill_test.cpp

@@ -0,0 +1,57 @@
+// 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();
+}

test/array_get_test.cpp

@@ -0,0 +1,40 @@
+// 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();
+}

test/array_get_test_cx.cpp

@@ -0,0 +1,42 @@
+// 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

test/array_getfail1.cpp

@@ -0,0 +1,50 @@
+/* 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();
+}

test/array_getfail2.cpp

@@ -0,0 +1,65 @@
+/* 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();
+}
+

test/array_hash.cpp

@@ -0,0 +1,44 @@
+/* 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();
+}
+

test/array_init_test.cpp

@@ -0,0 +1,81 @@
+// 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();
+}

test/array_init_test_cx.cpp

@@ -0,0 +1,78 @@
+// 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

test/array_iterator_test.cpp

@@ -0,0 +1,108 @@
+// 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();
+}

test/array_iterator_test_cx.cpp

@@ -0,0 +1,58 @@
+// 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

test/array_lt_test.cpp

@@ -0,0 +1,85 @@
+// 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();
+}

test/array_lt_test_cx.cpp

@@ -0,0 +1,74 @@
+// 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

test/array_reverse_test.cpp

@@ -0,0 +1,88 @@
+// 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();
+}

test/array_size_test.cpp

@@ -0,0 +1,73 @@
+// 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();
+}

test/array_size_test_cx.cpp

@@ -0,0 +1,64 @@
+// 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

test/array_swap_test.cpp

@@ -0,0 +1,49 @@
+// 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();
+}

test/array_swap_test2.cpp

@@ -0,0 +1,49 @@
+// 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();
+}

test/array_typedef_test.cpp

@@ -0,0 +1,43 @@
+// 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();
+}

test/cmake_install_test/CMakeLists.txt

@@ -0,0 +1,17 @@
+# 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>)

test/cmake_subdir_test/CMakeLists.txt

@@ -0,0 +1,23 @@
+# 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>)

test/quick.cpp

@@ -0,0 +1,11 @@
+// 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];
+}