Merge pull request #28 from ashtum/patch-1

Update index.html
2025-06-26 12:31:41 +02:00 · 2025-04-03 14:10:17 +03:00 · 2025-04-03 14:25:37 +03:30 · 2025-02-23 22:02:50 +02:00 · 2025-02-23 21:04:28 +02:00 · 2025-02-23 20:59:49 +02:00
60 changed files with 2136 additions and 555 deletions
--- a/.drone.jsonnet
+++ b/.drone.jsonnet
@ -0,0 +1,416 @@
+# 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 18.04 Clang 3.9",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.9', CXXSTD: '03,11,14' },
+        "clang-3.9",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 4.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-4.0', CXXSTD: '03,11,14' },
+        "clang-4.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 5.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-5.0', CXXSTD: '03,11,14,1z' },
+        "clang-5.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 6.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '03,11,14,17' },
+        "clang-6.0",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 7",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '03,11,14,17' },
+        "clang-7",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 8",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '03,11,14,17' },
+        "clang-8",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 9",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '03,11,14,17,2a' },
+        "clang-9",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 10",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '03,11,14,17,2a' },
+        "clang-10",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 11",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '03,11,14,17,2a' },
+        "clang-11",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 12",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '03,11,14,17,2a' },
+        "clang-12",
+    ),
+
+    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' },
+    ),
+]
--- a/.drone.star
+++ b/.drone.star
@ -1,37 +0,0 @@
-# Use, modification, and distribution are
-# subject to the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE.txt)
-#
-# Copyright Rene Rivera 2020.
-
-# For Drone CI we use the Starlark scripting language to reduce duplication.
-# As the yaml syntax for Drone CI is rather limited.
-#
-#
-globalenv={}
-linuxglobalimage="cppalliance/droneubuntu1604:1"
-windowsglobalimage="cppalliance/dronevs2019"
-
-def main(ctx):
-  return [
-  linux_cxx("TEST_CMAKE=TRUE Job 0", "g++", packages="", buildtype="96ad197d74-2319b6d45f", image=linuxglobalimage, environment={'TEST_CMAKE': 'TRUE', 'DRONE_JOB_UUID': 'b6589fc6ab'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++ CXXSTD=03,11 Job 1", "g++", packages="", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': '356a192b79'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11 Job 2", "g++-4.7", packages="g++-4.7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.7', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': 'da4b9237ba'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11 Job 3", "g++-4.8", packages="g++-4.8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.8', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': '77de68daec'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11 Job 4", "g++-4.9", packages="g++-4.9", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.9', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': '1b64538924'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z Job 5", "g++-5", packages="g++-5", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'ac3478d69a'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z Job 6", "g++-6", packages="g++-6", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'c1dfd96eea'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17 Job 7", "g++-7", packages="g++-7", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '03,11,14,17', 'DRONE_JOB_UUID': '902ba3cda1'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=03,11 Job 8", "clang++", packages="", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': 'fe5dbbcea5'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03, Job 9", "clang++", packages="clang-3.5 libstdc++-4.9-dev", llvm_os="precise", llvm_ver="3.5", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.5', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '0ade7c2cf9'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03, Job 10", "clang++", packages="clang-3.6", llvm_os="precise", llvm_ver="3.6", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.6', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'b1d5781111'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03, Job 11", "clang++", packages="clang-3.7", llvm_os="precise", llvm_ver="3.7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.7', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '17ba079149'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03, Job 12", "clang++-3.8", packages="clang-3.8 libstdc++-4.9-dev", llvm_os="precise", llvm_ver="3.8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.8', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '7b52009b64'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03, Job 13", "clang++-3.9", packages="clang-3.9 libstdc++-4.9-dev", llvm_os="precise", llvm_ver="3.9", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.9', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'bd307a3ec3'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03, Job 14", "clang++-4.0", packages="clang-4.0", llvm_os="xenial", llvm_ver="4.0", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'fa35e19212'}, globalenv=globalenv),
-  linux_cxx("TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03, Job 15", "clang++-5.0", packages="clang-5.0", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'f1abd67035'}, globalenv=globalenv),
-  osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,1 Job 16", "clang++", packages="", buildtype="boost", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '1574bddb75'}, globalenv=globalenv),
-  ]
-
-# from https://github.com/boostorg/boost-ci
-load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx")
--- a/.drone/96ad197d74-2319b6d45f.sh
+++ b/.drone/96ad197d74-2319b6d45f.sh
@ -1,37 +0,0 @@
-#!/bin/bash
-
-set -ex
-export TRAVIS_BUILD_DIR=$(pwd)
-export DRONE_BUILD_DIR=$(pwd)
-export TRAVIS_BRANCH=$DRONE_BRANCH
-export VCS_COMMIT_ID=$DRONE_COMMIT
-export GIT_COMMIT=$DRONE_COMMIT
-export REPO_NAME=$DRONE_REPO
-export PATH=~/.local/bin:/usr/local/bin:$PATH
-
-echo '==================================> BEFORE_INSTALL'
-
-. .drone/before-install.sh
-
-echo '==================================> 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
-
-echo '==================================> BEFORE_SCRIPT'
-
-. $DRONE_BUILD_DIR/.drone/before-script.sh
-
-echo '==================================> SCRIPT'
-
-mkdir __build__ && cd __build__
-cmake ../test/test_cmake
-cmake --build .
-
-echo '==================================> AFTER_SUCCESS'
-
-. $DRONE_BUILD_DIR/.drone/after-success.sh
--- a/.drone/after-success.sh
+++ b/.drone/after-success.sh
@ -1,3 +0,0 @@
-#!/bin/bash
-
-
--- a/.drone/before-install.sh
+++ b/.drone/before-install.sh
@ -1,3 +0,0 @@
-#!/bin/bash
-
-
--- a/.drone/before-script.sh
+++ b/.drone/before-script.sh
@ -1,3 +0,0 @@
-#!/bin/bash
-
-
--- a/.drone/boost.sh
+++ b/.drone/boost.sh
@ -1,41 +0,0 @@
-#!/bin/bash
-
-set -ex
-export TRAVIS_BUILD_DIR=$(pwd)
-export DRONE_BUILD_DIR=$(pwd)
-export TRAVIS_BRANCH=$DRONE_BRANCH
-export VCS_COMMIT_ID=$DRONE_COMMIT
-export GIT_COMMIT=$DRONE_COMMIT
-export REPO_NAME=$DRONE_REPO
-export PATH=~/.local/bin:/usr/local/bin:$PATH
-
-echo '==================================> BEFORE_INSTALL'
-
-. .drone/before-install.sh
-
-echo '==================================> 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
-
-echo '==================================> BEFORE_SCRIPT'
-
-. $DRONE_BUILD_DIR/.drone/before-script.sh
-
-echo '==================================> SCRIPT'
-
-echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-./b2 -j 3 libs/array/test toolset=$TOOLSET cxxstd=$CXXSTD
-
-echo '==================================> AFTER_SUCCESS'
-
-. $DRONE_BUILD_DIR/.drone/after-success.sh
--- a/.drone/drone.bat
+++ b/.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
--- a/.drone/drone.sh
+++ b/.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}
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -16,7 +16,6 @@ target_link_libraries(boost_array
  INTERFACE
    Boost::assert
    Boost::config
-    Boost::core
    Boost::static_assert
    Boost::throw_exception
 )
--- a/build.jam
+++ b/build.jam
@ -0,0 +1,24 @@
+# Copyright 2023-2024 René Ferdinand Rivera Morell
+# Copyright 2024 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/assert//boost_assert
+    /boost/config//boost_config
+    /boost/static_assert//boost_static_assert
+    /boost/throw_exception//boost_throw_exception
+    ;
+
+project /boost/array ;
+
+explicit
+    [ alias boost_array : : : : <include>include <library>$(boost_dependencies) ]
+    [ alias all : boost_array test ]
+    ;
+
+call-if : boost-library array
+    ;
+
--- a/doc/array.adoc
+++ b/doc/array.adoc
@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 https://www.boost.org/LICENSE_1_0.txt
 ////

-# Array
+# Boost.Array
 Nicolai M. Josuttis
 :toc: left
 :toclevels: 4
@ -18,8 +18,8 @@ Nicolai M. Josuttis

 :leveloffset: +1

-
 include::array/introduction.adoc[]
+include::array/changes.adoc[]
 include::array/reference.adoc[]
 include::array/design_rationale.adoc[]
 include::array/information.adoc[]
--- a/doc/array/changes.adoc
+++ b/doc/array/changes.adoc
@ -0,0 +1,24 @@
+////
+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.
+* Marked obsolete functions as deprecated.
+* Removed obsolete compiler workarounds.
+* Changed `array<T, 0>::begin()`, `cbegin()`, `end()`, `cend()` to return `nullptr`, enabling `constexpr`.
+  This matches the behavior of `std::array`.
+* Removed local `hash_value` overload; `boost::hash` supports array-like types natively.
+* `array<T, 0>` can now be initialized with `= {{}}`.
+* Added `operator\<\=>`.
+* Added `to_array`.
--- a/doc/array/copyright.adoc
+++ b/doc/array/copyright.adoc
@ -12,4 +12,4 @@ Copyright (C) 2001-2004 Nicolai M. Josuttis

 Copyright (C) 2012 Marshall Clow

-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)
+Distributed under the https://www.boost.org/LICENSE_1_0.txt[Boost Software License, Version 1.0].
--- a/doc/array/design_rationale.adoc
+++ b/doc/array/design_rationale.adoc
@ -37,7 +37,3 @@ Note that for standard conforming compilers it is possible to use fewer braces (
 ```cpp
 boost::array<int,4> a = { 1, 2, 3 };
 ```
-
-I'd appreciate any constructive feedback. **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.**
-
-The code is provided "as is" without expressed or implied warranty.
--- a/doc/array/introduction.adoc
+++ b/doc/array/introduction.adoc
@ -11,11 +11,18 @@ https://www.boost.org/LICENSE_1_0.txt
 :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).
+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.
+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].
+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`.

--- a/doc/array/reference.adoc
+++ b/doc/array/reference.adoc
@ -15,24 +15,40 @@ https://www.boost.org/LICENSE_1_0.txt

 ```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>
-    bool operator==(const array<T, N>&, const array<T, N>&);
+    void swap(array<T, N>&, array<T, N>&);
+
  template<typename T, std::size_t N>
-    bool operator!=(const array<T, N>&, const array<T, N>&);
+    constexpr bool operator==(const array<T, N>&, const array<T, N>&);
  template<typename T, std::size_t N>
-    bool operator<(const array<T, N>&, const array<T, N>&);
+    constexpr bool operator!=(const array<T, N>&, const array<T, N>&);
+
  template<typename T, std::size_t N>
-    bool operator>(const array<T, N>&, const array<T, N>&);
+    constexpr bool operator<(const array<T, N>&, const array<T, N>&);
  template<typename T, std::size_t N>
-    bool operator<=(const array<T, N>&, const array<T, N>&);
+    constexpr bool operator>(const array<T, N>&, const array<T, N>&);
  template<typename T, std::size_t N>
-    bool operator>=(const array<T, N>&, const array<T, N>&);
-  template<typename T, std::size_t N, std::size_t Idx>
-    T boost::get(array<T, N>&);
-  template<typename T, std::size_t N, std::size_t Idx>
-    T boost::get(const array<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 auto 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;
+
+  template<class T, std::size_t N>
+    constexpr array<T, N> to_array( T const (&)[N] );
+  template<class T, std::size_t N>
+    constexpr array<T, N> to_array( T (&&)[N] );
+  template<class T, std::size_t N>
+    constexpr array<T, N> to_array( T const (&&)[N] );
 }
 ```

@ -46,7 +62,9 @@ namespace boost {
 template<typename T, std::size_t N>
 class array {
 public:
+
  // types
+
  typedef T                                     value_type;
  typedef T*                                    iterator;
  typedef const T*                              const_iterator;
@ -58,361 +76,377 @@ public:
  typedef std::ptrdiff_t                        difference_type;

  // static constants
+
  static const size_type static_size = N;

-  // construct/copy/destruct
+  // construct/copy/destroy
+
  template<typename U> array& operator=(const array<U, N>&);

  // iterator support
-  iterator begin();
-  const_iterator begin() const;
-  iterator end();
-  const_iterator end() const;
-  const_iterator cbegin();
-  const_iterator cend();
+
+  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();
-  const_reverse_iterator rbegin() const;
-  reverse_iterator rend();
-  const_reverse_iterator rend() const;
-  const_reverse_iterator crbegin();
-  const_reverse_iterator crend();
+
+  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
-  size_type size();
-  bool empty();
-  size_type max_size();
+
+  static constexpr size_type size() noexcept;
+  static constexpr bool empty() noexcept;
+  static constexpr size_type max_size() noexcept;

  // element access
-  reference operator[](size_type);
-  const_reference operator[](size_type) const;
-  reference at(size_type);
-  const_reference at(size_type) const;
-  reference front();
-  const_reference front() const;
-  reference back();
-  const_reference back() const;
-  const T* data() const;
-  T* c_array();
+
+  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
-  void swap(array<T, N>&);
-  void assign(const T&);
+
+  swap(array<T, N>&);
+
+  constexpr void fill(const T&);
+  void assign(const T&); // deprecated

  // public data members
  T elems[N];
 };
-
-// specialized algorithms
-template<typename T, std::size_t N> void swap(array<T, N>&, array<T, N>&);
-
-// comparisons
-template<typename T, std::size_t N>
-  bool operator==(const array<T, N>&, const array<T, N>&);
-template<typename T, std::size_t N>
-  bool operator!=(const array<T, N>&, const array<T, N>&);
-template<typename T, std::size_t N>
-  bool operator<(const array<T, N>&, const array<T, N>&);
-template<typename T, std::size_t N>
-  bool operator>(const array<T, N>&, const array<T, N>&);
-template<typename T, std::size_t N>
-  bool operator<=(const array<T, N>&, const array<T, N>&);
-template<typename T, std::size_t N>
-  bool operator>=(const array<T, N>&, const array<T, N>&);
-
-// specializations
-template<typename T, std::size_t N, std::size_t Idx>
-  T boost::get(array<T, N>&);
-template<typename T, std::size_t N, std::size_t Idx>
-  T boost::get(const array<T, N>&);
 ```

-### Description
-
-#### array public construct/copy/destruct
+### Construct/Copy/Destroy

 ```
 template<typename U> array& operator=(const array<U, N>& other);
 ```
 [horizontal]
-Effects: :: `std::copy(rhs.begin(), rhs.end(), begin())`
+Effects: :: For each `i` in `[0..N)`, performs `elems[i] = other.elems[i];`.

 ---

-#### array iterator support
+### Iterator Support

 ```
-iterator begin();
-const_iterator begin() const;
+constexpr iterator begin() noexcept;
+constexpr const_iterator begin() const noexcept;
+constexpr const_iterator cbegin() const noexcept;
 ```
 [horizontal]
-Returns: :: iterator for the first element
-Throws: :: will not throw
+Returns: :: `data()`.

 ---

 ```
-iterator end();
-const_iterator end() const;
+constexpr iterator end() noexcept;
+constexpr const_iterator end() const noexcept;
+constexpr const_iterator cend() const noexcept;
 ```
 [horizontal]
-Returns: :: iterator for position after the last element
-Throws: :: will not throw
+Returns: :: `data() + size()`.

 ---

+### Reverse Iterator Support
+
 ```
-const_iterator cbegin();
+reverse_iterator rbegin() noexcept;
 ```
 [horizontal]
-Returns: :: constant iterator for the first element
-Throws: :: will not throw
+Returns: :: `reverse_iterator(end())`.

 ---

 ```
-const_iterator cend();
+const_reverse_iterator rbegin() const noexcept;
+const_reverse_iterator crbegin() const noexcept;
 ```
 [horizontal]
-Returns: :: constant iterator for position after the last element
-Throws: :: will not throw
+Returns: :: `const_reverse_iterator(end())`.

 ---

-#### array reverse iterator support
-
 ```
-reverse_iterator rbegin();
-const_reverse_iterator rbegin() const;
+reverse_iterator rend() noexcept;
 ```
 [horizontal]
-Returns: :: reverse iterator for the first element of reverse iteration
+Returns: :: `reverse_iterator(begin())`.

 ---

 ```
-reverse_iterator rend();
-const_reverse_iterator rend() const;
+const_reverse_iterator rend() const noexcept;
+const_reverse_iterator crend() const noexcept;
 ```
 [horizontal]
-Returns: :: reverse iterator for position after the last element in reverse iteration
+Returns: ::  `const_reverse_iterator(begin())`.

 ---

+### Capacity
+
 ```
-const_reverse_iterator crbegin();
+static constexpr size_type size() noexcept;
 ```
 [horizontal]
-Returns: :: constant reverse iterator for the first element of reverse iteration
-Throws: :: will not throw
+Returns: :: `N`.

 ---

 ```
-const_reverse_iterator crend();
+static constexpr bool empty() noexcept;
 ```
 [horizontal]
-Returns: ::  constant reverse iterator for position after the last element in reverse iteration
-Throws: ::  will not throw
+Returns: :: `N == 0`.

 ---

-#### array capacity
-
 ```
-size_type size();
+static constexpr size_type max_size() noexcept;
 ```
 [horizontal]
-Returns: :: `N`
+Returns: :: `N`.

 ---

+### Element Access
+
 ```
-bool empty();
+constexpr reference operator[](size_type i);
+constexpr const_reference operator[](size_type i) const;
 ```
 [horizontal]
-Returns: :: `N==0`
-Throws: :: will not throw
+Requires: :: `i < N`.
+Returns: ::  `elems[i]`.
+Throws: :: Nothing.

 ---

 ```
-size_type max_size();
+constexpr reference at(size_type i);
+constexpr const_reference at(size_type i) const;
 ```
 [horizontal]
-Returns: :: `N`
-Throws: ::  will not throw
+Returns: :: `elems[i]`.
+Throws: :: `std::out_of_range` if `i >= N`.

 ---

-#### array element access
-
 ```
-reference operator[](size_type i);
-const_reference operator[](size_type i) const;
+constexpr reference front();
+constexpr const_reference front() const;
 ```
 [horizontal]
-Requires: :: `i < N`
-Returns: ::  element with index `i`
-Throws: :: will not throw.
+Requires: ::  `N > 0`.
+Returns: :: `elems[0]`.
+Throws: :: Nothing.

 ---

 ```
-reference at(size_type i);
-const_reference at(size_type i) const;
+constexpr reference back();
+constexpr const_reference back() const;
 ```
 [horizontal]
-Returns: :: element with index `i`
-Throws: :: `std::range_error` if `i >= N`
+Requires: :: `N > 0`.
+Returns: :: `elems[N-1]`.
+Throws: :: Nothing.

 ---

 ```
-reference front();
-const_reference front() const;
+constexpr T* data() noexcept;
+constexpr const T* data() const noexcept;
 ```
 [horizontal]
-Requires: ::  `N > 0`
-Returns: :: the first element
-Throws: :: will not throw
+Returns: :: `elems`.

 ---

 ```
-reference back();
-const_reference back() const;
+T* c_array() noexcept; // deprecated
 ```
 [horizontal]
-Requires: :: `N > 0`
-Returns: :: the last element
-Throws: :: will not throw
+Returns: :: `data()`.
+Remarks: :: This function is deprecated. Use `data()` instead.

 ---

-```
-const T* data() const;
-```
-[horizontal]
-Returns: :: `elems`
-Throws: :: will not throw
-
---
-
-```
-T* c_array();
-```
-[horizontal]
-Returns: :: `elems`
-Throws: :: will not throw
-
---
-
-#### array modifiers
+### Modifiers

 ```
 void swap(array<T, N>& other);
 ```
 [horizontal]
-Effects: :: `std::swap_ranges(begin(), end(), other.begin())`
-Complexity: :: linear in `N`
+Effects: :: `std::swap(elems, other.elems)`.
+Complexity: :: linear in `N`.

 ---

 ```
-void assign(const T& value);
+void fill(const T& value);
 ```
 [horizontal]
-Effects: :: `std::fill_n(begin(), N, value)`
+Effects: :: For each `i` in `[0..N)`, performs `elems[i] = value;`.

 ---

-#### array specialized algorithms
-
 ```
-template<typename T, std::size_t N> void swap(array<T, N>& x, array<T, N>& y);
+void assign(const T& value); // deprecated
 ```
 [horizontal]
-Effects: :: `x.swap(y)`
-Throws: :: will not throw.
+Effects: :: `fill(value)`.
+Remarks: :: An obsolete and deprecated spelling of `fill`. Use `fill` instead.

 ---

-#### array comparisons
+### Specialized Algorithms

 ```
 template<typename T, std::size_t N>
-  bool operator==(const array<T, N>& x, const array<T, N>& y);
+  void swap(array<T, N>& x, array<T, N>& y);
 ```
 [horizontal]
-Returns: :: `std::equal(x.begin(), x.end(), y.begin())`
+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>
-  bool operator!=(const array<T, N>& x, const array<T, N>& y);
+  constexpr bool operator!=(const array<T, N>& x, const array<T, N>& y);
 ```
 [horizontal]
-Returns: :: `!(x == y)`
+Returns: :: `!(x == y)`.

 ---

 ```
 template<typename T, std::size_t N>
-  bool operator<(const array<T, N>& x, const array<T, N>& y);
+  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())`
+Returns: :: `std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end())`.

 ---

 ```
 template<typename T, std::size_t N>
-  bool operator>(const array<T, N>& x, const array<T, N>& y);
+  constexpr bool operator>(const array<T, N>& x, const array<T, N>& y);
 ```
 [horizontal]
-Returns: :: `y < x`
+Returns: :: `y < x`.

 ---

 ```
 template<typename T, std::size_t N>
-  bool operator<=(const array<T, N>& x, const array<T, N>& y);
+  constexpr bool operator<=(const array<T, N>& x, const array<T, N>& y);
 ```
 [horizontal]
-Returns: :: `!(y < x)`
+Returns: :: `!(y < x)`.

 ---

 ```
 template<typename T, std::size_t N>
-  bool operator>=(const array<T, N>& x, const array<T, N>& y);
+  constexpr bool operator>=(const array<T, N>& x, const array<T, N>& y);
 ```
 [horizontal]
-Returns: :: `!(x < y)`
-
---
-
-#### array specializations
-
-```
-template<typename T, std::size_t N, std::size_t Idx>
-  T boost::get(array<T, N>& arr);
-```
-[horizontal]
-Returns: :: element of array with index `Idx`
-Effects: :: Will `static_assert` if `Idx >= N`
+Returns: :: `!(x < y)`.

 ---

 ```
-template<typename T, std::size_t N, std::size_t Idx>
-  T boost::get(const array<T, N>& arr);
+template<typename T, std::size_t N>
+  constexpr auto operator<=>(const array<T, N>& x, const array<T, N>& y)
+  -> decltype(x[0] <=> y[0]);
 ```
 [horizontal]
-Returns: :: const element of array with index `Idx`
-Effects: :: Will `static_assert` if `Idx >= N`
+Effects: :: For each `i` in `[0..N)`, if `(x[i] \<\=> y[i]) != 0`, returns `x[i] \<\=> y[i]`. Otherwise, returns `std::strong_ordering::equal`, converted to the return type.
+Remarks: :: When `N` is 0, the return type is `std::strong_ordering` and the return value is `std::strong_ordering::equal`.
+
+---
+
+### 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]`.
+
+---
+
+
+### Creation
+
+```
+template<class T, std::size_t N>
+  constexpr array<T, N> to_array( T const (&a)[N] );
+```
+[horizontal]
+Returns: :: an `array<T, N>` `r` such that for each `i` in `[0..N)`, `r[i]` is copied from `a[i]`.
+
+```
+template<class T, std::size_t N>
+  constexpr array<T, N> to_array( T (&&a)[N] );
+```
+[horizontal]
+Returns: :: an `array<T, N>` `r` such that for each `i` in `[0..N)`, `r[i]` is moved from `std::move(a[i])`.
+
+```
+template<class T, std::size_t N>
+  constexpr array<T, N> to_array( T const (&&a)[N] );
+```
+[horizontal]
+Returns: :: an `array<T, N>` `r` such that for each `i` in `[0..N)`, `r[i]` is copied from `a[i]`.

 ---
--- a/include/boost/array.hpp
+++ b/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.
 *
@ -28,31 +31,31 @@
 *
 * Jan 29, 2004
 */
-#ifndef BOOST_ARRAY_HPP
-#define BOOST_ARRAY_HPP

-#include <boost/detail/workaround.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>

 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
 # pragma warning(push)
-# pragma warning(disable:4996) // 'std::equal': Function call with parameters that may be unsafe
-# pragma warning(disable:4510) // boost::array<T,N>' : default constructor could not be generated
-# pragma warning(disable:4610) // warning C4610: class 'boost::array<T,N>' can never be instantiated - user defined constructor required
+# 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
+# pragma warning(disable: 4702) // unreachable code
 #endif

-#include <cstddef>
+#include <boost/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/throw_exception.hpp>
 #include <iterator>
 #include <stdexcept>
-#include <boost/assert.hpp>
-#include <boost/core/invoke_swap.hpp>
-#include <boost/static_assert.hpp>
-
-#include <boost/throw_exception.hpp>
-#include <algorithm>
-
-// FIXES for broken compilers
-#include <boost/config.hpp>
+#include <utility>
+#include <cstddef>

+#if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L
+# if __has_include(<compare>)
+#  include <compare>
+# endif
+#endif

 namespace boost {

@ -72,62 +75,54 @@ namespace boost {
        typedef std::ptrdiff_t difference_type;

        // iterator support
-        iterator        begin()       { return elems; }
-        const_iterator  begin() const { return elems; }
-        const_iterator cbegin() const { return elems; }
+        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; }

-        iterator        end()       { return elems+N; }
-        const_iterator  end() const { return elems+N; }
-        const_iterator cend() const { return elems+N; }
+        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_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(_RWSTD_NO_CLASS_PARTIAL_SPEC)
-        typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
-              value_type, reference, iterator, difference_type> reverse_iterator;
-        typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
-              value_type, const_reference, const_iterator, difference_type> const_reverse_iterator;
-#else
-        // workaround for broken reverse_iterator implementations
-        typedef std::reverse_iterator<iterator,T> reverse_iterator;
-        typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
-#endif

-        reverse_iterator rbegin() { 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());
        }
-        const_reverse_iterator crbegin() const {
+        const_reverse_iterator crbegin() const BOOST_NOEXCEPT {
            return const_reverse_iterator(end());
        }

-        reverse_iterator rend() { return reverse_iterator(begin()); }
-        const_reverse_iterator rend() const {
+        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 {
+        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)
        {
            return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i];
        }

-        /*BOOST_CONSTEXPR*/ const_reference operator[](size_type i) const
+#if !BOOST_WORKAROUND(BOOST_GCC, < 50000)
+        BOOST_CONSTEXPR
+#endif
+        const_reference operator[](size_type i) const
        {
            return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i];
        }

        // at() with range check
-        reference                           at(size_type i)       { return rangecheck(i), elems[i]; }
-        /*BOOST_CONSTEXPR*/ const_reference at(size_type i) const { return rangecheck(i), 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];
        }
@ -137,7 +132,7 @@ namespace boost {
            return elems[0];
        }

-        reference back()
+        BOOST_CXX14_CONSTEXPR reference back()
        {
            return elems[N-1];
        }
@ -148,38 +143,56 @@ namespace boost {
        }

        // size is constant
-        static BOOST_CONSTEXPR size_type size() { return N; }
-        static BOOST_CONSTEXPR bool empty() { return false; }
-        static BOOST_CONSTEXPR 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::core::invoke_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 ( value ); }    // A synonym for fill
-        void fill   (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 BOOST_CONSTEXPR bool rangecheck (size_type i) {
            return i >= size() ? boost::throw_exception(std::out_of_range ("array<>: index out of range")), true : true;
@ -189,6 +202,8 @@ namespace boost {

    template< class T >
    class array< T, 0 > {
+      public:
+        struct {} elems; // enables initialization with = {{}}

      public:
        // type definitions
@ -201,42 +216,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 ) ); }
-        const_iterator cbegin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
+        BOOST_CXX14_CONSTEXPR iterator  begin()       BOOST_NOEXCEPT { return data(); }
+        BOOST_CONSTEXPR const_iterator  begin() const BOOST_NOEXCEPT { return data(); }
+        BOOST_CONSTEXPR const_iterator cbegin() const BOOST_NOEXCEPT { return data(); }

-        iterator        end()       { return  begin(); }
-        const_iterator  end() const { return  begin(); }
-        const_iterator cend() const { return cbegin(); }
+        BOOST_CXX14_CONSTEXPR iterator  end()       BOOST_NOEXCEPT { return  begin(); }
+        BOOST_CONSTEXPR const_iterator  end() const BOOST_NOEXCEPT { return  begin(); }
+        BOOST_CONSTEXPR const_iterator cend() const BOOST_NOEXCEPT { return cbegin(); }

        // reverse iterator support
-#if !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(_RWSTD_NO_CLASS_PARTIAL_SPEC)
-        typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
-              value_type, reference, iterator, difference_type> reverse_iterator;
-        typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
-              value_type, const_reference, const_iterator, difference_type> const_reverse_iterator;
-#else
-        // workaround for broken reverse_iterator implementations
-        typedef std::reverse_iterator<iterator,T> reverse_iterator;
-        typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
-#endif

-        reverse_iterator rbegin() { 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());
        }
-        const_reverse_iterator crbegin() const {
+        const_reverse_iterator crbegin() const BOOST_NOEXCEPT {
            return const_reverse_iterator(end());
        }

-        reverse_iterator rend() { return reverse_iterator(begin()); }
-        const_reverse_iterator rend() const {
+        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 {
+        const_reverse_iterator crend() const BOOST_NOEXCEPT {
            return const_reverse_iterator(begin());
        }

@ -246,14 +250,14 @@ namespace boost {
            return failed_rangecheck();
        }

-        /*BOOST_CONSTEXPR*/ const_reference operator[](size_type /*i*/) const
+        const_reference operator[](size_type /*i*/) const
        {
            return failed_rangecheck();
        }

        // at() with range check
-        reference at(size_type /*i*/)               {   return failed_rangecheck(); }
-        /*BOOST_CONSTEXPR*/ const_reference at(size_type /*i*/) const   { return failed_rangecheck(); }
+        reference at(size_type /*i*/)               { return failed_rangecheck(); }
+        const_reference at(size_type /*i*/) const   { return failed_rangecheck(); }

        // front() and back()
        reference front()
@ -261,7 +265,7 @@ namespace boost {
            return failed_rangecheck();
        }

-        BOOST_CONSTEXPR const_reference front() const
+        const_reference front() const
        {
            return failed_rangecheck();
        }
@ -271,26 +275,28 @@ namespace boost {
            return failed_rangecheck();
        }

-        BOOST_CONSTEXPR const_reference back() const
+        const_reference back() const
        {
            return failed_rangecheck();
        }

        // size is constant
-        static BOOST_CONSTEXPR size_type size() { return 0; }
-        static BOOST_CONSTEXPR bool empty() { return true; }
-        static BOOST_CONSTEXPR 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>
@ -298,87 +304,119 @@ namespace boost {
            return *this;
        }

-        // assign one value to all elements
+        // an obsolete synonym for fill
+        BOOST_DEPRECATED( "please use `fill` instead" )
        void assign (const T& value) { fill ( value ); }
-        void fill   (const T& ) {}
+
+        // 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
-                // actually get here....
-                //
-                static T placeholder;
-                return placeholder;
-#endif
-            }
+        static reference failed_rangecheck ()
+        {
+            boost::throw_exception( std::out_of_range( "attempt to access element of an empty array" ) );
+        }
    };

    // 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;
+        }
+
+        return true;
    }
-    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());
+
+#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);
    }

-#if defined(__SUNPRO_CC)
-//  Trac ticket #4757; the Sun Solaris compiler can't handle
-//  syntax like 'T(&get_c_array(boost::array<T,N>& arg))[N]'
-//
-//  We can't just use this for all compilers, because the
-//      borland compilers can't handle this form.
-    namespace detail {
-       template <typename T, std::size_t N> struct c_array
-       {
-           typedef T type[N];
-       };
+#if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L
+# if __has_include(<compare>)
+
+    template<class T, std::size_t N>
+    constexpr auto operator<=> (const array<T,N>& x, const array<T,N>& y)
+        -> decltype( x.elems[ 0 ] <=> y.elems[ 0 ] )
+    {
+        for( std::size_t i = 0; i < N; ++i )
+        {
+            auto r = x.elems[ i ] <=> y.elems[ i ];
+            if( r != 0 ) return r;
+        }
+
+        return std::strong_ordering::equal;
    }

-   // Specific for boost::array: simply returns its elems data member.
-   template <typename T, std::size_t N>
-   typename detail::c_array<T,N>::type& get_c_array(boost::array<T,N>& arg)
-   {
-       return arg.elems;
-   }
+    template<class T>
+    constexpr auto operator<=> (const array<T,0>& /*x*/, const array<T,0>& /*y*/)
+        -> std::strong_ordering
+    {
+        return std::strong_ordering::equal;
+    }

-   // Specific for boost::array: simply returns its elems data member.
-   template <typename T, std::size_t N>
-   typename detail::c_array<T,N>::type const& get_c_array(const boost::array<T,N>& arg)
-   {
-       return arg.elems;
-   }
-#else
-// Specific for boost::array: simply returns its elems data member.
+# endif
+#endif
+
+    // 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;
@ -386,49 +424,68 @@ namespace boost {

    // 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;
    }
-#endif

-#if 0
-    // Overload for std::array, assuming that std::array will have
-    // explicit conversion functions as discussed at the WG21 meeting
-    // in Summit, March 2009.
-    template <typename T, std::size_t N>
-    T(&get_c_array(std::array<T,N>& arg))[N]
+    template <size_t Idx, typename T, size_t N>
+    BOOST_CXX14_CONSTEXPR T &get(boost::array<T,N> &arr) BOOST_NOEXCEPT
    {
-        return static_cast<T(&)[N]>(arg);
+        BOOST_STATIC_ASSERT_MSG ( Idx < N, "boost::get<>(boost::array &) index out of range" );
+        return arr[Idx];
    }

-    // Const version.
-    template <typename T, std::size_t N>
-    const T(&get_c_array(const std::array<T,N>& arg))[N]
+    template <size_t Idx, typename T, size_t N>
+    BOOST_CONSTEXPR const T &get(const boost::array<T,N> &arr) BOOST_NOEXCEPT
    {
-        return static_cast<T(&)[N]>(arg);
+        BOOST_STATIC_ASSERT_MSG ( Idx < N, "boost::get<>(const boost::array &) index out of range" );
+        return arr[Idx];
    }
-#endif
-
-    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)
+    BOOST_CXX14_CONSTEXPR array<T, N> to_array( T const (&a)[ N ] )
    {
-        return boost::hash_range(arr.begin(), arr.end());
+        array<T, N> r = {};
+
+        for( std::size_t i = 0; i < N; ++i )
+        {
+            r[ i ] = a[ i ];
+        }
+
+        return r;
    }

-   template <size_t Idx, typename T, size_t N>
-   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];
-       }
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

-   template <size_t Idx, typename T, size_t N>
-   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];
-       }
+    template<class T, std::size_t N>
+    BOOST_CXX14_CONSTEXPR array<T, N> to_array( T (&&a)[ N ] )
+    {
+        array<T, N> r = {};
+
+        for( std::size_t i = 0; i < N; ++i )
+        {
+            r[ i ] = std::move( a[ i ] );
+        }
+
+        return r;
+    }
+
+    template<class T, std::size_t N>
+    BOOST_CXX14_CONSTEXPR array<T, N> to_array( T const (&&a)[ N ] )
+    {
+        array<T, N> r = {};
+
+        for( std::size_t i = 0; i < N; ++i )
+        {
+            r[ i ] = a[ i ];
+        }
+
+        return r;
+    }
+
+#endif

 } /* namespace boost */

@ -436,12 +493,14 @@ namespace boost {
 //  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];
@ -453,4 +512,4 @@ namespace std {
 # pragma warning(pop)
 #endif

-#endif /*BOOST_ARRAY_HPP*/
+#endif // #ifndef BOOST_ARRAY_HPP_INCLUDED
--- a/index.html
+++ b/index.html
@ -4,8 +4,8 @@
 </head>
 <body>
 Automatic redirection failed, please go to
-<a href="../../doc/html/array.html">doc/html/array.html</a> &nbsp;<hr>
-<p><EFBFBD> Copyright Beman Dawes, 2001</p>
+<a href="doc/html/array.html">doc/html/array.html</a> &nbsp;<hr>
+<p>© Copyright Beman Dawes, 2001</p>
 <p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
 file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
 at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -7,6 +7,41 @@ import testing ;
 import-search /boost/config/checks ;
 import config : requires ;

+project
+    : requirements
+
+        <library>/boost/array//boost_array
+        <library>/boost/core//boost_core
+
+        <warnings>extra
+
+        <toolset>msvc:<warnings-as-errors>on
+        <toolset>clang:<warnings-as-errors>on
+        <toolset>gcc:<warnings-as-errors>on
+
+        <toolset>gcc-4.6:<cxxflags>-Wno-missing-braces
+        <toolset>gcc-4.7:<cxxflags>-Wno-missing-braces
+
+        <toolset>gcc-4.6:<cxxflags>-Wno-missing-field-initializers
+        <toolset>gcc-4.7:<cxxflags>-Wno-missing-field-initializers
+        <toolset>gcc-4.8:<cxxflags>-Wno-missing-field-initializers
+        <toolset>gcc-4.9:<cxxflags>-Wno-missing-field-initializers
+
+        <toolset>gcc-4.6:<cxxflags>-Wno-type-limits
+        <toolset>gcc-4.7:<cxxflags>-Wno-type-limits
+        <toolset>gcc-10:<cxxflags>-Wno-type-limits
+
+        <toolset>clang:<cxxflags>-Wno-unnamed-type-template-args
+
+        <toolset>clang-3.5:<cxxflags>-Wno-missing-braces
+        <toolset>clang-3.6:<cxxflags>-Wno-missing-braces
+        <toolset>clang-3.7:<cxxflags>-Wno-missing-braces
+        <toolset>clang-3.8:<cxxflags>-Wno-missing-braces
+        <toolset>clang-3.9:<cxxflags>-Wno-missing-braces
+        <toolset>clang-4:<cxxflags>-Wno-missing-braces
+        <toolset>clang-5:<cxxflags>-Wno-missing-braces
+    ;
+
 #

 run array0.cpp ;
@ -18,13 +53,15 @@ run array5.cpp ;
 run array6.cpp ;
 run array7.cpp ;

-# run array_constexpr.cpp ;
+compile array_constexpr.cpp ;

-compile-fail array_getfail1.cpp ;
-compile-fail array_getfail2.cpp ;
+compile-fail array_getfail1.cpp
+  : <warnings>off ;
+compile-fail array_getfail2.cpp
+  : <warnings>off ;

 run array_hash.cpp
-  : : : [ requires cxx11_noexcept ] ;
+  : : : <library>/boost/container_hash//boost_container_hash [ requires cxx11_noexcept ] ;

 #

@ -45,7 +82,29 @@ run array_swap_test.cpp ;
 run array_swap_test2.cpp ;
 run array_eq_test.cpp ;
 run array_lt_test.cpp ;
+run array_thw_test.cpp ;
 run array_get_test.cpp ;
+run to_array_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_assign_test_cx.cpp ;
+compile array_access_test_cx2.cpp ;
+compile array_fill_test_cx.cpp ;
+compile array_eq_test_cx.cpp ;
+compile array_lt_test_cx.cpp ;
+compile array_thw_test_cx.cpp ;
+compile to_array_test_cx.cpp ;

 #

--- a/test/array0.cpp
+++ b/test/array0.cpp
@ -5,11 +5,11 @@
 * 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>
-
-#include <boost/core/lightweight_test_trait.hpp>

 namespace {

@ -44,7 +44,12 @@ void    RunTests()
    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() );
+    // BOOST_TEST ( test_case.begin() != const_test_case.begin() );
+    //
+    // TR1 specified that begin() must return a unique value for zero-sized
+    // arrays. However, this makes constexpr unimplementable, and all standard
+    // libraries have converged on using nullptr instead (see LWG issue 2157.)
+
    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!
--- a/test/array5.cpp
+++ b/test/array5.cpp
@ -5,6 +5,8 @@
 * http://www.boost.org/LICENSE_1_0.txt)
 */

+#define BOOST_ALLOW_DEPRECATED_SYMBOLS // assign
+
 #include <iostream>
 #include <boost/array.hpp>

--- a/test/array6.cpp
+++ b/test/array6.cpp
@ -5,12 +5,20 @@
 * http://www.boost.org/LICENSE_1_0.txt)
 */

+#define BOOST_ALLOW_DEPRECATED_SYMBOLS // get_c_array
+
+#include <boost/array.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 #include <string>
 #include <iostream>
-#include <boost/array.hpp>
 #include <algorithm>

-#include <boost/core/lightweight_test_trait.hpp>
+#if defined(BOOST_GCC) && BOOST_GCC / 10000 == 13
+// false -Warray-bounds positive when using -fsanitize=undefined
+// restricted to GCC 13 because that's what is tested on Drone
+# pragma GCC diagnostic ignored "-Warray-bounds"
+#endif

 namespace {
    template< class T >
--- a/test/array7.cpp
+++ b/test/array7.cpp
@ -5,6 +5,8 @@
 * http://www.boost.org/LICENSE_1_0.txt)
 */

+#define BOOST_ALLOW_DEPRECATED_SYMBOLS // std::get
+
 #include <string>
 #include <iostream>
 #include <boost/array.hpp>
--- a/test/array_access_test.cpp
+++ b/test/array_access_test.cpp
@ -1,6 +1,6 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #define BOOST_ENABLE_ASSERT_HANDLER

--- a/test/array_access_test_cx.cpp
+++ b/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
--- a/test/array_access_test_cx2.cpp
+++ b/test/array_access_test_cx2.cpp
@ -0,0 +1,45 @@
+// 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> constexpr boost::array<T, N> modified( boost::array<T, N> a1 )
+{
+    a1.front() = 1;
+    a1[ 1 ] = 2;
+    a1.at( 2 ) = 3;
+    a1.back() = 4;
+
+    return a1;
+}
+
+template<class T> void test1()
+{
+    constexpr boost::array<T, 4> a1 = {};
+    constexpr boost::array<T, 4> a2 = modified( a1 );
+
+    STATIC_ASSERT( a2[0] == 1 );
+    STATIC_ASSERT( a2[1] == 2 );
+    STATIC_ASSERT( a2[2] == 3 );
+    STATIC_ASSERT( a2[3] == 4 );
+}
+
+int main()
+{
+    test1<int>();
+}
+
+#endif
--- a/test/array_assign_test.cpp
+++ b/test/array_assign_test.cpp
@ -1,13 +1,18 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt
+
+#define BOOST_ALLOW_DEPRECATED_SYMBOLS
+
+// assign is a deprecated nonstandard equivalent of fill

 #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
+#if defined(_MSC_VER)
+# pragma warning(disable: 4702) // unreachable code
+#endif

 template<class T, std::size_t N> void test()
 {
--- a/test/array_assign_test_cx.cpp
+++ b/test/array_assign_test_cx.cpp
@ -0,0 +1,54 @@
+// 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> constexpr boost::array<T, N> assigned( boost::array<T, N> const& a1 )
+{
+    boost::array<T, N> a2 = {};
+
+    a2 = a1;
+
+    return a2;
+}
+
+template<class T> void test1()
+{
+    constexpr boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
+    constexpr boost::array<T, 4> a2 = assigned( a1 );
+
+    STATIC_ASSERT( a1[0] == a2[0] );
+    STATIC_ASSERT( a1[1] == a2[1] );
+    STATIC_ASSERT( a1[2] == a2[2] );
+    STATIC_ASSERT( a1[3] == a2[3] );
+}
+
+template<class T> void test2()
+{
+    constexpr boost::array<T, 0> a1 = {};
+    constexpr boost::array<T, 0> a2 = assigned( a1 );
+
+    (void)a1;
+    (void)a2;
+}
+
+int main()
+{
+    test1<int>();
+    test2<int>();
+}
+
+#endif
--- a/test/array_c_array_test.cpp
+++ b/test/array_c_array_test.cpp
@ -1,6 +1,8 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt
+
+#define BOOST_ALLOW_DEPRECATED_SYMBOLS

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
@ -8,8 +10,7 @@
 #include <boost/config/workaround.hpp>
 #include <cstddef>

-// c_array and get_c_array are nonstandard extensions
-// probably need to be deprecated and removed
+// c_array and get_c_array are deprecated nonstandard extensions

 template<class T, std::size_t N> void test()
 {
--- a/test/array_constexpr.cpp
+++ b/test/array_constexpr.cpp
@ -5,27 +5,15 @@
 * 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/config.hpp>

 #ifndef BOOST_NO_CXX11_CONSTEXPR
+
 constexpr boost::array<int, 10> arr  {{ 0,1,2,3,4,5,6,7,8,9 }};
-constexpr std::array<int, 10> arr_std {{ 0,1,2,3,4,5,6,7,8,9 }};
-
-template <typename T>
-void sink ( T t ) {}
-
-template <typename T, size_t N>
-void sink ( boost::array<T,N> &arr ) {}

 int main()
 {
-//    constexpr int two = arr_std.at (2);
    constexpr int three = arr.at (3);
    int whatever [ arr.at(4) ];
    (void)three;
@ -33,7 +21,9 @@ int main()
 }

 #else   // no constexpr means no constexpr tests!
+
 int main()
 {
 }
+
 #endif
--- a/test/array_convert_test.cpp
+++ b/test/array_convert_test.cpp
@ -1,6 +1,6 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
--- a/test/array_copy_test.cpp
+++ b/test/array_copy_test.cpp
@ -1,6 +1,6 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
@ -44,11 +44,11 @@ template<class T> void test4()

 int main()
 {
-    // test1<int, 0>();
+    test1<int, 0>();
    test1<int, 1>();
    test1<int, 7>();

-    // test1<int const, 0>();
+    test1<int const, 0>();
    test1<int const, 1>();
    test1<int const, 7>();

--- a/test/array_copy_test_cx.cpp
+++ b/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
--- a/test/array_data_test.cpp
+++ b/test/array_data_test.cpp
@ -1,6 +1,6 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
--- a/test/array_data_test_cx.cpp
+++ b/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
--- a/test/array_elems_test.cpp
+++ b/test/array_elems_test.cpp
@ -1,6 +1,6 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
--- a/test/array_eq_test.cpp
+++ b/test/array_eq_test.cpp
@ -1,11 +1,15 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <cstddef>

+#if defined(_MSC_VER)
+# pragma warning(disable: 4702) // unreachable code
+#endif
+
 template<class T, std::size_t N> void test()
 {
    {
--- a/test/array_eq_test_cx.cpp
+++ b/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
--- a/test/array_fill_test.cpp
+++ b/test/array_fill_test.cpp
@ -1,11 +1,15 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <cstddef>

+#if defined(_MSC_VER)
+# pragma warning(disable: 4702) // unreachable code
+#endif
+
 template<class T, std::size_t N> void test()
 {
    boost::array<T, N> a = {};
--- a/test/array_fill_test_cx.cpp
+++ b/test/array_fill_test_cx.cpp
@ -0,0 +1,51 @@
+// 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> constexpr boost::array<T, N> filled( T const& v )
+{
+    boost::array<T, N> r = {};
+
+    r.fill( v );
+
+    return r;
+}
+
+template<class T> void test1()
+{
+    constexpr boost::array<T, 4> a1 = filled<T, 4>( 7 );
+
+    STATIC_ASSERT( a1[0] == 7 );
+    STATIC_ASSERT( a1[1] == 7 );
+    STATIC_ASSERT( a1[2] == 7 );
+    STATIC_ASSERT( a1[3] == 7 );
+}
+
+template<class T> void test2()
+{
+    constexpr boost::array<T, 0> a1 = filled<T, 0>( 7 );
+
+    (void)a1;
+}
+
+int main()
+{
+    test1<int>();
+    test2<int>();
+}
+
+#endif
--- a/test/array_get_test.cpp
+++ b/test/array_get_test.cpp
@ -1,6 +1,6 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
--- a/test/array_get_test_cx.cpp
+++ b/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
--- a/test/array_init_test.cpp
+++ b/test/array_init_test.cpp
@ -1,6 +1,6 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
@ -8,6 +8,10 @@
 #include <boost/config/workaround.hpp>
 #include <cstddef>

+#if defined(_MSC_VER)
+# pragma warning(disable: 4702) // unreachable code
+#endif
+
 template<class T, std::size_t N> void test1()
 {
    boost::array<T, N> a = {{}};
@ -46,11 +50,11 @@ template<class T> void test4()

 int main()
 {
-    // test1<int, 0>();
+    test1<int, 0>();
    test1<int, 1>();
    test1<int, 7>();

-    // test1<int const, 0>();
+    test1<int const, 0>();
    test1<int const, 1>();
    test1<int const, 7>();

@ -58,7 +62,7 @@ int main()
    test2<int, 1>();
    test2<int, 7>();

-    // test2<int const, 0>();
+    test2<int const, 0>();

 #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) || BOOST_WORKAROUND(BOOST_GCC, < 50000)

--- a/test/array_init_test_cx.cpp
+++ b/test/array_init_test_cx.cpp
@ -0,0 +1,79 @@
+// 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 = {{}};
+    (void)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
--- a/test/array_iterator_test.cpp
+++ b/test/array_iterator_test.cpp
@ -1,6 +1,6 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
@ -94,11 +94,11 @@ template<class T> void test2()

 int main()
 {
-    // test<int, 0>();
+    test<int, 0>();
    test<int, 1>();
    test<int, 7>();

-    // test<int const, 0>();
+    test<int const, 0>();
    test<int const, 1>();
    test<int const, 7>();

--- a/test/array_iterator_test_cx.cpp
+++ b/test/array_iterator_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_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 = {};
+
+    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
--- a/test/array_lt_test.cpp
+++ b/test/array_lt_test.cpp
@ -1,11 +1,15 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <cstddef>

+#if defined(_MSC_VER)
+# pragma warning(disable: 4702) // unreachable code
+#endif
+
 template<class T, std::size_t N> void test()
 {
    {
--- a/test/array_lt_test_cx.cpp
+++ b/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
--- a/test/array_reverse_test.cpp
+++ b/test/array_reverse_test.cpp
@ -1,6 +1,6 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
@ -76,11 +76,11 @@ template<class T, std::size_t N> void test()

 int main()
 {
-    // test<int, 0>();
+    test<int, 0>();
    test<int, 1>();
    test<int, 7>();

-    // test<int const, 0>();
+    test<int const, 0>();
    test<int const, 1>();
    test<int const, 7>();

--- a/test/array_size_test.cpp
+++ b/test/array_size_test.cpp
@ -1,6 +1,6 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
@ -15,6 +15,8 @@ template<class T, std::size_t N> void test1()
        BOOST_TEST_EQ( a.size(), N );
        BOOST_TEST_EQ( a.empty(), N == 0 );
        BOOST_TEST_EQ( a.max_size(), N );
+
+        (void)a; // msvc-12.0
    }

    {
@ -23,6 +25,8 @@ template<class T, std::size_t N> void test1()
        BOOST_TEST_EQ( a.size(), N );
        BOOST_TEST_EQ( a.empty(), N == 0 );
        BOOST_TEST_EQ( a.max_size(), N );
+
+        (void)a; // msvc-12.0
    }
 }

@ -49,11 +53,11 @@ template<class T, std::size_t N> void test3()

 int main()
 {
-    // test1<int, 0>();
+    test1<int, 0>();
    test1<int, 1>();
    test1<int, 7>();

-    // test1<int const, 0>();
+    test1<int const, 0>();
    test1<int const, 1>();
    test1<int const, 7>();

--- a/test/array_size_test_cx.cpp
+++ b/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
--- a/test/array_swap_test.cpp
+++ b/test/array_swap_test.cpp
@ -1,11 +1,15 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <cstddef>

+#if defined(_MSC_VER)
+# pragma warning(disable: 4702) // unreachable code
+#endif
+
 template<class T, std::size_t N> void test()
 {
    boost::array<T, N> a1 = {};
--- a/test/array_swap_test2.cpp
+++ b/test/array_swap_test2.cpp
@ -1,11 +1,15 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <cstddef>

+#if defined(_MSC_VER)
+# pragma warning(disable: 4702) // unreachable code
+#endif
+
 template<class T, std::size_t N> void test()
 {
    boost::array<T, N> a1 = {};
--- a/test/array_thw_test.cpp
+++ b/test/array_thw_test.cpp
@ -0,0 +1,102 @@
+// 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/pragma_message.hpp>
+#include <cstddef>
+
+#if defined(__has_include)
+# if __has_include(<compare>)
+#  define HAS_COMPARE
+# endif
+#endif
+
+#if !defined(__cpp_impl_three_way_comparison)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because __cpp_impl_three_way_comparison is not defined" )
+int main() {}
+
+#elif !( __cpp_impl_three_way_comparison >= 201907L )
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because __cpp_impl_three_way_comparison is defined to " BOOST_STRINGIZE(__cpp_impl_three_way_comparison) )
+int main() {}
+
+#elif !defined(HAS_COMPARE)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because <compare> is not available" )
+int main() {}
+
+#else
+
+template<class T, std::size_t N> void test()
+{
+    constexpr auto eq = 0 <=> 0;
+    constexpr auto lt = 0 <=> 1;
+    constexpr auto gt = 1 <=> 0;
+
+    {
+        boost::array<T, N> const a1 = {};
+        boost::array<T, N> const a2 = {};
+
+        BOOST_TEST( ( a1 <=> a2 ) == eq );
+    }
+
+    {
+        boost::array<T, N> a1;
+        boost::array<T, N> a2;
+
+        a1.fill( 1 );
+        a2.fill( 1 );
+
+        BOOST_TEST( ( a1 <=> a2 ) == eq );
+    }
+
+    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 ) == lt );
+
+        {
+            boost::array<T, N> const a3 = a1;
+            boost::array<T, N> const a4 = a2;
+
+            BOOST_TEST( ( a3 <=> a4 ) == lt );
+        }
+
+        a1[ i ] = 2;
+
+        BOOST_TEST( ( a1 <=> a2 ) == gt );
+
+        {
+            boost::array<T, N> const a3 = a1;
+            boost::array<T, N> const a4 = a2;
+
+            BOOST_TEST( ( a3 <=> a4 ) == gt );
+        }
+    }
+}
+
+int main()
+{
+    test<int, 0>();
+    test<int, 1>();
+    test<int, 7>();
+
+    test<float, 0>();
+    test<float, 1>();
+    test<float, 7>();
+
+    return boost::report_errors();
+}
+
+#endif
--- a/test/array_thw_test_cx.cpp
+++ b/test/array_thw_test_cx.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/config.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <boost/config/workaround.hpp>
+#include <cstddef>
+
+#if defined(__has_include)
+# if __has_include(<compare>)
+#  define HAS_COMPARE
+# endif
+#endif
+
+#if !defined(__cpp_impl_three_way_comparison)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because __cpp_impl_three_way_comparison is not defined" )
+int main() {}
+
+#elif !( __cpp_impl_three_way_comparison >= 201907L )
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because __cpp_impl_three_way_comparison is defined to " BOOST_STRINGIZE(__cpp_impl_three_way_comparison) )
+int main() {}
+
+#elif !defined(HAS_COMPARE)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because <compare> is not available" )
+int main() {}
+
+#else
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+template<class T, std::size_t N> void test1()
+{
+    constexpr auto eq = 0 <=> 0;
+
+    constexpr boost::array<T, N> a1 = {};
+    constexpr boost::array<T, N> a2 = {};
+
+    STATIC_ASSERT( ( a1 <=> a2 ) == eq );
+}
+
+template<class T> void test2()
+{
+    constexpr auto eq = 0 <=> 0;
+    constexpr auto lt = 0 <=> 1;
+    constexpr auto gt = 1 <=> 0;
+
+    {
+        constexpr boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
+        constexpr boost::array<T, 4> a2 = {{ 1, 2, 3, 4 }};
+
+        STATIC_ASSERT( ( a1 <=> a2 ) == eq );
+    }
+    {
+        constexpr boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
+        constexpr boost::array<T, 4> a2 = {{ 1, 2, 3, 5 }};
+
+        STATIC_ASSERT( ( a1 <=> a2 ) == lt );
+    }
+    {
+        constexpr boost::array<T, 4> a1 = {{ 1, 2, 3, 4 }};
+        constexpr boost::array<T, 4> a2 = {{ 1, 2, 3, 2 }};
+
+        STATIC_ASSERT( ( a1 <=> a2 ) == gt );
+    }
+}
+
+int main()
+{
+    test1<int, 0>();
+    test1<int, 1>();
+    test1<int, 7>();
+
+    test2<int>();
+}
+
+#endif
--- a/test/array_typedef_test.cpp
+++ b/test/array_typedef_test.cpp
@ -1,6 +1,6 @@
 // Copyright 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
--- a/test/quick.cpp
+++ b/test/quick.cpp
@ -1,6 +1,6 @@
 // Copyright 2023 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
+// https://www.boost.org/LICENSE_1_0.txt

 #include <boost/array.hpp>

--- a/test/to_array_test.cpp
+++ b/test/to_array_test.cpp
@ -0,0 +1,109 @@
+// 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 <memory>
+#include <utility>
+
+boost::array<int, 3> f1()
+{
+    boost::array<int, 3> r = {{ 1, 2, 3 }};
+    return r;
+}
+
+boost::array<int, 3> const f2()
+{
+    boost::array<int, 3> r = {{ 1, 2, 3 }};
+    return r;
+}
+
+int main()
+{
+    {
+        int a[] = { 1, 2, 3 };
+
+        boost::array<int, 3> b = boost::to_array( a );
+
+        BOOST_TEST_EQ( b[0], 1 );
+        BOOST_TEST_EQ( b[1], 2 );
+        BOOST_TEST_EQ( b[2], 3 );
+    }
+
+    {
+        int const a[] = { 1, 2, 3 };
+
+        boost::array<int, 3> b = boost::to_array( a );
+
+        BOOST_TEST_EQ( b[0], 1 );
+        BOOST_TEST_EQ( b[1], 2 );
+        BOOST_TEST_EQ( b[2], 3 );
+    }
+
+    {
+        boost::array<int, 3> b = boost::to_array( f1().elems );
+
+        BOOST_TEST_EQ( b[0], 1 );
+        BOOST_TEST_EQ( b[1], 2 );
+        BOOST_TEST_EQ( b[2], 3 );
+    }
+
+    {
+        boost::array<int, 3> b = boost::to_array( f2().elems );
+
+        BOOST_TEST_EQ( b[0], 1 );
+        BOOST_TEST_EQ( b[1], 2 );
+        BOOST_TEST_EQ( b[2], 3 );
+    }
+
+#if BOOST_CXX_VERSION >= 201103L
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
+    {
+        int a[] = { 1, 2, 3 };
+
+        boost::array<int, 3> b = boost::to_array( std::move( a ) );
+
+        BOOST_TEST_EQ( b[0], 1 );
+        BOOST_TEST_EQ( b[1], 2 );
+        BOOST_TEST_EQ( b[2], 3 );
+    }
+
+    {
+        int const a[] = { 1, 2, 3 };
+
+        boost::array<int, 3> b = boost::to_array( std::move( a ) );
+
+        BOOST_TEST_EQ( b[0], 1 );
+        BOOST_TEST_EQ( b[1], 2 );
+        BOOST_TEST_EQ( b[2], 3 );
+    }
+#endif
+
+#if !BOOST_WORKAROUND(BOOST_GCC, < 40900) && !BOOST_WORKAROUND(BOOST_CLANG_VERSION, < 30800)
+    {
+        boost::array<int, 3> b = boost::to_array({ 1, 2, 3 });
+
+        BOOST_TEST_EQ( b[0], 1 );
+        BOOST_TEST_EQ( b[1], 2 );
+        BOOST_TEST_EQ( b[2], 3 );
+    }
+#endif
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1920)
+    {
+        std::unique_ptr<int> a[] = { {}, {}, {} };
+
+        boost::array<std::unique_ptr<int>, 3> b = boost::to_array( std::move( a ) );
+
+        (void)b;
+    }
+#endif
+
+#endif
+
+    return boost::report_errors();
+}
--- a/test/to_array_test_cx.cpp
+++ b/test/to_array_test_cx.cpp
@ -0,0 +1,32 @@
+// 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__)
+
+int main()
+{
+    {
+        constexpr int a[] = { 1, 2, 3, 4 };
+        constexpr boost::array<int, 4> b = boost::to_array( a );
+
+        STATIC_ASSERT( b[0] == 1 );
+        STATIC_ASSERT( b[1] == 2 );
+        STATIC_ASSERT( b[2] == 3 );
+        STATIC_ASSERT( b[3] == 4 );
+    }
+}
+
+#endif
Author	SHA1	Message	Date
Peter Dimov	e988ef9c4a	Merge pull request #28 from ashtum/patch-1 Update index.html	2025-04-03 14:10:17 +03:00
Mohammad Nejati	a0be8d9537	Update index.html	2025-04-03 14:25:37 +03:30
Peter Dimov	eee0d5bbc5	Update documentation	2025-02-23 22:02:50 +02:00
Peter Dimov	ec61272c1f	Remove stray parentheses	2025-02-23 21:04:28 +02:00
Peter Dimov	e97dc53868	Add to_array_test_cx.cpp	2025-02-23 20:59:49 +02:00
Peter Dimov	ffbced7a17	Disable initializer list test for GCC < 4.9 and Clang < 3.8	2025-02-23 20:54:43 +02:00
Peter Dimov	37289c5d92	Add to_array	2025-02-23 20:45:50 +02:00
Peter Dimov	9b508e3ad2	Disable <=> tests when <compare> isn't available	2025-01-29 04:26:00 +02:00
Peter Dimov	84d0f84c9b	Check for the existence of <compare>, include it, use it; 0 <=> 0 doesn't work without it anyway.	2025-01-29 04:03:41 +02:00
Peter Dimov	37a4833e26	Add the rest of the Clangs to Drone	2025-01-29 03:14:12 +02:00
Peter Dimov	8991751e3b	Regenerate CMakeLists.txt	2025-01-27 21:22:01 +02:00
Peter Dimov	b2f6f0ca65	Update build.jam	2025-01-27 21:21:34 +02:00
Peter Dimov	703ad46b81	Fix test/Jamfile project requirements	2025-01-27 21:18:15 +02:00
Peter Dimov	7482efd0a1	Merge branch 'modular' of https://github.com/grafikrobot/boostorg.array into feature/pr-24	2025-01-27 21:16:20 +02:00
Peter Dimov	61bbcbf341	Disable warnings for compile-fail tests	2025-01-27 19:53:31 +02:00
Peter Dimov	59e9940d5b	Suppress false -Warray-bounds positive with -fsanitize=undefined	2025-01-27 19:53:16 +02:00
Peter Dimov	771750f7e1	Supress GCC and Clang warnings	2025-01-27 19:00:30 +02:00
Peter Dimov	75db85d1e9	Suppress MSVC unreachable code warnings	2025-01-27 18:23:43 +02:00
Peter Dimov	49e2a46c3a	Enable warnings=extra, warnings-as-errors=on in test suite	2025-01-27 17:41:50 +02:00
Peter Dimov	07a14f33ef	Update revision history	2025-01-27 17:19:06 +02:00
Peter Dimov	047ba01807	Update documentation	2025-01-27 17:16:50 +02:00
Peter Dimov	45de3be80c	Add array_thw_test_cx.cpp	2025-01-27 04:03:06 +02:00
Peter Dimov	68db6ebd2d	Add operator<=> overload for zero-sized arrays	2025-01-27 03:59:32 +02:00
Peter Dimov	329e59454f	Add float tests to array_thw_test, as floats use std::partial_ordering	2025-01-27 03:55:13 +02:00
Peter Dimov	9a4010b88b	Add operator<=>, array_thw_test.cpp	2025-01-27 03:40:19 +02:00
Peter Dimov	527ff0a80d	Update revision history	2025-01-26 22:07:42 +02:00
Peter Dimov	f017dac435	Enable failing tests	2025-01-26 21:26:46 +02:00
Peter Dimov	567ba40840	Add a dummy element to array<T, 0> to enable initialization with = {{}}	2025-01-26 21:15:39 +02:00
Peter Dimov	29700ff270	Update revision history	2025-01-26 21:02:26 +02:00
Peter Dimov	b147799665	Remove local hash_value overload; boost::hash supports array-like types natively.	2025-01-26 20:35:19 +02:00
Peter Dimov	acef60446a	Update revision history	2025-01-26 20:31:53 +02:00
Peter Dimov	3d9f39814c	Re-enable failing tests	2025-01-26 19:23:41 +02:00
Peter Dimov	89f09e33f1	Change array<T, 0>::begin() to return nullptr and make it constexpr.	2025-01-26 19:21:39 +02:00
Peter Dimov	43326390d9	Reenable failing test	2025-01-26 08:19:00 +02:00
Peter Dimov	c95d855018	Remove obsolete workaround from `failed_rangecheck`	2025-01-26 08:09:41 +02:00
Peter Dimov	0a72026887	Update revision history	2025-01-26 06:09:05 +02:00
Peter Dimov	d2c295b85f	Add array_access_test_cx2.cpp	2025-01-26 05:53:09 +02:00
Peter Dimov	324827cfc0	Add array_assign_test_cx.cpp	2025-01-26 05:45:36 +02:00
Peter Dimov	9253e8f1af	Add array_fill_test_cx.cpp	2025-01-26 05:41:56 +02:00
Peter Dimov	cd0532b8fa	Remove inclusion of <algorithm>	2025-01-26 05:08:42 +02:00
Peter Dimov	6a9e8c78da	Update documentation of `swap`.	2025-01-26 04:11:14 +02:00
Peter Dimov	55bc631d40	Remove use of core/invoke_swap	2025-01-26 04:08:06 +02:00
Peter Dimov	435b293467	Mark `std::get` illegal overloads as deprecated	2025-01-26 03:16:23 +02:00
Peter Dimov	6447b408b2	Remove idef-ed out overload of get_c_array	2025-01-26 03:10:59 +02:00
Peter Dimov	17b49d86ad	Mark `get_c_array` as deprecated	2025-01-26 03:10:23 +02:00
Peter Dimov	fe60e163c7	Remove obsolete Sun workaround	2025-01-26 03:07:53 +02:00
Peter Dimov	16280f660b	Mark `assign` as deprecated	2025-01-26 03:06:28 +02:00
Peter Dimov	16b6ba8d84	Mark c_array as deprecated	2025-01-25 23:20:31 +02:00
Peter Dimov	f5a3f1b34a	Remove obsolete reverse_iterator workarounds	2025-01-25 23:12:34 +02:00
Peter Dimov	9e2868f8e2	Reorder includes	2025-01-25 23:10:41 +02:00
Peter Dimov	4f2ed73766	Add array_get_test_cx.cpp	2025-01-25 21:20:12 +02:00
Peter Dimov	b32a6cfcfd	Work around GCC 5..8 constexpr comparison failures	2025-01-25 20:59:46 +02:00
Peter Dimov	50cf6ebba7	Disable array_access_test_cx for GCC 4.x	2025-01-25 20:51:36 +02:00
Peter Dimov	ec05d6ca34	Disable array_iterator_test_cx for GCC 4.x	2025-01-25 20:50:45 +02:00
Peter Dimov	18ec6239b2	Disable array_data_test_cx for GCC 4.x	2025-01-25 20:49:14 +02:00
Peter Dimov	b44be8da89	Disable array_copy_test_cx for GCC 4.x	2025-01-25 20:47:36 +02:00
Peter Dimov	ea9dbd5674	Disable array_init_test_cx for GCC 4.x	2025-01-25 20:46:20 +02:00
Peter Dimov	5c05254afb	Add array_lt_test_cx.cpp	2025-01-25 20:32:38 +02:00
Peter Dimov	a211468866	Add array_eq_test_cx.cpp	2025-01-25 20:24:15 +02:00
Peter Dimov	c06cadc04f	Add array_access_test_cx.cpp	2025-01-25 20:09:17 +02:00
Peter Dimov	f155831795	Add array_iterator_test_cx.cpp	2025-01-25 20:02:57 +02:00
Peter Dimov	7ca2f112a2	Disable constexpr data() test for msvc-14.0	2025-01-25 19:42:21 +02:00
Peter Dimov	19f02c7615	Add array_data_test_cx.cpp	2025-01-25 19:38:01 +02:00
Peter Dimov	66386e8eda	Add array_copy_test_cx.cpp	2025-01-25 19:29:47 +02:00
Peter Dimov	54d839c8bc	Add array_size_test_cx.cpp	2025-01-25 19:23:50 +02:00
Peter Dimov	e7663434ee	Add array_init_test_cx.cpp	2025-01-25 19:18:22 +02:00
Peter Dimov	52406dfcc0	Add revision history	2025-01-25 18:06:00 +02:00
Peter Dimov	9b8a342f44	Update documentation	2025-01-25 18:00:27 +02:00
Peter Dimov	01983ff604	Remove GCC 4.4 from Drone	2025-01-15 21:12:57 +02:00
Peter Dimov	536412674f	Add Drone support	2025-01-15 20:52:27 +02:00
Peter Dimov	8c5f36ae52	array<T, 0> access operations are never constexpr	2025-01-15 20:18:14 +02:00
Peter Dimov	9d6b871972	Work around GCC 4.x constexpr failure in operator[]	2025-01-15 19:57:39 +02:00
Peter Dimov	79ca787bfe	Add more constexpr to match std::array	2025-01-12 03:31:49 +02:00
Peter Dimov	0da094a21d	Add BOOST_NOEXCEPT as needed to match std::array	2025-01-12 03:31:49 +02:00
Peter Dimov	2099995189	Uncomment BOOST_CONSTEXPR; update and enable test/array_constexpr.cpp	2025-01-12 03:31:49 +02:00
Rene Rivera	78fb6a71dd	Adjust self dependencies as inter-lib deps no longer apply globally.	2024-07-27 11:03:42 -05:00
Rene Rivera	40e2a2d4d8	Move inter-lib dependencies to a project variable and into the build targets.	2024-07-23 22:34:23 -05:00
Rene Rivera	fc10453994	Update copyright dates.	2024-07-20 22:52:04 -05:00
Rene Rivera	28d8d30b57	Bump B2 require to 5.2	2024-06-14 11:33:55 -05:00
Rene Rivera	fe1e99eb31	Add requires-b2 check to top-level build file.	2024-05-05 09:00:00 -05:00
Rene Rivera	1469f4b28e	Sync from upstream.	2024-04-12 22:21:21 -05:00
Rene Rivera	d535c37a57	Switch to library requirements instead of source. As source puts extra source in install targets.	2024-03-29 21:12:36 -05:00
Rene Rivera	36bba5af2d	Make the library modular usable.	2024-03-11 08:27:02 -05:00