Added new gcc and clang jobs to GitHub Actions.

Use Azure mirrors of Ubuntu .deb repositories in containers.
This reduces the likelihood of spurious CI failures caused by DDoS filters being triggered by massive numbers of concurrent CI jobs.
2025-06-25 12:01:38 +02:00 · 2025-06-13 02:53:36 +03:00 · 2025-06-13 02:48:20 +03:00 · 2025-06-13 02:47:06 +03:00 · 2025-05-03 05:29:05 +03:00 · 2025-05-03 05:17:00 +03:00
18 changed files with 702 additions and 675 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -1,4 +1,4 @@
-# Copyright 2021-2024 Andrey Semashev
+# Copyright 2021-2025 Andrey Semashev
 #
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
@ -77,12 +77,14 @@ jobs:
              - g++-8
          - toolset: gcc-9
            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            os: ubuntu-latest
+            container: ubuntu:20.04
            install:
              - g++-9
          - toolset: gcc-10
            cxxstd: "11,14,17,20"
-            os: ubuntu-20.04
+            os: ubuntu-latest
+            container: ubuntu:20.04
            install:
              - g++-10
          - toolset: gcc-11
@ -97,18 +99,28 @@ jobs:
              - g++-12
          - toolset: gcc-13
            cxxstd: "11,14,17,20,23"
-            os: ubuntu-latest
-            container: ubuntu:23.04
+            os: ubuntu-24.04
            install:
              - g++-13
+          - toolset: gcc-14
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-24.04
+            install:
+              - g++-14
+          - toolset: gcc-15
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-latest
+            container: ubuntu:25.04
+            install:
+              - g++-15
          - name: UBSAN
-            toolset: gcc-11
+            toolset: gcc-13
            cxxstd: "11,14,17,20,23"
            ubsan: 1
            build_variant: debug
-            os: ubuntu-22.04
+            os: ubuntu-24.04
            install:
-              - g++-11
+              - g++-13

          # Linux, clang
          - toolset: clang
@ -187,13 +199,15 @@ jobs:
          - toolset: clang
            compiler: clang++-9
            cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
+            os: ubuntu-latest
+            container: ubuntu:20.04
            install:
              - clang-9
          - toolset: clang
            compiler: clang++-10
            cxxstd: "11,14,17,20"
-            os: ubuntu-20.04
+            os: ubuntu-latest
+            container: ubuntu:20.04
            install:
              - clang-10
          - toolset: clang
@ -237,54 +251,64 @@ jobs:
          - toolset: clang
            compiler: clang++-16
            cxxstd: "11,14,17,20,2b"
-            os: ubuntu-22.04
+            os: ubuntu-24.04
            install:
              - clang-16
-            sources:
-              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-16 main"
-            source_keys:
-              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
+              - g++-11
+            gcc_toolchain: 11
          - toolset: clang
            compiler: clang++-17
            cxxstd: "11,14,17,20,23"
-            os: ubuntu-22.04
+            os: ubuntu-24.04
            install:
              - clang-17
-            sources:
-              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-17 main"
-            source_keys:
-              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
+              - g++-11
+            gcc_toolchain: 11
          - toolset: clang
-            compiler: clang++-17
-            cxxstd: "11,14,17,20,23"
-            os: ubuntu-22.04
+            compiler: clang++-18
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-24.04
            install:
-              - clang-17
-              - libc++-17-dev
-              - libc++abi-17-dev
-            sources:
-              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-17 main"
-            source_keys:
-              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
+              - clang-18
+              - g++-13
+          - toolset: clang
+            compiler: clang++-19
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-24.04
+            install:
+              - clang-19
+          - toolset: clang
+            compiler: clang++-20
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-latest
+            container: ubuntu:25.04
+            install:
+              - clang-20
+          - toolset: clang
+            compiler: clang++-20
+            cxxstd: "11,14,17,20,23,26"
+            os: ubuntu-latest
+            container: ubuntu:25.04
+            install:
+              - clang-20
+              - libc++-20-dev
+              - libc++abi-20-dev
            cxxflags: -stdlib=libc++
            linkflags: -stdlib=libc++
          - name: UBSAN
            toolset: clang
-            compiler: clang++-15
-            cxxstd: "11,14,17,20,2b"
+            compiler: clang++-18
+            cxxstd: "11,14,17,20,23"
            cxxflags: -stdlib=libc++
-            linkflags: -stdlib=libc++
+            linkflags: "-stdlib=libc++ -lubsan"
            ubsan: 1
            build_variant: debug
-            os: ubuntu-22.04
+            os: ubuntu-24.04
            install:
-              - clang-15
-              - libc++-15-dev
-              - libc++abi-15-dev
+              - clang-18
+              - libc++-18-dev
+              - libc++abi-18-dev

-          - toolset: clang
-            cxxstd: "11,14,17,20,2b"
-            os: macos-12
          - toolset: clang
            cxxstd: "11,14,17,20,2b"
            os: macos-13
@ -309,6 +333,22 @@ jobs:
                echo "GHA_CONTAINER=${{matrix.container}}" >> $GITHUB_ENV
                if [ -f "/etc/debian_version" ]
                then
+                    # Use Azure APT mirrors in containers to avoid HTTP errors due to DDoS filters triggered by lots of CI jobs launching concurrently.
+                    # Note that not all Ubuntu versions support "mirror+file:..." URIs in APT sources, so just use Azure mirrors exclusively.
+                    # Note also that on recent Ubuntu versions DEB822 format is used for source files.
+                    APT_SOURCES=()
+                    if [ -d "/etc/apt/sources.list.d" ]
+                    then
+                        readarray -t APT_SOURCES < <(find "/etc/apt/sources.list.d" -type f -name '*.sources' -print)
+                    fi
+                    if [ -f "/etc/apt/sources.list" ]
+                    then
+                        APT_SOURCES+=("/etc/apt/sources.list")
+                    fi
+                    if [ "${#APT_SOURCES[@]}" -gt 0 ]
+                    then
+                        sed -i -E -e 's!([^ ]+) (http|https)://(archive|security)\.ubuntu\.com/ubuntu[^ ]*(.*)!\1 http://azure.archive.ubuntu.com/ubuntu/\4!' "${APT_SOURCES[@]}"
+                    fi
                    apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
                    if [ "$(apt-cache search "^python-is-python3$" | wc -l)" -ne 0 ]
                    then
@ -508,14 +548,6 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - toolset: msvc-14.0
-            cxxstd: "14"
-            addrmd: 32,64
-            os: windows-2019
-          - toolset: msvc-14.2
-            cxxstd: "14,17,20,latest"
-            addrmd: 32,64
-            os: windows-2019
          - toolset: msvc-14.3
            cxxstd: "14,17,20,latest"
            addrmd: 32,64
@ -525,9 +557,9 @@ jobs:
            addrmd: 32,64
            os: windows-2022
          - toolset: gcc
-            cxxstd: "11,14,17,2a"
+            cxxstd: "11,14,17,20,23"
            addrmd: 64
-            os: windows-2019
+            os: windows-2022

    timeout-minutes: 15
    runs-on: ${{matrix.os}}
--- a/build.jam
+++ b/build.jam
@ -0,0 +1,29 @@
+# Copyright René Ferdinand Rivera Morell 2023-2024
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/assert//boost_assert
+    /boost/config//boost_config
+    /boost/core//boost_core
+    /boost/io//boost_io
+    /boost/preprocessor//boost_preprocessor
+    /boost/throw_exception//boost_throw_exception
+    /boost/type_traits//boost_type_traits ;
+
+project /boost/utility
+    : common-requirements
+        <include>include
+    ;
+
+explicit
+    [ alias boost_utility : : : : <library>$(boost_dependencies) ]
+    [ alias all : boost_utility test ]
+    ;
+
+call-if : boost-library utility
+    ;
+
--- a/doc/BOOST_BINARY.qbk
+++ b/doc/BOOST_BINARY.qbk
@ -6,8 +6,7 @@
 /]

 [/===============]
-[#sec:BOOST_BINARY]
-[section Binary Integer Literals]
+[section:BOOST_BINARY Binary Integer Literals]
 [/===============]

 [section Introduction]
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -8,7 +8,7 @@ import quickbook ;

 project boost/libs/utility/doc ;

-path-constant INCLUDES : ../../.. ;
+path-constant INCLUDES : ../include ;
 path-constant boost-images : ../../../doc/src/images ;

 # Generate XML doxygen reference for base_from_member component in base_from_member_reference.xml
@ -39,6 +39,7 @@ doxygen base_from_member_reference
                    BOOST_CONSTEXPR_OR_CONST=constexpr \\
                    BOOST_NOEXCEPT=noexcept \\
                    BOOST_NOEXCEPT_IF(x)=noexcept(x) \\
+                    BOOST_NOEXCEPT_EXPR(x)=noexcept(x) \\
                    BOOST_NOEXCEPT_OR_NOTHROW=noexcept \\
                    BOOST_COPY_ASSIGN_REF(x)=\"x const&\" \\
                    BOOST_DEFAULTED_FUNCTION(x,y)=\"x = default;\" \\
@ -83,6 +84,7 @@ doxygen boost_binary_reference
                    BOOST_CONSTEXPR_OR_CONST=constexpr \\
                    BOOST_NOEXCEPT=noexcept \\
                    BOOST_NOEXCEPT_IF(x)=noexcept(x) \\
+                    BOOST_NOEXCEPT_EXPR(x)=noexcept(x) \\
                    BOOST_NOEXCEPT_OR_NOTHROW=noexcept \\
                    BOOST_COPY_ASSIGN_REF(x)=\"x const&\" \\
                    BOOST_DEFAULTED_FUNCTION(x,y)=\"x = default;\" \\
@ -128,6 +130,7 @@ doxygen call_traits_reference
                    BOOST_CONSTEXPR_OR_CONST=constexpr \\
                    BOOST_NOEXCEPT=noexcept \\
                    BOOST_NOEXCEPT_IF(x)=noexcept(x) \\
+                    BOOST_NOEXCEPT_EXPR(x)=noexcept(x) \\
                    BOOST_NOEXCEPT_OR_NOTHROW=noexcept \\
                    BOOST_COPY_ASSIGN_REF(x)=\"x const&\" \\
                    BOOST_DEFAULTED_FUNCTION(x,y)=\"x = default;\" \\
@ -173,6 +176,7 @@ doxygen compressed_pair_reference
                    BOOST_CONSTEXPR_OR_CONST=constexpr \\
                    BOOST_NOEXCEPT=noexcept \\
                    BOOST_NOEXCEPT_IF(x)=noexcept(x) \\
+                    BOOST_NOEXCEPT_EXPR(x)=noexcept(x) \\
                    BOOST_NOEXCEPT_OR_NOTHROW=noexcept \\
                    BOOST_COPY_ASSIGN_REF(x)=\"x const&\" \\
                    BOOST_DEFAULTED_FUNCTION(x,y)=\"x = default;\" \\
@ -218,6 +222,7 @@ doxygen in_place_factory_reference
                    BOOST_CONSTEXPR_OR_CONST=constexpr \\
                    BOOST_NOEXCEPT=noexcept \\
                    BOOST_NOEXCEPT_IF(x)=noexcept(x) \\
+                    BOOST_NOEXCEPT_EXPR(x)=noexcept(x) \\
                    BOOST_NOEXCEPT_OR_NOTHROW=noexcept \\
                    BOOST_COPY_ASSIGN_REF(x)=\"x const&\" \\
                    BOOST_DEFAULTED_FUNCTION(x,y)=\"x = default;\" \\
@ -265,6 +270,7 @@ doxygen result_of_reference
                    BOOST_CONSTEXPR_OR_CONST=constexpr \\
                    BOOST_NOEXCEPT=noexcept \\
                    BOOST_NOEXCEPT_IF(x)=noexcept(x) \\
+                    BOOST_NOEXCEPT_EXPR(x)=noexcept(x) \\
                    BOOST_NOEXCEPT_OR_NOTHROW=noexcept \\
                    BOOST_COPY_ASSIGN_REF(x)=\"x const&\" \\
                    BOOST_DEFAULTED_FUNCTION(x,y)=\"x = default;\" \\
@ -285,6 +291,7 @@ doxygen result_of_reference
 doxygen string_view_reference
  :
    $(INCLUDES)/boost/utility/string_view.hpp
+    $(INCLUDES)/boost/utility/string_ref.hpp
  :
    <location>tmp
    <doxygen:param>ENABLE_PREPROCESSING=YES
@ -309,6 +316,7 @@ doxygen string_view_reference
                    BOOST_CONSTEXPR_OR_CONST=constexpr \\
                    BOOST_NOEXCEPT=noexcept \\
                    BOOST_NOEXCEPT_IF(x)=noexcept(x) \\
+                    BOOST_NOEXCEPT_EXPR(x)=noexcept(x) \\
                    BOOST_NOEXCEPT_OR_NOTHROW=noexcept \\
                    BOOST_COPY_ASSIGN_REF(x)=\"x const&\" \\
                    BOOST_DEFAULTED_FUNCTION(x,y)=\"x = default;\" \\
@ -353,6 +361,7 @@ doxygen value_init_reference
                    BOOST_CONSTEXPR_OR_CONST=constexpr \\
                    BOOST_NOEXCEPT=noexcept \\
                    BOOST_NOEXCEPT_IF(x)=noexcept(x) \\
+                    BOOST_NOEXCEPT_EXPR(x)=noexcept(x) \\
                    BOOST_NOEXCEPT_OR_NOTHROW=noexcept \\
                    BOOST_COPY_ASSIGN_REF(x)=\"x const&\" \\
                    BOOST_DEFAULTED_FUNCTION(x,y)=\"x = default;\" \\
--- a/doc/call_traits.qbk
+++ b/doc/call_traits.qbk
@ -7,7 +7,7 @@
 /]

 [/===============]
-[section Call Traits]
+[section:call_traits Call Traits]
 [/===============]

 [section Introduction]
@ -19,9 +19,9 @@ The template class __call_traits_T__ encapsulates the
 "best" method to pass a parameter of some type `T` to or
 from a function, and consists of a collection of `typedef`s defined
 as in the table below. The purpose of __call_traits__ is to ensure
-that problems like [link sec:refs "references to references"]
+that problems like [link utility.utilities.call_traits.examples.refs "references to references"]
 never occur, and that parameters are passed in the most efficient
-manner possible, as in the [link sec:examples examples]. In each
+manner possible, as in the [link utility.utilities.call_traits.examples examples]. In each
 case, if your existing practice is to use the type defined on the
 left, then replace it with the __call_traits__ defined type on the
 right.
@ -100,7 +100,7 @@ used to solve the reference to reference problem.
 Notes:

 # If `T` is already reference type, then __call_traits__ is
-        defined such that [link sec:refs "references to references"]
+        defined such that [link utility.utilities.call_traits.examples.refs "references to references"]
        do not occur (requires partial specialization).
 # If `T` is an array type, then __call_traits__ defines `value_type`
        as a "constant pointer to type" rather than an
@ -145,8 +145,7 @@ If `T` is an assignable type the following assignments are possible:
 ]
 [endsect]

-[#sec:examples]
-[section Examples]
+[section:examples Examples]

 The following table shows the effect that __call_traits__ has on
 various types.
@ -204,8 +203,7 @@ struct contained
 ```
 [endsect]

-[#sec:refs]
-[section Example 2 (the reference to reference problem):]
+[section:refs Example 2 (the reference to reference problem):]

 Consider the definition of __std_binder1st__:

@ -241,8 +239,7 @@ the no "reference to reference" occurs.

 [endsect]

-[#sec:example3]
-[section Example 3 (the `make_pair` problem):]
+[section:example3 Example 3 (the `make_pair` problem):]

 If we pass the name of an array as one (or both) arguments to `__std_make_pair__`,
 then template argument deduction deduces the passed parameter as
@ -277,8 +274,7 @@ __std_make_pair__ are not expressed in terms of __call_traits__: doing so
 would prevent template argument deduction from functioning.
 [endsect]

-[#sec:example4]
-[section Example 4 (optimising fill):]
+[section:example4 Example 4 (optimising fill):]

 The __call_traits__ template will "optimize" the passing
 of a small built-in type as a function parameter. This mainly has
@ -359,12 +355,12 @@ Small built-in types, what the standard calls [@https://en.cppreference.com/w/cp
 types], differ from existing practice only in the `param_type`
 `typedef`. In this case passing `T const` is compatible
 with existing practice, but may improve performance in some cases
-(see [link sec:example4 Example 4]). In any case this should never
+(see [link utility.utilities.call_traits.examples.example4 Example 4]). In any case this should never
 be any worse than existing practice.

 Pointers follow the same rationale as small built-in types.

-For reference types the rationale follows [link sec:refs Example 2]
+For reference types the rationale follows [link utility.utilities.call_traits.examples.refs Example 2]
 - references to references are not allowed, so the __call_traits__
 members must be defined such that these problems do
 not occur. There is a proposal to modify the language such that
@ -425,7 +421,7 @@ For `value_type` (return by value), again only a pointer may be
 returned, not a copy of the whole array, and again __call_traits__
 makes the degradation explicit. The `value_type` member is useful
 whenever an array must be explicitly degraded to a pointer -
-[link sec:example3 Example 3] provides the test case.
+[link utility.utilities.call_traits.examples.example3 Example 3] provides the test case.

 Footnote: the array specialisation for __call_traits__ is the least
 well understood of all the __call_traits__ specialisations. If the given
--- a/doc/compressed_pair.qbk
+++ b/doc/compressed_pair.qbk
@ -8,7 +8,7 @@
  or copy at http://boost.org/LICENSE_1_0.txt
 ]

-[section Compressed Pair]
+[section:compressed_pair Compressed Pair]

 [section Introduction]

--- a/doc/in_place_factory.qbk
+++ b/doc/in_place_factory.qbk
@ -7,8 +7,7 @@
 /]

 [/===============]
-[#sec:in_place_factory]
-[section In-place Factory]
+[section:in_place_factory In-place Factory]
 [/===============]

 [section Introduction]
@ -296,7 +295,6 @@ void foo()
 [endsect]

 [/===============]
-[#boost.typed_in_place_factory_base]
 [xinclude tmp/in_place_factory_reference.xml]
 [/===============]

--- a/doc/main.qbk
+++ b/doc/main.qbk
@ -57,113 +57,113 @@
 [/ (Macros are defined here because these macros are often referenced in other components) ]
 [/ (operators macros link to the a table of operators because there's no doxygen reference for the operators) ]

-[def __BOOST_BINARY__ [link sec:BOOST_BINARY `BOOST_BINARY`]]
-[def __in_place_factory__ [link sec:in_place_factory `in_place_factory`]]
+[def __BOOST_BINARY__ [link utility.utilities.BOOST_BINARY `BOOST_BINARY`]]
+[def __in_place_factory__ [link utility.utilities.in_place_factory `in_place_factory`]]

-[def __boost_base_from_member__ [link boost.base_from_member `boost::base_from_member`]]
-[def __boost_call_traits__ [link boost.call_traits `boost::call_traits`]]
-[def __boost_result_of__ [link boost.result_of `boost::result_of`]]
-[def __boost_tr1_result_of__ [link boost.tr1_result_of `boost::tr1_result_of`]]
-[def __boost_string_view__ [link boost.basic_string_view `boost::string_view`]]
-[def __boost_basic_string_view__ [link boost.basic_string_view `boost::basic_string_view`]]
+[def __boost_base_from_member__ [classref boost::base_from_member `boost::base_from_member`]]
+[def __boost_call_traits__ [classref boost::call_traits `boost::call_traits`]]
+[def __boost_result_of__ [classref boost::result_of `boost::result_of`]]
+[def __boost_tr1_result_of__ [classref boost::tr1_result_of `boost::tr1_result_of`]]
+[def __boost_string_view__ [classref boost::basic_string_view `boost::string_view`]]
+[def __boost_basic_string_view__ [classref boost::basic_string_view `boost::basic_string_view`]]

-[def __additive1__ [link sec:arithmetic `additive1`]]
-[def __additive2__ [link sec:arithmetic `additive2`]]
-[def __arithmetic1__ [link sec:arithmetic `arithmetic1`]]
-[def __arithmetic2__ [link sec:arithmetic `arithmetic2`]]
-[def __base_from_member__ [link boost.base_from_member `base_from_member`]]
-[def __basic_string_ref__ [link boost.basic_string_view `basic_string_ref`]]
-[def __basic_string_view__ [link boost.basic_string_view `basic_string_view`]]
-[def __bidirectional_iteratable__ [link sec:arithmetic `bidirectional_iteratable`]]
-[def __bidirectional_iterator_helper__ [link sec:arithmetic `bidirectional_iterator_helper`]]
-[def __bitwise1__ [link sec:arithmetic `bitwise1`]]
-[def __bitwise2__ [link sec:arithmetic `bitwise2`]]
-[def __call_traits__ [link boost.call_traits `call_traits`]]
-[def __call_traits_T__ [link boost.call_traits `call_traits<T>`]]
-[def __call_traits_lt__T___ [link boost.call_traits `call_traits<T&>`]]
-[def __call_traits_lt__T_lb_N_rb__gt___ [link boost.call_traits `call_traits< T[N]>`]]
-[def __call_traits_lt__const_T_lb_N_rb__gt___ [link boost.call_traits `call_traits< const T[N]>`]]
-[def __compressed_pair__ [link boost.compressed_pair `compressed_pair`]]
-[def __decrementable__ [link sec:arithmetic `decrementable`]]
-[def __dereferenceable__ [link sec:arithmetic `dereferenceable`]]
-[def __equal_pointees__ [link sec:arithmetic `equal_pointees`]]
-[def __equal_pointees_t__ [link sec:arithmetic `equal_pointees_t`]]
-[def __equality_comparable1__ [link sec:arithmetic `equality_comparable1`]]
-[def __equality_comparable2__ [link sec:arithmetic `equality_comparable2`]]
-[def __equivalent1__ [link sec:arithmetic `equivalent1`]]
-[def __equivalent2__ [link sec:arithmetic `equivalent2`]]
-[def __euclidean_ring_operators1__ [link sec:arithmetic `euclidean_ring_operators1`]]
-[def __euclidean_ring_operators2__ [link sec:arithmetic `euclidean_ring_operators2`]]
-[def __field_operators1__ [link sec:arithmetic `field_operators1`]]
-[def __field_operators2__ [link sec:arithmetic `field_operators2`]]
-[def __forward_iteratable__ [link sec:arithmetic `forward_iteratable`]]
-[def __forward_iterator_helper__ [link sec:arithmetic `forward_iterator_helper`]]
-[def __get__ [link boost.get `get`]]
-[def __hash_range__ [link boost.hash_range `hash_range`]]
-[def __hash_value__ [link boost.hash_value `hash_value`]]
-[def __in_place_factory_base__ [link boost.in_place_factory_base `in_place_factory_base`]]
-[def __incrementable__ [link sec:arithmetic `incrementable`]]
-[def __indexable__ [link sec:arithmetic `indexable`]]
-[def __initialized__ [link boost.initialized `initialized`]]
-[def __initialized_value__ [link boost.initialized_value `initialized_value`]]
-[def __initialized_value_t__ [link boost.initialized_value_t `initialized_value_t`]]
-[def __input_iteratable__ [link sec:arithmetic `input_iteratable`]]
-[def __input_iterator_helper__ [link sec:arithmetic `input_iterator_helper`]]
-[def __integer_arithmetic1__ [link sec:arithmetic `integer_arithmetic1`]]
-[def __integer_arithmetic2__ [link sec:arithmetic `integer_arithmetic2`]]
-[def __integer_multiplicative1__ [link sec:arithmetic `integer_multiplicative1`]]
-[def __integer_multiplicative2__ [link sec:arithmetic `integer_multiplicative2`]]
-[def __is_chained_base__ [link sec:arithmetic `is_chained_base`]]
-[def __less_pointees__ [link boost.less_pointees `less_pointees`]]
-[def __less_pointees_t__ [link boost.less_pointees_t `less_pointees_t`]]
-[def __less_than_comparable1__ [link sec:arithmetic `less_than_comparable1`]]
-[def __less_than_comparable2__ [link sec:arithmetic `less_than_comparable2`]]
-[def __multiplicative1__ [link sec:arithmetic `multiplicative1`]]
-[def __multiplicative2__ [link sec:arithmetic `multiplicative2`]]
-[def __operator_eq__eq__ [link sec:arithmetic `operator==`]]
-[def __operator_gt__ [link sec:arithmetic `operator_gt_`]]
-[def __operator_gt__eq__ [link sec:arithmetic `operator&gt;`]]
-[def __operator_lt__ [link sec:arithmetic `operator&lt;`]]
-[def __operator_lt__eq__ [link sec:arithmetic `operator&lt;=`]]
-[def __operator_lt__lt__ [link sec:arithmetic `operator&lt;&lt;`]]
-[def __operator_not__eq__ [link sec:arithmetic `operator!=`]]
-[def __operators2__ [link sec:arithmetic `operators2`]]
-[def __operators__ [link sec:arithmetic `operators`]]
-[def __operators_lt_T__ [link sec:arithmetic `operators<T,T>`]]
-[def __ordered_euclidean_ring_operators1__ [link sec:arithmetic `ordered_euclidean_ring_operators1`]]
-[def __ordered_euclidean_ring_operators2__ [link sec:arithmetic `ordered_euclidean_ring_operators2`]]
-[def __ordered_euclidian_ring_operators1__ [link sec:arithmetic `ordered_euclidian_ring_operators1`]]
-[def __ordered_euclidian_ring_operators2__ [link sec:arithmetic `ordered_euclidian_ring_operators2`]]
-[def __ordered_field_operators1__ [link sec:arithmetic `ordered_field_operators1`]]
-[def __ordered_field_operators2__ [link sec:arithmetic `ordered_field_operators2`]]
-[def __ordered_ring_operators1__ [link sec:arithmetic `ordered_ring_operators1`]]
-[def __ordered_ring_operators2__ [link sec:arithmetic `ordered_ring_operators2`]]
-[def __output_iteratable__ [link sec:arithmetic `output_iteratable`]]
-[def __output_iterator_helper__ [link sec:arithmetic `output_iterator_helper`]]
-[def __partially_ordered1__ [link sec:arithmetic `partially_ordered1`]]
-[def __partially_ordered2__ [link sec:arithmetic `partially_ordered2`]]
-[def __random_access_iteratable__ [link sec:arithmetic `random_access_iteratable`]]
-[def __random_access_iterator_helper__ [link sec:arithmetic `random_access_iterator_helper`]]
-[def __result_of__ [link boost.result_of `result_of`]]
-[def __ring_operators1__ [link sec:arithmetic `ring_operators1`]]
-[def __ring_operators2__ [link sec:arithmetic `ring_operators2`]]
-[def __shiftable1__ [link sec:arithmetic `shiftable1`]]
-[def __shiftable2__ [link sec:arithmetic `shiftable2`]]
-[def __string_ref__ [link boost.basic_string_view `string_ref`]]
-[def __string_view__ [link boost.basic_string_view `string_view`]]
-[def __swap__ [link sec:arithmetic `swap`]]
-[def __totally_ordered1__ [link sec:arithmetic `totally_ordered1`]]
-[def __totally_ordered2__ [link sec:arithmetic `totally_ordered2`]]
-[def __tr1_result_of__ [link boost.tr1_result_of `tr1_result_of`]]
-[def __typed_in_place_factory_base__ [link boost.typed_in_place_factory_base `typed_in_place_factory_base`]]
-[def __u16string_ref__ [link boost.basic_string_view `u16string_ref`]]
-[def __u16string_view__ [link boost.basic_string_view `u16string_view`]]
-[def __u32string_ref__ [link boost.basic_string_view `u32string_ref`]]
-[def __u32string_view__ [link boost.basic_string_view `u32string_view`]]
-[def __unit_steppable__ [link sec:arithmetic `unit_steppable`]]
-[def __value_initialized__ [link boost.value_initialized `value_initialized`]]
-[def __wstring_ref__ [link boost.basic_string_view `wstring_ref`]]
-[def __wstring_view__ [link boost.basic_string_view `wstring_view`]]
+[def __additive1__ [link utility.utilities.operators.arithmetic `additive1`]]
+[def __additive2__ [link utility.utilities.operators.arithmetic `additive2`]]
+[def __arithmetic1__ [link utility.utilities.operators.arithmetic `arithmetic1`]]
+[def __arithmetic2__ [link utility.utilities.operators.arithmetic `arithmetic2`]]
+[def __base_from_member__ [classref boost::base_from_member `base_from_member`]]
+[def __basic_string_ref__ [classref boost::basic_string_ref `basic_string_ref`]]
+[def __basic_string_view__ [classref boost::basic_string_view `basic_string_view`]]
+[def __bidirectional_iteratable__ [link utility.utilities.operators.arithmetic `bidirectional_iteratable`]]
+[def __bidirectional_iterator_helper__ [link utility.utilities.operators.arithmetic `bidirectional_iterator_helper`]]
+[def __bitwise1__ [link utility.utilities.operators.arithmetic `bitwise1`]]
+[def __bitwise2__ [link utility.utilities.operators.arithmetic `bitwise2`]]
+[def __call_traits__ [classref boost::call_traits `call_traits`]]
+[def __call_traits_T__ [classref boost::call_traits `call_traits<T>`]]
+[def __call_traits_lt__T___ [classref boost::call_traits `call_traits<T&>`]]
+[def __call_traits_lt__T_lb_N_rb__gt___ [classref boost::call_traits `call_traits< T[N]>`]]
+[def __call_traits_lt__const_T_lb_N_rb__gt___ [classref boost::call_traits `call_traits< const T[N]>`]]
+[def __compressed_pair__ [classref boost::compressed_pair `compressed_pair`]]
+[def __decrementable__ [link utility.utilities.operators.arithmetic `decrementable`]]
+[def __dereferenceable__ [link utility.utilities.operators.arithmetic `dereferenceable`]]
+[def __equal_pointees__ [link utility.utilities.operators.arithmetic `equal_pointees`]]
+[def __equal_pointees_t__ [link utility.utilities.operators.arithmetic `equal_pointees_t`]]
+[def __equality_comparable1__ [link utility.utilities.operators.arithmetic `equality_comparable1`]]
+[def __equality_comparable2__ [link utility.utilities.operators.arithmetic `equality_comparable2`]]
+[def __equivalent1__ [link utility.utilities.operators.arithmetic `equivalent1`]]
+[def __equivalent2__ [link utility.utilities.operators.arithmetic `equivalent2`]]
+[def __euclidean_ring_operators1__ [link utility.utilities.operators.arithmetic `euclidean_ring_operators1`]]
+[def __euclidean_ring_operators2__ [link utility.utilities.operators.arithmetic `euclidean_ring_operators2`]]
+[def __field_operators1__ [link utility.utilities.operators.arithmetic `field_operators1`]]
+[def __field_operators2__ [link utility.utilities.operators.arithmetic `field_operators2`]]
+[def __forward_iteratable__ [link utility.utilities.operators.arithmetic `forward_iteratable`]]
+[def __forward_iterator_helper__ [link utility.utilities.operators.arithmetic `forward_iterator_helper`]]
+[def __get__ [funcref boost::get `get`]]
+[def __hash_range__ [funcref boost::hash_range `hash_range`]]
+[def __hash_value__ [funcref boost::hash_value `hash_value`]]
+[def __in_place_factory_base__ [classref boost::in_place_factory_base `in_place_factory_base`]]
+[def __incrementable__ [link utility.utilities.operators.arithmetic `incrementable`]]
+[def __indexable__ [link utility.utilities.operators.arithmetic `indexable`]]
+[def __initialized__ [classref boost::initialized `initialized`]]
+[def __initialized_value__ [globalref boost::initialized_value `initialized_value`]]
+[def __initialized_value_t__ [classref boost::initialized_value_t `initialized_value_t`]]
+[def __input_iteratable__ [link utility.utilities.operators.arithmetic `input_iteratable`]]
+[def __input_iterator_helper__ [link utility.utilities.operators.arithmetic `input_iterator_helper`]]
+[def __integer_arithmetic1__ [link utility.utilities.operators.arithmetic `integer_arithmetic1`]]
+[def __integer_arithmetic2__ [link utility.utilities.operators.arithmetic `integer_arithmetic2`]]
+[def __integer_multiplicative1__ [link utility.utilities.operators.arithmetic `integer_multiplicative1`]]
+[def __integer_multiplicative2__ [link utility.utilities.operators.arithmetic `integer_multiplicative2`]]
+[def __is_chained_base__ [link utility.utilities.operators.arithmetic `is_chained_base`]]
+[def __less_pointees__ [funcref boost::less_pointees `less_pointees`]]
+[def __less_pointees_t__ [class boost::less_pointees_t `less_pointees_t`]]
+[def __less_than_comparable1__ [link utility.utilities.operators.arithmetic `less_than_comparable1`]]
+[def __less_than_comparable2__ [link utility.utilities.operators.arithmetic `less_than_comparable2`]]
+[def __multiplicative1__ [link utility.utilities.operators.arithmetic `multiplicative1`]]
+[def __multiplicative2__ [link utility.utilities.operators.arithmetic `multiplicative2`]]
+[def __operator_eq__eq__ [link utility.utilities.operators.arithmetic `operator==`]]
+[def __operator_gt__ [link utility.utilities.operators.arithmetic `operator_gt_`]]
+[def __operator_gt__eq__ [link utility.utilities.operators.arithmetic `operator&gt;`]]
+[def __operator_lt__ [link utility.utilities.operators.arithmetic `operator&lt;`]]
+[def __operator_lt__eq__ [link utility.utilities.operators.arithmetic `operator&lt;=`]]
+[def __operator_lt__lt__ [link utility.utilities.operators.arithmetic `operator&lt;&lt;`]]
+[def __operator_not__eq__ [link utility.utilities.operators.arithmetic `operator!=`]]
+[def __operators2__ [link utility.utilities.operators.arithmetic `operators2`]]
+[def __operators__ [link utility.utilities.operators.arithmetic `operators`]]
+[def __operators_lt_T__ [link utility.utilities.operators.arithmetic `operators<T,T>`]]
+[def __ordered_euclidean_ring_operators1__ [link utility.utilities.operators.arithmetic `ordered_euclidean_ring_operators1`]]
+[def __ordered_euclidean_ring_operators2__ [link utility.utilities.operators.arithmetic `ordered_euclidean_ring_operators2`]]
+[def __ordered_euclidian_ring_operators1__ [link utility.utilities.operators.arithmetic `ordered_euclidian_ring_operators1`]]
+[def __ordered_euclidian_ring_operators2__ [link utility.utilities.operators.arithmetic `ordered_euclidian_ring_operators2`]]
+[def __ordered_field_operators1__ [link utility.utilities.operators.arithmetic `ordered_field_operators1`]]
+[def __ordered_field_operators2__ [link utility.utilities.operators.arithmetic `ordered_field_operators2`]]
+[def __ordered_ring_operators1__ [link utility.utilities.operators.arithmetic `ordered_ring_operators1`]]
+[def __ordered_ring_operators2__ [link utility.utilities.operators.arithmetic `ordered_ring_operators2`]]
+[def __output_iteratable__ [link utility.utilities.operators.arithmetic `output_iteratable`]]
+[def __output_iterator_helper__ [link utility.utilities.operators.arithmetic `output_iterator_helper`]]
+[def __partially_ordered1__ [link utility.utilities.operators.arithmetic `partially_ordered1`]]
+[def __partially_ordered2__ [link utility.utilities.operators.arithmetic `partially_ordered2`]]
+[def __random_access_iteratable__ [link utility.utilities.operators.arithmetic `random_access_iteratable`]]
+[def __random_access_iterator_helper__ [link utility.utilities.operators.arithmetic `random_access_iterator_helper`]]
+[def __result_of__ [classref boost::result_of `result_of`]]
+[def __ring_operators1__ [link utility.utilities.operators.arithmetic `ring_operators1`]]
+[def __ring_operators2__ [link utility.utilities.operators.arithmetic `ring_operators2`]]
+[def __shiftable1__ [link utility.utilities.operators.arithmetic `shiftable1`]]
+[def __shiftable2__ [link utility.utilities.operators.arithmetic `shiftable2`]]
+[def __string_ref__ [classref boost::basic_string_ref `string_ref`]]
+[def __string_view__ [classref boost::basic_string_view `string_view`]]
+[def __swap__ [link utility.utilities.operators.arithmetic `swap`]]
+[def __totally_ordered1__ [link utility.utilities.operators.arithmetic `totally_ordered1`]]
+[def __totally_ordered2__ [link utility.utilities.operators.arithmetic `totally_ordered2`]]
+[def __tr1_result_of__ [classref boost::tr1_result_of `tr1_result_of`]]
+[def __typed_in_place_factory_base__ [classref boost::typed_in_place_factory_base `typed_in_place_factory_base`]]
+[def __u16string_ref__ [classref boost::basic_string_ref `u16string_ref`]]
+[def __u16string_view__ [classref boost::basic_string_view `u16string_view`]]
+[def __u32string_ref__ [classref boost::basic_string_ref `u32string_ref`]]
+[def __u32string_view__ [classref boost::basic_string_view `u32string_view`]]
+[def __unit_steppable__ [link utility.utilities.operators.arithmetic `unit_steppable`]]
+[def __value_initialized__ [classref boost::value_initialized `value_initialized`]]
+[def __wstring_ref__ [classref boost::basic_string_ref `wstring_ref`]]
+[def __wstring_view__ [classref boost::basic_string_view `wstring_view`]]

 [/ std:: types ]

@ -219,8 +219,7 @@

 [include other.qbk]

-[#sec:reference]
-[section:ref Quick Reference]
+[section:reference Quick Reference]

 [/ Reference table ]
 [xinclude quickref.xml]
--- a/doc/operators.qbk
+++ b/doc/operators.qbk
--- a/doc/other.qbk
+++ b/doc/other.qbk
@ -7,7 +7,7 @@
    Official repository: https://github.com/boostorg/utility
 ]

-[section:utilities More Utilities]
+[section:more_utilities More Utilities]

 Some utilities have been moved from Boost.Utilities to more appropriate Boost libraries:

--- a/doc/overview.qbk
+++ b/doc/overview.qbk
@ -20,14 +20,14 @@ Over time,
 When the component has moved to another Boost library, Boost.Utility headers still lead to the appropriate headers
 in other libraries.

-[table:id Components
+[table Components
    [[Boost.Utility] [Moved to Boost] [C++ Standard variant]]
    [[[@boost:/libs/core/doc/html/core/addressof.html `addressof`]] [[@boost:/libs/core/index.html Boost.Core]] [C++11 __std_addressof__]]
-    [[__base_from_member__]      [] []]
+    [[[link utility.utilities.base_from_member `base_from_member`]]      [] []]
    [[__BOOST_BINARY__] [] [C++14 [@https://en.cppreference.com/w/cpp/language/integer_literal Binary integer literal]]]
-    [[__call_traits__]      [] []]
+    [[[link utility.utilities.call_traits `call_traits`]]      [] []]
    [[[@boost:/libs/core/doc/html/core/checked_delete.html `checked_delete`]] [[@boost:/libs/core/index.html Boost.Core]] []]
-    [[__compressed_pair__]      [] []]
+    [[[link utility.utilities.compressed_pair `compressed_pair`]]      [] []]
    [[[@boost:/libs/type_traits/doc/html/boost_typetraits/reference/declval.html `declval`]] [[@boost:/libs/type_traits/index.html Boost.TypeTraits]] [C++11 __std_declval__]]
    [[[@boost:/libs/core/doc/html/core/enable_if.html `enable_if`]] [[@boost:/libs/core/index.html Boost.Core]] [C++11 __std_enable_if__]]
    [[[@boost:/libs/iterator/doc/generator_iterator.htm generator iterator adaptors]] [[@boost:/libs/iterator/index.html Boost.Iterator]] []]
@ -35,12 +35,12 @@ in other libraries.
    [[[@boost:/libs/iterator/index.html `iterator_adaptors`]]      [[@boost:/libs/iterator/index.html Boost.Iterator]] []]
    [[[@boost:/libs/iterator/doc/html/iterator/algorithms/next_prior.html `next` / `prior`]] [[@boost:/libs/iterator/index.html Boost.Iterator]] [C++11 __std_next__ / __std_prev__]]
    [[[@boost:/libs/core/doc/html/core/noncopyable.html `noncopyable`]] [[@boost:/libs/core/index.html Boost.Core]] []]
-    [[[link sec:operators `operators`]]      [] []]
+    [[[link utility.utilities.operators `operators`]]      [] []]
    [[[@boost:/libs/io/doc/html/io.html `ostream_string`]] [[@boost:/libs/io/index.html Boost.IO]] []]
-    [[__result_of__]      [] [C++11 __std_result_of__]]
-    [[__string_view__]      [] [C++17 __std_string_view__]]
+    [[[link utility.utilities.result_of `result_of`]]      [] [C++11 __std_result_of__]]
+    [[[link utility.utilities.string_view `string_view`]]      [] [C++17 __std_string_view__]]
    [[[@boost:/libs/throw_exception/doc/html/throw_exception.html#using_boost_throw_exception `throw_exception`]] [[@boost:/libs/throw_exception/index.html Boost.ThrowException]] []]
-    [[[link sec:value_init `value_init`]]      [] [C++11 [@https://en.cppreference.com/w/cpp/language/list_initialization List initialization]]]
+    [[[link utility.utilities.value_init `value_init`]]      [] [C++11 [@https://en.cppreference.com/w/cpp/language/list_initialization List initialization]]]
 ]

 [endsect]
--- a/doc/quickref.xml
+++ b/doc/quickref.xml
@ -43,7 +43,7 @@
                    <bridgehead renderas="sect3">Classes</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="boost.base_from_member">base_from_member</link>
+                            <classname alt="boost::base_from_member">base_from_member</classname>
                        </member>
                    </simplelist>
                </entry>
@ -53,19 +53,16 @@
                    <bridgehead renderas="sect3">Type Traits</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="boost.call_traits">call_traits</link>
+                            <classname alt="boost::call_traits">call_traits</classname>
                        </member>
                        <member>
-                            <link linkend="boost.call_traits">call_traits&lt;T&amp;&gt;</link>
+                            <classname alt="boost::call_traits">call_traits&lt;T&amp;&gt;</classname>
                        </member>
                        <member>
-                            <link linkend="boost.call_traits">call_traits&lt;T[N]&gt;
-                            </link>
+                            <classname alt="boost::call_traits">call_traits&lt;T[N]&gt;</classname>
                        </member>
                        <member>
-                            <link linkend="boost.call_traits">call_traits&lt;const
-                                T[N]&gt;
-                            </link>
+                            <classname alt="boost::call_traits">call_traits&lt;const T[N]&gt;</classname>
                        </member>
                    </simplelist>
                </entry>
@ -75,14 +72,14 @@
                    <bridgehead renderas="sect3">Classes</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="boost.compressed_pair">compressed_pair</link>
+                            <classname alt="boost::compressed_pair">compressed_pair</classname>
                        </member>
                    </simplelist>

                    <bridgehead renderas="sect3">Functions</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="header.boost.detail.compressed_pair_hpp">swap</link>
+                            <headername alt="boost/detail/compressed_pair.hpp">swap</headername>
                        </member>
                    </simplelist>
                </entry>
@ -92,11 +89,10 @@
                    <bridgehead renderas="sect3">Classes</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="boost.in_place_factory_base">in_place_factory_base</link>
+                            <classname alt="boost::in_place_factory_base">in_place_factory_base</classname>
                        </member>
                        <member>
-                            <link linkend="boost.typed_in_place_factory_base">typed_in_place_factory_base
-                            </link>
+                            <classname alt="boost::typed_in_place_factory_base">typed_in_place_factory_base</classname>
                        </member>
                    </simplelist>
                </entry>
@ -126,45 +122,45 @@
                    <bridgehead renderas="sect3">Classes (1 of 5)</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="sec:arithmetic">additive1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.additive1">additive1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">additive2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.additive2">additive2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">arithmetic1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.arithmetic1">arithmetic1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">arithmetic2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.arithmetic2">arithmetic2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">bidirectional_iteratable</link>
+                            <link linkend="utility.utilities.operators.deref.grpd_iter_oprs.bidirectional_iteratable">bidirectional_iteratable</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">
+                            <link linkend="utility.utilities.operators.deref.iterator.bidirectional_iterator_helper">
                                bidirectional_iterator_helper
                            </link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">bitwise1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.bitwise1">bitwise1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">bitwise2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.bitwise2">bitwise2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">decrementable</link>
+                            <link linkend="utility.utilities.operators.arithmetic.smpl_oprs.decrementable">decrementable</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">dereferenceable</link>
+                            <link linkend="utility.utilities.operators.deref.dereference.dereferenceable">dereferenceable</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">equality_comparable1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.smpl_oprs.equality_comparable1">equality_comparable1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">equality_comparable2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.smpl_oprs.equality_comparable2">equality_comparable2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">equivalent1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.smpl_oprs.equivalent1">equivalent1</link>
                        </member>
                    </simplelist>
                </entry>
@ -173,45 +169,45 @@
                    <bridgehead renderas="sect3">Classes (2 of 5)</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="sec:arithmetic">equivalent2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.smpl_oprs.equivalent2">equivalent2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">euclidean_ring_operators1
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.euclidean_ring_operators1">euclidean_ring_operators1
                            </link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">euclidean_ring_operators2
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.euclidean_ring_operators2">euclidean_ring_operators2
                            </link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">field_operators1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.field_operators1">field_operators1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">field_operators2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.field_operators2">field_operators2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">forward_iteratable</link>
+                            <link linkend="utility.utilities.operators.deref.grpd_iter_oprs.forward_iteratable">forward_iteratable</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">forward_iterator_helper</link>
+                            <link linkend="utility.utilities.operators.deref.iterator.forward_iterator_helper">forward_iterator_helper</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">incrementable</link>
+                            <link linkend="utility.utilities.operators.arithmetic.smpl_oprs.incrementable">incrementable</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">indexable</link>
+                            <link linkend="utility.utilities.operators.deref.dereference.indexable">indexable</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">input_iteratable</link>
+                            <link linkend="utility.utilities.operators.deref.grpd_iter_oprs.input_iteratable">input_iteratable</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">input_iterator_helper</link>
+                            <link linkend="utility.utilities.operators.deref.iterator.input_iterator_helper">input_iterator_helper</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">integer_arithmetic1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.integer_arithmetic1">integer_arithmetic1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">integer_arithmetic2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.integer_arithmetic2">integer_arithmetic2</link>
                        </member>
                    </simplelist>
                </entry>
@ -220,49 +216,47 @@
                    <bridgehead renderas="sect3">Classes (3 of 5)</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="sec:arithmetic">integer_multiplicative1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.integer_multiplicative1">integer_multiplicative1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">integer_multiplicative2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.integer_multiplicative2">integer_multiplicative2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">is_chained_base</link>
+                            <link linkend="utility.utilities.operators.arithmetic.smpl_oprs.less_than_comparable1">less_than_comparable1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">less_than_comparable1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.smpl_oprs.less_than_comparable2">less_than_comparable2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">less_than_comparable2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.multiplicative1">multiplicative1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">multiplicative1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.multiplicative2">multiplicative2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">multiplicative2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.ex_oprs.operators1">operators1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">operators</link>
+                            <link linkend="utility.utilities.operators.arithmetic.ex_oprs.operators2">operators2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">operators2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.ex_oprs.operators2">operators&lt;T,T&gt;</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">operators&lt;T,T&gt;</link>
-                        </member>
-                        <member>
-                            <link linkend="sec:arithmetic">
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ordered_euclidean_ring_operators1">
                                ordered_euclidean_ring_operators1
                            </link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ordered_euclidean_ring_operators2">
                                ordered_euclidean_ring_operators2
                            </link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">
-                                ordered_euclidian_ring_operators1
-                            </link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ordered_field_operators1">ordered_field_operators1</link>
+                        </member>
+                        <member>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ordered_field_operators2">ordered_field_operators2</link>
                        </member>
                    </simplelist>
                </entry>
@ -271,47 +265,45 @@
                    <bridgehead renderas="sect3">Classes (4 of 5)</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="sec:arithmetic">
-                                ordered_euclidian_ring_operators2
-                            </link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ordered_ring_operators1">ordered_ring_operators1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">ordered_field_operators1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ordered_ring_operators2">ordered_ring_operators2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">ordered_field_operators2</link>
+                            <link linkend="utility.utilities.operators.deref.grpd_iter_oprs.output_iteratable">output_iteratable</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">ordered_ring_operators1</link>
+                            <link linkend="utility.utilities.operators.deref.iterator.output_iterator_helper">output_iterator_helper</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">ordered_ring_operators2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.smpl_oprs.partially_ordered1">partially_ordered1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">output_iteratable</link>
+                            <link linkend="utility.utilities.operators.arithmetic.smpl_oprs.partially_ordered2">partially_ordered2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">output_iterator_helper</link>
+                            <link linkend="utility.utilities.operators.deref.grpd_iter_oprs.random_access_iteratable">random_access_iteratable</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">partially_ordered1</link>
-                        </member>
-                        <member>
-                            <link linkend="sec:arithmetic">partially_ordered2</link>
-                        </member>
-                        <member>
-                            <link linkend="sec:arithmetic">random_access_iteratable</link>
-                        </member>
-                        <member>
-                            <link linkend="sec:arithmetic">
+                            <link linkend="utility.utilities.operators.deref.iterator.random_access_iterator_helper">
                                random_access_iterator_helper
                            </link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">ring_operators1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ring_operators1">ring_operators1</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">ring_operators2</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ring_operators2">ring_operators2</link>
+                        </member>
+                        <member>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.shiftable1">shiftable1</link>
+                        </member>
+                        <member>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.shiftable2">shiftable2</link>
+                        </member>
+                        <member>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.totally_ordered1">totally_ordered1</link>
                        </member>
                    </simplelist>
                </entry>
@ -320,25 +312,10 @@
                    <bridgehead renderas="sect3">Classes (5 of 5)</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="sec:arithmetic">shiftable1</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.totally_ordered2">totally_ordered2</link>
                        </member>
                        <member>
-                            <link linkend="sec:arithmetic">shiftable2</link>
-                        </member>
-                        <member>
-                            <link linkend="sec:arithmetic">totally_ordered1</link>
-                        </member>
-                        <member>
-                            <link linkend="sec:arithmetic">totally_ordered2</link>
-                        </member>
-                        <member>
-                            <link linkend="sec:arithmetic">unit_steppable</link>
-                        </member>
-                    </simplelist>
-                    <bridgehead renderas="sect3">Type Traits</bridgehead>
-                    <simplelist type="vert" columns="1">
-                        <member>
-                            <link linkend="sec:arithmetic">is_chained_base</link>
+                            <link linkend="utility.utilities.operators.arithmetic.grpd_oprs.unit_steppable">unit_steppable</link>
                        </member>
                    </simplelist>
                </entry>
@ -374,10 +351,10 @@
                    <bridgehead renderas="sect3">Type Traits</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="boost.result_of">result_of</link>
+                            <classname alt="boost::result_of">result_of</classname>
                        </member>
                        <member>
-                            <link linkend="boost.tr1_result_of">tr1_result_of</link>
+                            <classname alt="boost::tr1_result_of">tr1_result_of</classname>
                        </member>
                    </simplelist>
                </entry>
@ -387,28 +364,28 @@
                    <bridgehead renderas="sect3">Aliases</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="boost.basic_string_view">string_view</link>
+                            <classname alt="boost::basic_string_view">string_view</classname>
                        </member>
                        <member>
-                            <link linkend="boost.basic_string_view">u16string_ref</link>
+                            <classname alt="boost::basic_string_ref">u16string_ref</classname>
                        </member>
                        <member>
-                            <link linkend="boost.basic_string_view">u16string_view</link>
+                            <classname alt="boost::basic_string_view">u16string_view</classname>
                        </member>
                        <member>
-                            <link linkend="boost.basic_string_view">u32string_ref</link>
+                            <classname alt="boost::basic_string_ref">u32string_ref</classname>
                        </member>
                        <member>
-                            <link linkend="boost.basic_string_view">u32string_view</link>
+                            <classname alt="boost::basic_string_view">u32string_view</classname>
                        </member>
                        <member>
-                            <link linkend="boost.basic_string_view">wstring_ref</link>
+                            <classname alt="boost::basic_string_ref">wstring_ref</classname>
                        </member>
                        <member>
-                            <link linkend="boost.basic_string_view">wstring_view</link>
+                            <classname alt="boost::basic_string_view">wstring_view</classname>
                        </member>
                        <member>
-                            <link linkend="boost.basic_string_view">string_ref</link>
+                            <classname alt="boost::basic_string_ref">string_ref</classname>
                        </member>
                    </simplelist>
                </entry>
@ -417,19 +394,19 @@
                    <bridgehead renderas="sect3">Classes</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="boost.basic_string_view">basic_string_ref</link>
+                            <classname alt="boost::basic_string_ref">basic_string_ref</classname>
                        </member>
                        <member>
-                            <link linkend="boost.basic_string_view">basic_string_view</link>
+                            <classname alt="boost::basic_string_view">basic_string_view</classname>
                        </member>
                    </simplelist>
                    <bridgehead renderas="sect3">Functions</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="boost.hash_range">hash_range</link>
+                            <functionname alt="boost::hash_range">hash_range</functionname>
                        </member>
                        <member>
-                            <link linkend="boost.hash_value">hash_value</link>
+                            <functionname alt="boost::hash_value">hash_value</functionname>
                        </member>
                    </simplelist>
                </entry>
@ -438,58 +415,58 @@
                    <bridgehead renderas="sect3">Operators</bridgehead>
                    <simplelist type="vert" columns="1">
                        <member>
-                            <link linkend="header.boost.utility.string_view_hpp">operator==</link>
+                            <headername alt="boost/utility/string_view.hpp">operator==</headername>
                        </member>
                        <member>
-                            <link linkend="header.boost.utility.string_view_hpp">operator!=</link>
+                            <headername alt="boost/utility/string_view.hpp">operator!=</headername>
                        </member>
                        <member>
-                            <link linkend="header.boost.utility.string_view_hpp">operator&lt;</link>
+                            <headername alt="boost/utility/string_view.hpp">operator&lt;</headername>
                        </member>
                        <member>
-                            <link linkend="header.boost.utility.string_view_hpp">operator&lt;=</link>
+                            <headername alt="boost/utility/string_view.hpp">operator&lt;=</headername>
                        </member>
                        <member>
-                            <link linkend="header.boost.utility.string_view_hpp">operator&gt;</link>
+                            <headername alt="boost/utility/string_view.hpp">operator&gt;</headername>
                        </member>
                        <member>
-                            <link linkend="header.boost.utility.string_view_hpp">operator&gt;=</link>
+                            <headername alt="boost/utility/string_view.hpp">operator&gt;=</headername>
                        </member>
                        <member>
-                            <link linkend="header.boost.utility.string_view_hpp">operator&lt;&lt;</link>
+                            <headername alt="boost/utility/string_view.hpp">operator&lt;&lt;</headername>
                        </member>
                    </simplelist>
                </entry>

                <!-- value_init -->
                <entry valign="top">
-                        <bridgehead renderas="sect3">Classes</bridgehead>
-                        <simplelist type="vert" columns="1">
-                            <member>
-                                <link linkend="boost.initialized">initialized</link>
-                            </member>
-                            <member>
-                                <link linkend="boost.initialized_value_t">initialized_value_t</link>
-                            </member>
-                            <member>
-                                <link linkend="boost.value_initialized">value_initialized</link>
-                            </member>
-                        </simplelist>
-                        <bridgehead renderas="sect3">Functions</bridgehead>
-                        <simplelist type="vert" columns="1">
-                            <member>
-                                <link linkend="header.boost.utility.value_init_hpp">get</link>
-                            </member>
-                            <member>
-                                <link linkend="header.boost.utility.value_init_hpp">swap</link>
-                            </member>
-                        </simplelist>
-                        <bridgehead renderas="sect3">Constants</bridgehead>
-                        <simplelist type="vert" columns="1">
-                            <member>
-                                <link linkend="boost.initialized_value">initialized_value</link>
-                            </member>
-                        </simplelist>
+                    <bridgehead renderas="sect3">Classes</bridgehead>
+                    <simplelist type="vert" columns="1">
+                        <member>
+                            <classname alt="boost::initialized">initialized</classname>
+                        </member>
+                        <member>
+                            <classname alt="boost::initialized_value_t">initialized_value_t</classname>
+                        </member>
+                        <member>
+                            <classname alt="boost::value_initialized">value_initialized</classname>
+                        </member>
+                    </simplelist>
+                    <bridgehead renderas="sect3">Functions</bridgehead>
+                    <simplelist type="vert" columns="1">
+                        <member>
+                            <headername alt="boost/utility/value_init.hpp">get</headername>
+                        </member>
+                        <member>
+                            <headername alt="boost/utility/value_init.hpp">swap</headername>
+                        </member>
+                    </simplelist>
+                    <bridgehead renderas="sect3">Constants</bridgehead>
+                    <simplelist type="vert" columns="1">
+                        <member>
+                            <globalname alt="boost::initialized_value">initialized_value</globalname>
+                        </member>
+                    </simplelist>
                </entry>
            </row>
        </tbody>
--- a/doc/result_of.qbk
+++ b/doc/result_of.qbk
@ -7,7 +7,7 @@
 /]

 [/===============]
-[section Result of]
+[section:result_of Result of]
 [/===============]

 [section Introduction]
@ -122,7 +122,7 @@ and is not implemented by some compilers.
 the actual result type deduced by __decltype__, then using TR1 with a __decltype__ fallback
 will allow you to work with both your existing TR1 function objects and new C++11
 function object. This situation could occur if your legacy function objects
-misused the TR1 protocol. See the documentation on known [link sec:result_of_tr1_diff differences]
+misused the TR1 protocol. See the documentation on known [link utility.utilities.result_of.result_of_tr1_diff differences]
 between __boost_result_of__ and TR1.

 * [#BOOST_NO_RESULT_OF] This implementation of __result_of__ requires class template
@ -138,8 +138,7 @@ or, for motivation and design rationale, the __result_of__

 [endsect]

-[#sec:result_of_guidelines]
-[section Usage guidelines for __boost_result_of__]
+[section:result_of_guidelines Usage guidelines for __boost_result_of__]

 The following are general suggestions about when and how to use __boost_result_of__.

@ -151,7 +150,7 @@ there's no reason to stop using it.
 # If you are targeting C++11 but may port your code to legacy compilers
 at some time in the future, then use __boost_result_of__ with __decltype__.
 When __decltype__ is used __boost_result_of__ and `__std_result_of__` are usually
-interchangeable. See the documentation on known [link sec:result_of_cxx11_diff differences]
+interchangeable. See the documentation on known [link utility.utilities.result_of.result_of_cxx11_diff differences]
 between __boost_result_of__ and C++11 __std_result_of__.

 # If compiler portability is required, use __boost_result_of__ with the TR1 protocol
@ -195,8 +194,7 @@ typedef __boost_result_of__<

 [endsect]

-[#sec:result_of_tr1_protocol_guidelines]
-[section Usage guidelines for the TR1 result_of protocol]
+[section:result_of_tr1_protocol_guidelines Usage guidelines for the TR1 result_of protocol]

 On compliant C++11 compilers, __boost_result_of__ can
 use __decltype__ to deduce the type of any
@ -212,7 +210,7 @@ argument types or the cv-qualification of the
 function object, simply
 define `result_type`. There is no need
 to use the `result` template unless the
-return type varies.</li>
+return type varies.

 * Use the protocol specified type when defining
 function prototypes. This can help ensure the
@ -274,8 +272,7 @@ struct functor {

 [endsect]

-[#sec:result_of_tr1_diff]
-[section Known differences between __boost_result_of__ and __boost_tr1_result_of__]
+[section:result_of_tr1_diff Known differences between __boost_result_of__ and __boost_tr1_result_of__]

 When using __decltype__, __boost_result_of__ ignores the TR1 protocol and instead deduces the
 return type of function objects directly via __decltype__. In most situations, users
@ -399,8 +396,7 @@ BOOST_STATIC_ASSERT((

 [endsect]

-[#sec:result_of_cxx11_diff]
-[section Known differences between __boost_result_of__ and C++11 result_of]
+[section:result_of_cxx11_diff Known differences between __boost_result_of__ and C++11 result_of]

 When using __decltype__, __boost_result_of__ implements most of the C++11 __std_result_of__
 specification. One known exception is that __boost_result_of__ does not implement the
--- a/doc/string_view.qbk
+++ b/doc/string_view.qbk
@ -7,7 +7,7 @@
 /]

 [/===============]
-[section String View]
+[section:string_view String View]
 [/===============]

 [section Introduction]
--- a/doc/value_init.qbk
+++ b/doc/value_init.qbk
@ -7,9 +7,7 @@
 /]

 [/===============]
-[#sec:value_init]
-[section Value Init]
-
+[section:value_init Value Init]
 [/===============]

 [section Introduction]
@ -61,7 +59,7 @@ the syntax did not allow for a class that has an explicitly declared constructor
 The fourth form is the most generic form of them, as it can be used to initialize
 arithmetic types, class types, aggregates, pointers, and other types.
 The declaration,  `T4 var4 = T4()`, should be read as follows: First a temporary
-object is created, by `T4()`. This object is [link sec:valueinit value-initialized].
+object is created, by `T4()`. This object is [link utility.utilities.value_init.details.value_initialization value-initialized].
 Next the temporary object is copied to the named variable, `var4`. Afterwards,
 the temporary is destroyed. While the copying and the destruction are likely to
 be optimized away, C++ still requires the type `T4` to be __CopyConstructible__.
@ -69,11 +67,11 @@ So `T4` needs to be ['both] __DefaultConstructible__ ['and] __CopyConstructible_

 A class may not be CopyConstructible, for example because it may have a
 private and undefined copy constructor, or because it may be derived from
-`boost::noncopyable`. Scott Meyers \[[link sec:references 2]\] explains why a
+`boost::noncopyable`. Scott Meyers \[[link utility.utilities.value_init.references 2]\] explains why a
 class would be defined like that.

 There is another, less obvious disadvantage to the fourth form, `T4 var4 = T4()`:
-It suffers from various [link sec:compiler_issues compiler issues], causing
+It suffers from various [link utility.utilities.value_init.details.compiler_issues compiler issues], causing
 a variable to be left uninitialized in some compiler specific cases.

 The template __value_initialized__ offers a generic way to initialize
@ -103,13 +101,12 @@ but robust against the aforementioned compiler issues.

 [endsect]

-[#sec:details]
-[section Details]
+[section:details Details]

-The C++ standard \[[link sec:references 3]\] contains the definitions
+The C++ standard \[[link utility.utilities.value_init.references 3]\] contains the definitions
 of `zero-initialization` and `default-initialization`. Informally, zero-initialization
 means that the object is given the initial value `0` converted to the type and
-default-initialization means that [@https://en.cppreference.com/w/cpp/named_req/PODType POD] \[[link sec:references 4]\] types are zero-initialized,
+default-initialization means that [@https://en.cppreference.com/w/cpp/named_req/PODType POD] \[[link utility.utilities.value_init.references 4]\] types are zero-initialized,
 while non-POD class types are initialized with their corresponding default constructors.

 A ['declaration] can contain an ['initializer], which specifies the
@ -136,8 +133,7 @@ foo ( __std_string__() ) ;
 // as indicated by the initializer ()
 ```

-[#sec:valueinit]
-[h5 value-initialization]
+[section:value_initialization value-initialization]

 The first [@http://www.open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html Technical
 Corrigendum for the C++ Standard] (TC1), whose draft was released to the public in
@ -173,8 +169,9 @@ eat ( int() ) ; // value-initialized
 eat ( __std_string__() ) ; // value-initialized
 ```

-[#sec:valueinitsyn]
-[h5 value-initialization syntax]
+[endsect]
+
+[section:syntax value-initialization syntax]

 Value initialization is specified using `()`. However, the empty set of
 parentheses is not permitted by the syntax of initializers because it is
@ -224,8 +221,9 @@ This is the solution as it was supplied by earlier versions of the
 `__value_initialized__<T>` template class. Unfortunately this approach
 suffered from various compiler issues.

-[#sec:compiler_issues]
-[h5 Compiler issues]
+[endsect]
+
+[section:compiler_issues Compiler issues]

 Various compilers have not yet fully implemented value-initialization.
 So when an object should be ['value-initialized] according to the C++ Standard,
@ -242,8 +240,6 @@ go wrong on various compilers.
 At the moment of writing, May 2010, the following reported issues regarding
 value-initialization are still there in current compiler releases:

-
-
 * [@https://connect.microsoft.com/VisualStudio/feedback/details/100744 Microsoft Visual Studio Feedback ID 100744, Value-initialization in new-expression]: Reported by Pavel Kuznetsov (MetaCommunications Engineering), 2005.
 * [@http://connect.microsoft.com/VisualStudio/feedback/details/484295 Microsoft Visual Studio Feedback ID 484295, VC++ does not value-initialize members of derived classes without user-declared constructor] Reported by Sylvester Hesp, 2009.
 * [@https://connect.microsoft.com/VisualStudio/feedback/details/499606 Microsoft Visual Studio Feedback ID 499606, Presence of copy constructor breaks member class initialization] Reported by Alex Vakulenko, 2009
@ -267,11 +263,11 @@ compiler defect macro] `BOOST_NO_COMPLETE_VALUE_INITIALIZATION`.

 [endsect]

-[#sec:types]
-[section Types and objects]
+[endsect]

-[#sec:val_init]
-[section `template class value_initialized<T>`]
+[section:types Types and objects]
+
+[section:val_init `template class value_initialized<T>`]

 ```
 namespace boost {
@ -323,7 +319,7 @@ void swap ( __value_initialized__<T>& lhs, __value_initialized__<T>& rhs )
 ```

 An object of this template class is a `T`-wrapper convertible to `'T&'` whose
-wrapped object (data member of type `T`) is [link sec:valueinit value-initialized] upon default-initialization
+wrapped object (data member of type `T`) is [link utility.utilities.value_init.details.value_initialization value-initialized] upon default-initialization
 of this wrapper class:

 ```
@ -338,7 +334,7 @@ assert( y == def ) ;

 The purpose of this wrapper is to provide a consistent syntax for value initialization
 of scalar, union and class types (POD and non-POD) since the correct syntax for value
-initialization varies (see [link sec:valueinitsyn value-initialization syntax]).
+initialization varies (see [link utility.utilities.value_init.details.syntax value-initialization syntax]).

 The wrapped object can be accessed either through the conversion operator
 `T&`, the member function `data()`, or the non-member function `get()`:
@ -404,7 +400,7 @@ supports the idea of logical constness.

 ]

-[h5 Recommended practice: The non-member get() idiom]
+[section Recommended practice: The non-member get() idiom]

 The obscure behavior of being able to modify a non-`const`
 wrapped object from within a constant wrapper (as was supported by previous
@ -426,8 +422,9 @@ get(cx_c) = 1; // ERROR: Cannot modify a const object

 [endsect]

-[#sec:initialized]
-[section `template class initialized<T>`]
+[endsect]
+
+[section:initialized `template class initialized<T>`]


 ```
@ -491,8 +488,7 @@ direct-initialized, none of the two wrappers really needs to be used.

 [endsect]

-[#sec:initialized_value]
-[section `initialized_value`]
+[section:initialized_value `initialized_value`]

 ```
 namespace boost {
@ -538,8 +534,7 @@ T var = __initialized_value__;
 [endsect]
 [endsect]

-[#sec:references]
-[section References]
+[section:references References]

 # Bjarne Stroustrup, Gabriel Dos Reis, and J. Stephen Adamczyk wrote various papers,
 proposing to extend the support for brace-enclosed ['initializer lists]
@ -561,8 +556,7 @@ compiler-generated functions you do not want], [@http://www.aristeia.com/books.h
 [xinclude tmp/value_init_reference.xml]
 [/===============]

-[#sec:acknowledgements]
-[section Acknowledgements]
+[section:acknowledgements Acknowledgements]

 __value_initialized__ was developed by Fernando Cacciola, with help and suggestions
 from David Abrahams and Darin Adler.
--- a/identity_type/doc/Jamfile.v2
+++ b/identity_type/doc/Jamfile.v2
@ -8,7 +8,7 @@
 import quickbook ;
 using boostbook ;

-doxygen reference : ../../../../boost/utility/identity_type.hpp
+doxygen reference : ../../include/boost/utility/identity_type.hpp
    :   <reftitle>"Reference"
        <doxygen:param>PREDEFINED="DOXYGEN"
        <doxygen:param>QUIET=YES
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -8,12 +8,14 @@
 # bring in rules for testing
 import testing ;

+project : requirements <library>/boost/utility//boost_utility ;
+
 run base_from_member_test.cpp ;
 run base_from_member_ref_test.cpp ;

 run binary_test.cpp ;

-run call_traits_test.cpp : -u ;
+run call_traits_test.cpp : -u : : <library>/boost/type_traits//testing ;

 run compressed_pair_test.cpp ;
 run compressed_pair_final_test.cpp ;
@ -31,7 +33,7 @@ run string_ref_test2.cpp ;
 run string_ref_test_io.cpp ;
 # compile-fail string_view_from_rvalue.cpp ;
 compile string_view_constexpr_test1.cpp ;
-run string_view_test1.cpp ;
+run string_view_test1.cpp : : : <library>/boost/container_hash//boost_container_hash ;
 run string_view_test2.cpp ;
 run string_view_test_io.cpp ;

--- a/test/call_traits_test.cpp
+++ b/test/call_traits_test.cpp
@ -18,8 +18,8 @@
 #include <typeinfo>
 #include <boost/call_traits.hpp>

-#include <libs/type_traits/test/test.hpp>
-#include <libs/type_traits/test/check_type.hpp>
+// type_traits/test utilities
+#include "check_type.hpp"

 #ifdef BOOST_MSVC
 #pragma warning(disable:4181) // : warning C4181: qualifier applied to reference type; ignored
Author	SHA1	Message	Date
Andrey Semashev	211570f2b9	Added new gcc and clang jobs to GitHub Actions.	2025-06-13 02:53:36 +03:00
Andrey Semashev	7f1b54c3cc	Use Azure mirrors of Ubuntu .deb repositories in containers. This reduces the likelihood of spurious CI failures caused by DDoS filters being triggered by massive numbers of concurrent CI jobs.	2025-06-13 02:48:20 +03:00
Andrey Semashev	4c85489e91	Removed windows-2019 jobs from GitHub Actions. The windows-2019 image is deprecated and is about to be removed.	2025-06-13 02:47:06 +03:00
Andrey Semashev	fdd6586aa6	Expand BOOST_NOEXCEPT_EXPR in Doxygen.	2025-05-03 05:29:05 +03:00
Andrey Semashev	49cd132374	Fixed references to Doxygen-generated reference and between sections. Since BoostBook stylesheets were updated to pass through Doxygen anchor names to BoostBook output, references from QuickBook and manually written BoostBook docs were broken. Fix this by using classref/classname and similar tools to reference Doxygen-generated content. Also, to avoid anchor clashes between different parts of Boost.Utility docs, use proper anchor namespacing: avoid using manual anchors where possible and use fully qualified namespace where not. Fixes https://github.com/boostorg/utility/issues/110.	2025-05-03 05:17:00 +03:00
Andrey Semashev	67d8cbd243	Updated GHA to remove obsolete images and add new compilers.	2025-04-15 14:12:08 +03:00
Andrey Semashev	ec297bfdfb	Merge pull request #109 from grafikrobot/modular Add support for modular build structure.	2025-04-13 17:39:40 +03:00
Rene Rivera	3a5e8f4aba	Minimize the possible header ambiguiity of including the type_traits test headers by only including the more specific header and using non-system search paths bracket.	2024-08-17 01:26:12 -05:00
Rene Rivera	9939ea24d1	Update build deps.	2024-08-10 20:47:03 -05:00
Rene Rivera	171647fb3e	Adjust doc build to avoid boost-root references.	2024-07-28 11:51:28 -05:00
Rene Rivera	8f6116ada4	Move inter-lib dependencies to a project variable and into the build targets.	2024-07-23 22:34:22 -05:00
Rene Rivera	2a37aaaeb4	Update copyright dates.	2024-07-20 22:52:04 -05:00
Rene Rivera	79c293351f	Change all <source> references to <library>.	2024-07-20 21:27:39 -05:00
Rene Rivera	a481266238	Bump B2 require to 5.2	2024-06-14 11:33:56 -05:00
Rene Rivera	2aa26c9e84	Sync from upstream.	2024-05-20 18:30:51 -05:00
Rene Rivera	6d870ad5e3	Add requires-b2 check to top-level build file.	2024-05-05 09:00:01 -05:00
Rene Rivera	80ede74e8c	Sync from upstream.	2024-04-20 15:32:25 -05:00
Rene Rivera	336c00b659	Remove relative references to boost-root in Jamfiles.	2024-04-13 16:21:04 -05:00
Rene Rivera	bf21064bfd	Switch to library requirements instead of source. As source puts extra source in install targets.	2024-03-29 21:16:00 -05:00
Rene Rivera	2a8ce8e081	Make the library modular usable.	2024-03-11 08:38:17 -05:00