tests: remove all -Wall warnings

Merge pull request #145 from alandefreitas/fix/maybe-uninitialized-pragma
fix: add -Wmaybe-uninitialized pragma to union storage constructors
2026-05-05 04:04:34 +02:00 · 2026-02-25 22:49:18 +01:00 · 2026-02-25 17:42:43 +01:00 · 2026-02-24 12:11:51 -05:00 · 2026-02-20 16:14:53 +01:00 · 2026-02-18 21:10:45 +01:00
162 changed files with 14390 additions and 7473 deletions
@@ -0,0 +1,36 @@
+# 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("TOOLSET=gcc COMPILER=g++ CXXSTD=03,11 Job 0", "g++", packages="", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': 'b6589fc6ab'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11 Job 1", "g++-4.7", packages="g++-4.7", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.7', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': '356a192b79'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11 Job 2", "g++-4.8", packages="g++-4.8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.8', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': 'da4b9237ba'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11 Job 3", "g++-4.9", packages="g++-4.9", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.9', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': '77de68daec'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z Job 4", "g++-5", packages="g++-5", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '1b64538924'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z Job 5", "g++-6", packages="g++-6", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'ac3478d69a'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17 Job 6", "g++-7", packages="g++-7", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '03,11,14,17', 'DRONE_JOB_UUID': 'c1dfd96eea'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=03,11 Job 7", "clang++", packages="", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': '902ba3cda1'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03, Job 8", "clang++-3.5", packages="clang-3.5 libstdc++-4.9-dev", llvm_os="precise", llvm_ver="3.5", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.5', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'fe5dbbcea5'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03, Job 9", "clang++-3.6", packages="clang-3.6", llvm_os="precise", llvm_ver="3.6", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.6', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '0ade7c2cf9'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03, Job 10", "clang++-3.7", packages="clang-3.7", llvm_os="precise", llvm_ver="3.7", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.7', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'b1d5781111'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03, Job 11", "clang++-3.8", packages="clang-3.8 libstdc++-4.9-dev", llvm_os="precise", llvm_ver="3.8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.8', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '17ba079149'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03, Job 12", "clang++-3.9", packages="clang-3.9 libstdc++-4.9-dev", llvm_os="precise", llvm_ver="3.9", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.9', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '7b52009b64'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03, Job 13", "clang++-4.0", packages="clang-4.0", llvm_os="trusty", llvm_ver="4.0", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'bd307a3ec3'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03, Job 14", "clang++-5.0", packages="clang-5.0", llvm_os="trusty", llvm_ver="5.0", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'fa35e19212'}, globalenv=globalenv),
+  osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,1 Job 15", "clang++", packages="", buildtype="boost", buildscript="drone", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'f1abd67035'}, globalenv=globalenv),
+    ]
+
+# from https://github.com/boostorg/boost-ci
+load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx")
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+# Copyright 2020 Rene Rivera, Sam Darwin
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+set -e
+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
+
+if [ "$DRONE_JOB_BUILDTYPE" == "boost" ]; then
+
+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/optional
+python tools/boostdep/depinst/depinst.py optional
+./bootstrap.sh
+./b2 headers
+
+echo '==================================> SCRIPT'
+
+echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+./b2 libs/optional/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+fi
@@ -0,0 +1,614 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+      - feature/**
+
+env:
+  UBSAN_OPTIONS: print_stacktrace=1
+
+jobs:
+  posix:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: gcc-4.8
+            cxxstd: "03,11"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: g++-4.8-multilib
+            address-model: 32,64
+          - toolset: gcc-5
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: g++-5-multilib
+            address-model: 32,64
+          - toolset: gcc-6
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: g++-6-multilib
+            address-model: 32,64
+          - toolset: gcc-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: g++-7-multilib
+            address-model: 32,64
+          - toolset: gcc-8
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-8-multilib
+            address-model: 32,64
+          - toolset: gcc-9
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-9-multilib
+            address-model: 32,64
+          - toolset: gcc-10
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: g++-10-multilib
+            address-model: 32,64
+          - toolset: gcc-11
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-22.04
+            install: g++-11-multilib
+            address-model: 32,64
+          - toolset: gcc-12
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-22.04
+            install: g++-12-multilib
+            address-model: 32,64
+          - toolset: gcc-13
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-24.04
+            install: g++-13-multilib
+            address-model: 32,64
+          - toolset: clang
+            compiler: clang++-3.9
+            cxxstd: "03,11,14"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: clang-3.9
+          - toolset: clang
+            compiler: clang++-4.0
+            cxxstd: "03,11,14"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: clang-4.0
+          - toolset: clang
+            compiler: clang++-5.0
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install: clang-5.0
+          - toolset: clang
+            compiler: clang++-6.0
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-6.0
+          - toolset: clang
+            compiler: clang++-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-7
+          - toolset: clang
+            compiler: clang++-8
+            cxxstd: "03,11,14,17"
+            os: ubuntu-20.04
+            install: clang-8
+          - toolset: clang
+            compiler: clang++-9
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+            install: clang-9
+          - toolset: clang
+            compiler: clang++-10
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-11
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-12
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-13
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-13
+          - toolset: clang
+            compiler: clang++-14
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-14
+          - toolset: clang
+            compiler: clang++-15
+            cxxstd: "03,11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
+            install: clang-15
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-24.04
+            install: clang-16
+          - toolset: clang
+            compiler: clang++-17
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-24.04
+            install: clang-17
+          - toolset: clang
+            cxxstd: "03,11,14,17,20,2b"
+            os: macos-13
+
+    runs-on: ${{matrix.os}}
+    container:
+      image: ${{matrix.container}}
+      volumes:
+        - /node20217:/node20217:rw,rshared
+        - ${{ startsWith(matrix.container, 'ubuntu:1') && '/node20217:/__e/node20:ro,rshared' || ' ' }}
+
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+      - name: Setup container environment
+        if: matrix.container
+        run: |
+          apt-get update
+          apt-get -y install sudo python3 git g++ curl
+          if [[ "${{matrix.container}}" == "ubuntu:1"* ]]; then
+            # Node 20 doesn't work with Ubuntu 16/18  glibc: https://github.com/actions/checkout/issues/1590
+            curl -sL https://archives.boost.io/misc/node/node-v20.9.0-linux-x64-glibc-217.tar.xz | tar -xJ --strip-components 1 -C /node20217
+          fi
+
+      - uses: actions/checkout@v4
+
+      - name: Install packages
+        if: matrix.install
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python3 tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+          ./bootstrap.sh
+          ./b2 -d0 headers
+
+      - name: Create user-config.jam
+        if: matrix.compiler
+        run: |
+          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
+
+      - name: Run tests
+        run: |
+          cd ../boost-root
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} variant=debug,release
+
+  windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: msvc-14.0
+            cxxstd: 14,latest
+            addrmd: 32,64
+            os: windows-2019
+          - toolset: msvc-14.2
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2019
+          - toolset: msvc-14.3
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: clang-win
+            cxxstd: "14,17,20,latest"
+            addrmd: 32,64
+            os: windows-2022
+          - toolset: gcc
+            cxxstd: "03,11,14,17,2a"
+            addrmd: 64
+            os: windows-2019
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+          cmd /c bootstrap
+          b2 -d0 headers
+
+      - name: Run tests
+        shell: cmd
+        run: |
+          cd ../boost-root
+          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release embed-manifest-via=linker
+
+  posix-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-12
+          - os: macos-13
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Use library with add_subdirectory
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-12
+          - os: macos-13
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
+
+      - name: Install
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+          - os: ubuntu-22.04
+          - os: macos-12
+          - os: macos-13
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
+
+      - name: Build tests
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests
+
+      - name: Run tests
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error
+
+  windows-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Use library with add_subdirectory (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use library with add_subdirectory (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+
+      - name: Install (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Debug
+
+      - name: Install (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Release
+
+      - name: Use the installed library (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use the installed library (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DBUILD_TESTING=ON ..
+
+      - name: Build tests (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests --config Debug
+
+      - name: Run tests (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Build tests (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests --config Release
+
+      - name: Run tests (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Release
@@ -0,0 +1,201 @@
+# Copyright 2016, 2017 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+
+    - os: linux
+      compiler: g++-4.7
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.8
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+    - os: linux
+      compiler: g++-4.9
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
+
+    - os: linux
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      compiler: clang++-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      dist: trusty
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      dist: trusty
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - cp -r $TRAVIS_BUILD_DIR/* libs/optional
+  - python tools/boostdep/depinst/depinst.py optional
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 libs/optional/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always
@@ -0,0 +1,33 @@
+# Generated by `boostdep --cmake optional`
+# Copyright 2020, 2021 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.20)
+
+project(boost_optional VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_optional INTERFACE)
+add_library(Boost::optional ALIAS boost_optional)
+
+target_include_directories(boost_optional INTERFACE include)
+if(NOT CMAKE_VERSION VERSION_LESS "3.19")
+  file(GLOB_RECURSE headers include/*.hpp)
+  target_sources(boost_optional PRIVATE ${headers})
+endif()
+
+target_link_libraries(boost_optional
+  INTERFACE
+    Boost::assert
+    Boost::config
+    Boost::core
+    Boost::throw_exception
+    Boost::type_traits
+)
+target_compile_features(boost_optional INTERFACE cxx_std_11)
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()
@@ -0,0 +1,15 @@
+optional
+========
+
+A library for representing optional (nullable) objects in C++.
+
+```cpp
+optional<int> readInt(); // this function may return either an int or a not-an-int
+
+if (optional<int> oi = readInt()) // did I get a real int
+  cout << "my int is: " << *oi;   // use my int
+else
+  cout << "I have no int";
+```
+
+For more information refer to the documentation provided with this library.
@@ -0,0 +1,23 @@
+# 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/throw_exception//boost_throw_exception
+    /boost/type_traits//boost_type_traits ;
+
+project /boost/optional ;
+
+explicit
+    [ alias boost_optional : : : : <library>$(boost_dependencies) <include>include ]
+    [ alias all : boost_optional test ]
+    ;
+
+call-if : boost-library optional
+    ;
@@ -0,0 +1,113 @@
+[library Boost.Optional
+    [quickbook 1.7]
+    [authors [Cacciola Carballal, Fernando Luis]]
+    [copyright 2003-2007 Fernando Luis Cacciola Carballal]
+    [copyright 2014-2026 Andrzej Krzemieński]
+    [category miscellaneous]
+    [id optional]
+    [dirname optional]
+    [purpose
+        Discriminated-union wrapper for optional values
+    ]
+    [source-mode c++]
+    [license
+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])
+    ]
+]
+
+[/ Macros will be used for links so we have a central place to change them ]
+
+
+[/ Cited Boost resources ]
+
+[def __BOOST_VARIANT__ [@../../../variant/index.html Boost.Variant]]
+[def __BOOST_TUPLE__ [@../../../tuple/index.html Boost.Tuple]]
+[def __BOOST_TRIBOOL__ [@../../../../doc/html/tribool.html boost::tribool]]
+
+[def __OPTIONAL_POINTEE__ [@../../../utility/OptionalPointee.html `OptionalPointee`]]
+[def __COPY_CONSTRUCTIBLE__ [@../../../utility/CopyConstructible.html `CopyConstructible`]]
+[def __MOVE_CONSTRUCTIBLE__ `MoveConstructible`]
+[def __FUNCTION_EQUAL_POINTEES__ [@../../../utility/OptionalPointee.html#equal `equal_pointees()`]]
+[def __FUNCTION_LESS_POINTEES__ [@../../../utility/OptionalPointee.html#less `less_pointees()`]]
+
+[def __IN_PLACE_FACTORY_HPP__ [@../../../../boost/utility/in_place_factory.hpp in_place_factory.hpp]]
+[def __TYPED_IN_PLACE_FACTORY_HPP__ [@../../../../boost/utility/typed_in_place_factory.hpp typed_in_place_factory.hpp]]
+
+[/ Other web resources ]
+
+[def __HASKELL__ [@http://www.haskell.org/ Haskell]]
+[def __STD_DEFAULT_CONSTRUCTIBLE__ [@https://en.cppreference.com/w/cpp/named_req/DefaultConstructible `DefaultConstructible`]]
+[def __STD_LESS_THAN_COMPARABLE__ [@https://en.cppreference.com/w/cpp/named_req/LessThanComparable `LessThanComparable`]]
+[def __STD_EQUALITY_COMPARABLE__ [@https://en.cppreference.com/w/cpp/named_req/EqualityComparable `EqualityComparable`]]
+[def __SGI_GENERATOR__ [@http://www.rrsd.com/software_development/stl/stl/Generator.html `Generator`]]
+
+
+[/ Icons ]
+
+[def __SPACE__ [$images/space.png]]
+[def __GO_TO__ [$images/R.png]]
+
+[/ Common terms ]
+
+[def __UB__ [@https://en.cppreference.com/w/cpp/language/ub ['undefined behavior]]]
+
+
+[section Introduction]
+Class template `optional` is a wrapper for representing 'optional' (or 'nullable')
+objects who may not (yet) contain a valid value. Optional objects offer full value semantics;
+they are good for passing by value and usage inside STL containers. This is a header-only C++11 library.
+
+[heading Problem]
+Suppose we want to read a parameter from a config file which represents some integral value, let's call it `"MaxValue"`. It is possible that this parameter is not specified; such situation is no error. It is valid to not specify the parameter and in that case the program is supposed to behave slightly differently. Also, suppose that any possible value of type `int` is a valid value for `"MaxValue"`, so we cannot just use `-1` to represent the absence of the parameter in the config file.
+
+[heading Solution]
+
+This is how you solve it with `boost::optional`:
+
+    #include <boost/optional.hpp>
+
+    boost::optional<int> getConfigParam(std::string name);  // return either an int or a `not-an-int`
+
+    int main()
+    {
+      if (boost::optional<int> oi = getConfigParam("MaxValue")) // did I get a real int?
+        runWithMax(*oi);                                        // use my int
+      else
+        runWithNoMax();
+    }
+
+[endsect]
+
+[include 01_quick_start.qbk]
+[section:design Design Overview and Rationale]
+[include 11_development.qbk]
+[include 12_relational_operators.qbk]
+[include 13_convenience.qbk]
+[include 15_io.qbk]
+[include 16_optional_references.qbk]
+[include 17_in_place_factories.qbk]
+[include 18_gotchas.qbk]
+[include 19_exception_safety.qbk]
+[include 1A_type_requirements.qbk]
+[endsect]
+[section:reference Reference]
+[include 21_ref_none.qbk]
+[include 22_ref_bad_optional_access.qbk]
+[include 23_ref_optional_io.qbk]
+[include 24_ref_optional_fwd.qbk]
+[section Header <boost/optional/optional.hpp>]
+[include 27_ref_optional_synopsis.qbk]
+[include 28_ref_optional_semantics.qbk]
+[endsect]
+[include 29_ref_optional_convenience.qbk]
+[endsect]
+[section:advice Advice]
+[include 31_when_to_use.qbk]
+[include 32_on_performance.qbk]
+[endsect]
+[include 90_dependencies.qbk]
+[include 91_comparison_with_std.qbk]
+[include 92_relnotes.qbk]
+[include 93_acknowledgments.qbk]
@@ -0,0 +1,194 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+    Copyright (c) 2014 Andrzej Krzemienski
+
+    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)
+]
+
+
+[section Quick Overview]
+
+[section Optional return values]
+
+Let's write and use a converter function that converts a `std::string` to an `int`.
+It is possible that for a given string (e.g. `"cat"`) there exists no value of type
+`int` capable of representing the conversion result. We do not consider such
+situation an error. We expect that the converter can be used only to check if
+the conversion is possible. A natural signature for this function can be:
+
+    #include <boost/optional.hpp>
+    boost::optional<int> convert(const std::string& text);
+
+All necessary functionality can be included with one header `<boost/optional.hpp>`.
+The above function signature means that the function can either return a value
+of type `int` or a flag indicating that no value of `int` is available.
+This does not indicate an error. It is like one additional value of `int`.
+This is how we can use our function:
+
+    const std::string& text = /*... */;
+    boost::optional<int> oi = convert(text); // move-construct
+    if (oi)                                  // contextual conversion to bool
+      int i = *oi;                           // operator*
+
+In order to test if `optional` contains a value, we use the contextual conversion to type `bool`. Because of this we can combine the initialization of the optional object and the test into one instruction:
+
+    if (boost::optional<int> oi = convert(text))
+      int i = *oi;
+
+We extract the contained value with `operator*` (and with `operator->` where it makes sense). An attempt to extract the contained value of an uninitialized optional object is an ['undefined behaviour] (UB). This implementation guards the call with `BOOST_ASSERT`. Therefore you should be sure that the contained value is there before extracting. For instance, the following code is reasonably UB-safe:
+
+    int i = *convert("100");
+
+This is because we know that string value `"100"` converts to a valid value of `int`. If you do not like this potential UB, you can use an alternative way of extracting the contained value:
+
+    try {
+      int j = convert(text).value();
+    }
+    catch (const boost::bad_optional_access&) {
+      // deal with it
+    }
+
+This version throws an exception upon an attempt to access a nonexistent contained value. If your way of dealing with the missing value is to use some default, like `0`, there exists a yet another alternative:
+
+    int k = convert(text).value_or(0);
+
+This uses the `atoi`-like approach to conversions: if `text` does not represent an integral number just return `0`. Finally, you can provide a callback to be called when trying to access the contained value fails:
+
+    int fallback_to_default()
+    {
+      cerr << "could not convert; using -1 instead" << endl;
+      return -1;
+    }
+
+    int l = convert(text).value_or_eval(fallback_to_default);
+
+This will call the provided callback and return whatever the callback returns. The callback can have side effects: they will only be observed when the optional object does not contain a value.
+
+Now, let's consider how function `convert` can be implemented.
+
+    boost::optional<int> convert(const std::string& text)
+    {
+      std::stringstream s(text);
+      int i;
+      if ((s >> i) && s.get() == std::char_traits<char>::eof())
+        return i;
+      else
+        return boost::none;
+    }
+
+Observe the two return statements. `return i` uses the converting constructor that can create `optional<T>` from `T`. Thus constructed optional object is initialized and its value is a copy of `i`. The other return statement uses another converting constructor from a special tag `boost::none`. It is used to indicate that we want to create an uninitialized optional object.
+
+[endsect]
+
+[section Optional automatic variables]
+
+We could write function `convert` in a slightly different manner, so that it has a single `return`-statement:
+
+    boost::optional<int> convert(const std::string& text)
+    {
+      boost::optional<int> ans;
+      std::stringstream s(text);
+      int i;
+      if ((s >> i) && s.get() == std::char_traits<char>::eof())
+        ans = i;
+
+      return ans;
+    }
+
+The default constructor of `optional` creates an uninitialized optional object. Unlike with `int`s you cannot have an `optional<int>` in an indeterminate state. Its state is always well defined. Instruction `ans = i` initializes the optional object. It uses the 'mixed' assignment from `int`. In general, for `optional<T>`, when an assignment from `T` is invoked, it can do two things. If the optional object is not initialized (our case here), it initializes the contained value using `T`'s copy constructor. If the optional object is already initialized, it assigns the new value to it using `T`'s copy assignment.
+[endsect]
+
+[section Optional data members]
+
+Suppose we want to implement a ['lazy load] optimization. This is because we do not want to perform an expensive initialization of our `Resource` until (if at all) it is really used. We can do it this way:
+
+    class Widget
+    {
+      mutable boost::optional<const Resource> resource_;
+
+    public:
+      Widget() {}
+
+      const Resource& getResource() const // not thread-safe
+      {
+        if (resource_ == boost::none)
+            resource_.emplace("resource", "arguments");
+
+        return *resource_;
+      }
+    };
+
+`optional`'s default constructor creates an uninitialized optional. No call to `Resource`'s default constructor is attempted. `Resource` doesn't have to be __STD_DEFAULT_CONSTRUCTIBLE__. In function `getResource` we first check if `resource_` is initialized. This time we do not use the contextual conversion to `bool`, but a comparison with `boost::none`. These two ways are equivalent. Function `emplace` initializes the optional in-place by perfect-forwarding the arguments to the constructor of `Resource`. No copy- or move-construction is involved here. `Resource` doesn't even have to be `MoveConstructible`.
+
+
+[endsect]
+
+[section Storage in containers]
+
+Suppose you want to ask users to choose some number (an `int`). One of the valid responses is to choose nothing, which is represented by an uninitialized `optional<int>`. You want to make a histogram showing how many times each choice was made. You can use an `std::map`:
+
+    std::map<boost::optional<int>, int> choices;
+
+    for (int i = 0; i < LIMIT; ++i) {
+      boost::optional<int> choice = readChoice();
+      ++choices[choice];
+    }
+
+This works because `optional<T>` is __STD_LESS_THAN_COMPARABLE__ whenever `T` is __STD_LESS_THAN_COMPARABLE__.
+In this case the state of being uninitialized is treated as a yet another value of `T`,
+which is compared less than any value of `T`.
+`optional<T>` can also be stored as a key in `std::unordered_map` and `std::unordered_set`
+as it provides specializations for `std::hash`.
+[endsect]
+
+[section Monadic interface]
+
+The monadic interface of `optional` allows the application of functions
+to optional values without resorting to the usage of explicit `if`-statements.
+
+Function `map` takes a function mapping type `T` onto type `U` and maps an `optional<T>`
+onto an `optional<U>` using the provided function.
+
+    int length(const string& s){ return s.size(); };
+
+    optional<string> null{}, thin{""}, word{"word"};
+    assert (null.map(length) == none);
+    assert (thin.map(length) == 0);
+    assert (word.map(length) == 4);
+
+Function `flat_map` is similar, but it requires the function to return an
+`optional<V>` for some type `V`. This `optional<V>` becomes the return type of
+`flat_map`.
+
+    optional<char> first_char(const string& s) {
+      if (s.empty()) return none;
+      else           return s[0];
+    };
+
+    optional<string> null{}, thin{""}, word{"word"};
+    assert (null.flat_map(first_char) == none);
+    assert (thin.flat_map(first_char) == none);
+    assert (word.flat_map(first_char) == 'w');
+
+These functions can be combined in one expression reflecting a chain of computations:
+
+    auto get_contents(path p) -> optional<string>;
+    auto trim(string) -> string;
+    auto length(string) -> int;
+
+    auto trimmed_size_of(optional<path> p) -> int
+    {
+      return p.flat_map(get_contents)
+              .map(trim)
+              .map(length)
+              .value_or(0);
+    }
+
+
+[endsect]
+
+[endsect]
@@ -0,0 +1,142 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+    Copyright (c) 2024 andrzej Krzemieński
+
+    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)
+]
+
+[section Design Goals]
+
+In C++ you can create an automatic object of a scalar type, and manipulate it,
+without assigning it the initial value.
+
+  {
+    int i; // indeterminate value
+    populate(&i);
+    cout << i;
+  }
+
+Such an object is said to have ['indeterminate value]. If you subsequently
+assign a proper value to the object, all is fine; but if the program tries to
+read an indeterminate value, this is ['undefined behavior'], and since C++26
+this is ['erroneous behavior].
+In any case, the program is now likely to do something else than what the
+programmer intended. In case you have some object `i`, and you do not know if it
+has an indeterminate value, or a normal, intended, value, there is no way to
+check it, because the checking would require reading the value.
+
+This is one of the primary problems that `optional` was intended to address: so
+that you may have a type that knows whether it has been assigned a proper value,
+and it can tell you that if requested.
+
+In the case of type `int` the internal representation of such a class could be:
+
+  class OptionalInt
+  {
+    bool _has_value = false;
+    int _value;
+  };
+
+In the general case, the internal representation is something equivalent to:
+
+  template <typename T>
+  class Optional
+  {
+    bool _has_value = false;
+    alignas(T) char _value [sizeof(T)];
+  };
+
+or:
+
+  template <typename T>
+  class Optional
+  {
+    bool _has_value = false;
+    union {
+      T         _value;
+      DummyType _non_value;
+    };
+  };
+
+Next, because we need to pass around these "optional" `int`s as normal `int`s,
+like returning them from functions, when copying, we need to copy `_has_value`,
+which indicates whether we have the value or not, and, if we do have value, and
+only then, to also copy `_value`.
+
+This means that our type requires ['deep copy] semantics.
+
+[note
+This is a C++ equivalent of a
+[@https://hackage.haskell.org/package/base-4.20.0.1/docs/Data-Maybe.html Maybe]
+monad in [@http://www.haskell.org/ Haskell].
+]
+
+[endsect]
+
+[section:iface Interface Design]
+One part of the interface is for modifying and setting the initial state of
+the object. It has to be able to say that
+
+* we want to store a specific value of type `T`,
+* we want to store no value.
+
+The default constructor stores no value. Other than that, we require that
+the assignment and construction from a `T` reflects the former, while assignment
+and construction of a special ['tag] value `none` reflect the latter need.
+
+  optional<int> o1;        // contains no value
+  optional<int> o2 = 2;    // contains value 2
+  optional<int> o3 = none; // contains no value
+
+  o1 = 1;    // assign value 1
+  o2 = none; // assign a no-value
+  o3 = {};   // assign a no-value
+
+[heading Inspecting the State]
+
+Inspecting the state of an optional object requires two steps:
+
+* check if we have the value or not,
+* if so, read the stored value.
+
+This 'procedure' is characteristic of inspecting pointers in C++, therefore the
+pointer-like syntax was chosen to represent this.
+
+  void inspect (optional<string> os)
+  {
+    if (os) {               // contextual conversion to `bool`
+      read_string(*os);     // `operator*` to access the stored value
+      read_int(os->size()); // `operator->` as shortcut for accessing members
+    }
+  }
+
+Also, similarly to pointers, if you access the value when it is not there,
+you trigger __UB__.
+This library detects and reports it via
+[@../../../assert/assert.html `BOOST_ASSERT()`]. This common property of
+pointers and `optional<>` has been formalized into a concept __OPTIONAL_POINTEE__.
+
+However, there is also the counter-intuitive part. All pointers embed ['shallow-copy]
+semantics: when you copy a pointer, the pointed-to object stays at the same location
+and you can access it via either of the pointers. This is unlike optional objects
+where the represented value is copied along.
+
+[caution
+Optional objects are not pointers.
+]
+
+There is a similar difference in relational operations: they compare deeply for
+`optional<>`, while they are shallow for pointers.
+
+[note
+When you need a deep relational operations that work uniformly for `optional<>`
+and pointers in generic contexts, use functions
+[@../../../utility/OptionalPointee.html#equal `equal_pointees()`] and
+[@../../../utility/OptionalPointee.html#less `less_pointees()`].
+]
+
+[endsect]
@@ -0,0 +1,37 @@
+
+[section Relational operators]
+
+Type `optional<T>` is __STD_EQUALITY_COMPARABLE__ whenever `T` is __STD_EQUALITY_COMPARABLE__. Two optional objects containing a value compare in the same way as their contained values. The uninitialized state of `optional<T>` is treated as a distinct value, equal to itself, and unequal to any value of type `T`:
+
+    boost::optional<int> oN = boost::none;
+    boost::optional<int> o0 = 0;
+    boost::optional<int> o1 = 1;
+
+    assert(oN != o0);
+    assert(o1 != oN);
+    assert(o0 != o1);
+    assert(oN == oN);
+    assert(o0 == o0);
+
+The converting constructor from `T` as well as from `boost::none` implies the existence and semantics of the mixed comparison between `T` and `optional<T>` as well as between `none_t` and `optional<T>`:
+
+    assert(oN != 0);
+    assert(o1 != boost::none);
+    assert(o0 != 1);
+    assert(oN == boost::none);
+    assert(o0 == 0);
+
+This mixed comparison has a practical interpretation, which is occasionally useful:
+
+    boost::optional<int> choice = ask_user();
+    if (choice == 2)
+        start_procedure_2();
+
+In the above example, the meaning of the comparison is 'user chose number 2'. If user chose nothing, he didn't choose number 2.
+
+In case where `optional<T>` is compared to `none`, it is not required that `T` be __STD_EQUALITY_COMPARABLE__.
+
+In a similar manner, type `optional<T>` is __STD_LESS_THAN_COMPARABLE__ whenever `T` is __STD_LESS_THAN_COMPARABLE__. The optional object containing no value is compared less than any value of `T`. To illustrate this, if the default ordering of `size_t` is {`0`, `1`, `2`, ...}, the default ordering of `optional<size_t>` is {`boost::none`, `0`, `1`, `2`, ...}. This order does not have a practical interpretation. The goal is to have any semantically correct default ordering in order for `optional<T>` to be usable in ordered associative containers (wherever `T` is usable).
+
+Mixed relational operators are the only case where the contained value of an optional object can be inspected without the usage of value accessing function (`operator*`, `value`, `value_or`).
+[endsect]
@@ -0,0 +1,102 @@
+
+[section Convenience Conversions and Deductions]
+
+Unlike `std::optional`, `boost::optional` does not offer a number of
+"convenience" converting constructors, mixed relational operations and
+deductions for class template parameters.
+
+  std::optional oi = 1;                 // OK
+
+  std:string_view sv = "hi";
+  std::optional<std::string> os = sv;   // OK
+  os == sv;                             // OK
+
+  std::optional<std::string> osv;
+  std::optional<std::string> os2 = osv; // OK
+  os2 == osv;                           // OK
+
+They are practical, and sometimes stem from the argument for consistency:
+if `(optT && *optT == u)` works then `(optT == u)` should also work.
+
+However, these intelligent convenience functions sometimes produce results
+that are counter to the programmer intentions and produce silent bugs.
+
+Consider a more complicated example:
+
+  Threshold th = /*...*/;
+  std::optional o = th;
+  assert (o);
+
+In this code, can we expect that thus initialized `optional` contains a value?
+The answer is: it depends on the type of `Threshold`. It can be defined as:
+
+  using Threshold = std::optional<int>;
+
+And then the assertion will fire. This is because in this case the intelligence
+decides that since we already have an optional, the additional wrapping into
+a yet another optional is unnecessary.
+
+If we explicitly specify the template type, the situation doesn't get less
+complicated.
+
+  Threshold th;
+  std::optional<Threshold> o = th;
+  assert(o);
+
+Can this assertion fire? Now we have two competing constructors:
+
+  template <typename U>
+  optional(U const&);
+
+  template <typename U>
+  optional(optional<U> const&);
+
+Which one will get chosen? Actually, we are lucky, and it is going to be the
+first one due to concept tricks. But let's try a different example:
+
+  Threshold th;
+  std::optional<Threshold> o = th;
+  assert(o);
+  assert(o == th);
+
+Here, the first assertion passes, but the second one fires. This is because
+there are two competing overloads of the comparison operator:
+
+  template <typename T, typename U>
+  bool operator==(optional<T> const&, U const&);
+
+  template <typename T, typename U>
+  bool operator==(optional<T> const&, optional<U> const&);
+
+And this time there is no concept trickery, so the second overload is chosen,
+and gives different results: we are comparing an optional object `th`, which does
+not contain a value, with an optional object `o` which does contain a value.
+
+This problem -- that the operations compile, but have runtime behavior counter
+to programmer's intuition -- gains new significance with the introduction of
+concepts to C++.
+
+  static_assert(std::equality_comparable_with<std::optional<Threshold>, Threshold>);
+
+Concepts have both syntactic constraints and semantic constraints. Syntactic
+constraints are statically checked by the compiler. For semantic constraints,
+functions that use the concept trust the programmer that these constraints are
+met, and if not, this is __UB__.
+
+These are problems with `std::optional`. `boost::optional` doesn't have these
+problems, because it does not offer the said convenience operations.
+
+The design principle for `boost::optional` is not to offer functionality that
+nicely deduces the programmer intentions in 95% of the cases, and in the remaining
+5% renders effects counter to programmer expectations.
+
+Instead, this library recommends using a more verbose syntax that works in 100%
+of the cases:
+
+  Threshold th;
+  auto o = boost::make_potional(th);   // *always* add a new layer of optionality
+
+  return boost::equal_pointees(o, th); // *always* unpack optionals for comparison
+  return o && *o == th;    // *always* treat the right-hand side argument as value
+
+[endsect]
@@ -0,0 +1,37 @@
+
+[section IO operators]
+
+It is possible to use `optional<T>` with IO streams, provided that `T` can be used with streams. IOStream operators are defined in a separate header.
+
+``
+#include <iostream>
+#include <boost/optional/optional_io.hpp>
+
+int main()
+{
+  boost::optional<int> o1 = 1, oN = boost::none;
+  std::cout << o1;
+  std::cin >> oN;
+}
+``
+
+The current implementation does not guarantee any particular output. What it guarantees is that if streaming out and then back in `T` gives the same value, then streaming out and then back in `optional<T>` will also give back the same result:
+
+``
+#include <cassert>
+#include <sstream>
+#include <boost/optional/optional_io.hpp>
+
+int main()
+{
+  boost::optional<int> o1 = 1, oN = boost::none;
+  boost::optional<int> x1, x2;
+  std::stringstream s;
+  s << o1 << oN;
+  s >> x1 >> x2;
+  assert (o1 == x1);
+  assert (oN == x2);
+}
+``
+
+[endsect]
@@ -0,0 +1,130 @@
+
+[section Optional references]
+
+[section Overview]
+
+This library allows the template parameter `T` to be of reference type:
+`T&`, and to some extent, `T const&`.
+
+However, since references are not real objects some restrictions apply and
+some operations are not available in this case:
+
+* Converting constructors
+* Converting assignment
+* InPlace construction
+* InPlace assignment
+* Value-access via pointer
+
+Also, even though `optional<T&>` treats it wrapped pseudo-object much as
+a real value, a true real reference is stored so aliasing will occur:
+
+* Copies of `optional<T&>` will copy the references but all these references
+will nonetheless refer to the same object.
+* Value-access will actually provide access to the referenced object
+rather than the reference itself.
+
+[caution
+On compilers that do not conform to Standard C++ rules of reference binding,
+some operations on optional references are disabled in order to prevent subtle
+bugs. For more details see
+[link optional_reference_binding Dependencies and Portability section].
+]
+
+[heading Rvalue references]
+
+Rvalue references and lvalue references to const have the ability in C++ to extend the life time of a temporary they bind to. Optional references do not have this capability, therefore to avoid surprising effects it is not possible to initialize an optional references from a temporary. Optional rvalue references are disabled altogether. Also, the initialization and assignment of an optional reference to const from rvalue reference is disabled.
+
+    const int& i = 1;            // legal
+    optional<const int&> oi = 1; // illegal
+
+[endsect]
+
+
+[#optional_ref_rebinding_semantics]
+[section Rebinding semantics for assignment of optional references]
+
+If you assign to an ['uninitialized ] `optional<T&>` the effect is to bind (for
+the first time) to the object. Clearly, there is no other choice.
+
+    int x = 1 ;
+    int& rx = x ;
+    optional<int&> ora ;
+    optional<int&> orb(x) ;
+    ora = orb ; // now 'ora' is bound to 'x' through 'rx'
+    *ora = 2 ; // Changes value of 'x' through 'ora'
+    assert(x==2);
+
+If you assign to a bare C++ reference, the assignment is forwarded to the
+referenced object; its value changes but the reference is never rebound.
+
+    int a = 1 ;
+    int& ra = a ;
+    int b = 2 ;
+    int& rb = b ;
+    ra = rb ; // Changes the value of 'a' to 'b'
+    assert(a==b);
+    b = 3 ;
+    assert(ra!=b); // 'ra' is not rebound to 'b'
+
+Now, if you assign to an ['initialized ] `optional<T&>`, the effect is to
+[*rebind] to the new object instead of assigning the referee. This is unlike
+bare C++ references.
+
+    int a = 1 ;
+    int b = 2 ;
+    int& ra = a ;
+    int& rb = b ;
+    optional<int&> ora(ra) ;
+    optional<int&> orb(rb) ;
+    ora = orb ; // 'ora' is rebound to 'b'
+    *ora = 3 ; // Changes value of 'b' (not 'a')
+    assert(a==1);
+    assert(b==3);
+
+[heading Rationale]
+
+Rebinding semantics for the assignment of ['initialized ] `optional` references has
+been chosen to provide [*consistency among initialization states] even at the
+expense of lack of consistency with the semantics of bare C++ references.
+It is true that `optional<U>` strives to behave as much as possible as `U`
+does whenever it is initialized; but in the case when `U` is `T&`, doing so would
+result in inconsistent behavior w.r.t to the lvalue initialization state.
+
+Imagine `optional<T&>` forwarding assignment to the referenced object (thus
+changing the referenced object value but not rebinding), and consider the
+following code:
+
+    optional<int&> a = get();
+    int x = 1 ;
+    int& rx = x ;
+    optional<int&> b(rx);
+    a = b ;
+
+What does the assignment do?
+
+If `a` is ['uninitialized], the answer is clear: it binds to `x` (we now have
+another reference to `x`).
+But what if `a` is already ['initialized]? it would change the value of the
+referenced object (whatever that is); which is inconsistent with the other
+possible case.
+
+If `optional<T&>` would assign just like `T&` does, you would never be able to
+use Optional's assignment without explicitly handling the previous
+initialization state unless your code is capable of functioning whether
+after the assignment, `a` aliases the same object as `b` or not.
+
+That is, you would have to discriminate in order to be consistent.
+
+If in your code rebinding to another object is not an option, then it is very
+likely that binding for the first time isn't either. In such case, assignment
+to an ['uninitialized ] `optional<T&>` shall be prohibited. It is quite possible
+that in such a scenario it is a precondition that the lvalue must be already
+initialized. If it isn't, then binding for the first time is OK
+while rebinding is not which is IMO very unlikely.
+In such a scenario, you can assign the value itself directly, as in:
+
+    assert(!!opt);
+    *opt=value;
+
+[endsect]
+[endsect]
@@ -0,0 +1,141 @@
+
+[section:in_place_factories In-Place Factories][#boost_optional_factories]
+
+One of the typical problems with wrappers and containers is that their
+interfaces usually provide an operation to initialize or assign the
+contained object as a copy of some other object. This not only requires the
+underlying type to be __COPY_CONSTRUCTIBLE__, but also requires the existence of
+a fully constructed object, often temporary, just to follow the copy from:
+
+    struct X
+    {
+        X ( int, std::string ) ;
+    } ;
+
+    class W
+    {
+        X wrapped_ ;
+
+        public:
+
+        W ( X const& x ) : wrapped_(x) {}
+    } ;
+
+    void foo()
+    {
+        // Temporary object created.
+        W ( X(123,"hello") ) ;
+    }
+
+A solution to this problem is to support direct construction of the
+contained object right in the container's storage.
+In this scheme, the user only needs to supply the arguments to the
+constructor to use in the wrapped object construction.
+
+    class W
+    {
+        X wrapped_ ;
+
+        public:
+
+        W ( X const& x ) : wrapped_(x) {}
+        W ( int a0, std::string a1) : wrapped_(a0,a1) {}
+    } ;
+
+    void foo()
+    {
+        // Wrapped object constructed in-place
+        // No temporary created.
+        W (123,"hello") ;
+    }
+
+A limitation of this method is that it doesn't scale well to wrapped
+objects with multiple constructors nor to generic code were the constructor
+overloads are unknown.
+
+The solution presented in this library is the family of [*InPlaceFactories]
+and [*TypedInPlaceFactories].
+These factories are a family of classes which encapsulate an increasing
+number of arbitrary constructor parameters and supply a method to construct
+an object of a given type using those parameters at an address specified by
+the user via placement new.
+
+For example, one member of this family looks like:
+
+    template<class T,class A0, class A1>
+    class TypedInPlaceFactory2
+    {
+        A0 m_a0 ; A1 m_a1 ;
+
+        public:
+
+        TypedInPlaceFactory2( A0 const& a0, A1 const& a1 ) : m_a0(a0), m_a1(a1) {}
+
+        void construct ( void* p ) { new (p) T(m_a0,m_a1) ; }
+     } ;
+
+A wrapper class aware of this can use it as:
+
+    class W
+    {
+        X wrapped_ ;
+
+        public:
+
+        W ( X const& x ) : wrapped_(x) {}
+        W ( TypedInPlaceFactory2 const& fac ) { fac.construct(&wrapped_) ; }
+    } ;
+
+    void foo()
+    {
+        // Wrapped object constructed in-place via a TypedInPlaceFactory.
+        // No temporary created.
+        W ( TypedInPlaceFactory2<X,int,std::string>(123,"hello")) ;
+    }
+
+The factories are divided in two groups:
+
+* [_TypedInPlaceFactories]: those which take the target type as a primary
+template parameter.
+* [_InPlaceFactories]: those with a template `construct(void*)` member
+function taking the target type.
+
+Within each group, all the family members differ only in the number of
+parameters allowed.
+
+This library provides an overloaded set of helper template functions to
+construct these factories without requiring unnecessary template parameters:
+
+    template<class A0,...,class AN>
+    InPlaceFactoryN <A0,...,AN> in_place ( A0 const& a0, ..., AN const& aN) ;
+
+    template<class T,class A0,...,class AN>
+    TypedInPlaceFactoryN <T,A0,...,AN> in_place ( T const& a0, A0 const& a0, ..., AN const& aN) ;
+
+In-place factories can be used generically by the wrapper and user as follows:
+
+    class W
+    {
+        X wrapped_ ;
+
+        public:
+
+        W ( X const& x ) : wrapped_(x) {}
+
+        template< class InPlaceFactory >
+        W ( InPlaceFactory const& fac ) { fac.template <X>construct(&wrapped_) ; }
+
+    } ;
+
+    void foo()
+    {
+        // Wrapped object constructed in-place via a InPlaceFactory.
+        // No temporary created.
+        W ( in_place(123,"hello") ) ;
+    }
+
+The factories are implemented in the headers: __IN_PLACE_FACTORY_HPP__ and __TYPED_IN_PLACE_FACTORY_HPP__
+
+[caution The support for in-place factories is deprecated. Use constructor taking `in_place_init` tag and function `.emplace()` instead.]
+
+[endsect:in_place_factories]
@@ -0,0 +1,111 @@
+[section Gotchas]
+
+[section A note about optional<bool>]
+
+`optional<bool>` should be used with special caution and consideration.
+
+First, it is functionally similar to a tristate boolean (false, maybe, true)
+—such as __BOOST_TRIBOOL__— except that in a tristate boolean, the maybe state
+[_represents a valid value], unlike the corresponding state of an uninitialized
+`optional<bool>`.
+It should be carefully considered if an `optional<bool>` instead of a `tribool`
+is really needed.
+
+Second, although `optional<>` provides a contextual conversion to `bool` in C++11,
+ this falls back to an implicit conversion on older compilers. This conversion refers
+ to the initialization state and not to the contained value. Using `optional<bool>`
+ can lead to subtle errors due to the implicit `bool` conversion:
+
+    void foo ( bool v ) ;
+    void bar()
+    {
+        optional<bool> v = try();
+
+        // The following intended to pass the value of 'v' to foo():
+        foo(v);
+        // But instead, the initialization state is passed
+        // due to a typo: it should have been foo(*v).
+    }
+
+The only implicit conversion is to `bool`, and it is safe in the sense that
+typical integral promotions don't apply (i.e. if `foo()` takes an `int`
+instead, it won't compile).
+
+Third, mixed comparisons with `bool` work differently than similar mixed comparisons between pointers and `bool`, so the results might surprise you:
+
+    optional<bool> oEmpty(none), oTrue(true), oFalse(false);
+    
+    if (oEmpty == none);  // renders true
+    if (oEmpty == false); // renders false!
+    if (oEmpty == true);  // renders false!
+     
+    if (oFalse == none);  // renders false
+    if (oFalse == false); // renders true!
+    if (oFalse == true);  // renders false
+    
+    if (oTrue == none);   // renders false
+    if (oTrue == false);  // renders false
+    if (oTrue == true);   // renders true
+
+In other words, for `optional<>`, the following assertion does not hold:
+
+    assert((opt == false) == (!opt));
+[endsect]
+
+[section Moved-from `optional`]
+
+When an optional object that contains a value is moved from (is a source of move constructor or assignment) it still contains a value and its contained value is left in a moved-from state. This can be illustrated with the following example.
+
+    optional<std::unique_ptr<int>> opi {std::make_unique<int>(1)};
+    optional<std::unique_ptr<int>> opj = std::move(opi);
+    assert (opi);
+    assert (*opi == nullptr);
+
+Quite a lot of people expect that when an object that contains a value is moved from, its contained value should be destroyed. This is not so, for performance reasons. Current semantics allow the implementation of `boost::optional<T>` to be trivially copyable when `T` is trivial.
+[endsect]
+
+[section Mixed relational comparisons]
+
+Because `T` is convertible to `optional<T>` and because `optional<T>` is __STD_LESS_THAN_COMPARABLE__ when `T` is __STD_LESS_THAN_COMPARABLE__,
+you can sometimes get an unexpected runtime result where you would rather expect a compiler error:
+
+    optional<double> Flight_plan::weight(); // sometimes no weight can be returned
+
+    bool is_aircraft_too_heavy(Flight_plan const& p)
+    {
+       return p.weight() > p.aircraft().max_weight(); // compiles!
+    }                                                 // returns false when the optional contains no value 
+
+[endsect]
+
+[section False positive with -Wmaybe-uninitialized]
+
+Sometimes on GCC compilers below version 5.1 you may get an -Wmaybe-uninitialized warning when compiling with option -02 on a perfectly valid `boost::optional` usage. For instance in this program:
+
+    #include <boost/optional.hpp>
+
+    boost::optional<int> getitem();
+
+    int main(int argc, const char *[])
+    {
+      boost::optional<int> a = getitem();
+      boost::optional<int> b;
+
+      if (argc > 0)
+        b = argc;
+
+      if (a != b)
+        return 1;
+
+      return 0;
+    }
+    
+This is a bug in the compiler. As a workaround (provided in [@http://stackoverflow.com/questions/21755206/how-to-get-around-gcc-void-b-4-may-be-used-uninitialized-in-this-funct this Stack Overflow question]) use the following way of initializing an optional containing no value:
+
+    boost::optional<int> b = boost::make_optional(false, int());
+
+This is obviously redundant, but makes the warning disappear.
+
+[endsect]
+
+[endsect]
@@ -0,0 +1,57 @@
+
+[section Exception Safety Guarantees]
+
+This library assumes that `T`'s destructor does not throw exceptions. If it does, the behaviour of many operations on `optional<T>` is undefined.
+
+The following mutating operations never throw exceptions:
+
+* `optional<T>::operator= ( none_t ) noexcept`
+* `optional<T>::reset() noexcept`
+
+In addition, the following constructors and the destructor never throw exceptions:
+
+* `optional<T>::optional() noexcept`
+* `optional<T>::optional( none_t ) noexcept`
+
+
+Regarding the following assignment functions:
+
+* `optional<T>::operator= ( optional<T> const& )`
+* `optional<T>::operator= ( T const& )`
+* `template<class U> optional<T>::operator= ( optional<U> const& )`
+* `template<class InPlaceFactory> optional<T>::operator= ( InPlaceFactory const& )`
+* `template<class TypedInPlaceFactory> optional<T>::operator= ( TypedInPlaceFactory const& ) `
+* `optional<T>::reset( T const& )`
+
+They forward calls to the corresponding `T`'s constructors or assignments (depending on whether the optional object is initialized or not); so if both `T`'s constructor and the assignment provide strong exception safety guarantee, `optional<T>`'s assignment also provides strong exception safety guarantee; otherwise we only get the basic guarantee. Additionally, if both involved `T`'s constructor and the assignment never throw, `optional<T>`'s assignment also never throws.
+
+Unless `T`'s constructor or assignment throws, assignments to `optional<T>` do not throw anything else on its own. A throw during assignment never changes the initialization state of any optional object involved:
+
+
+    optional<T> opt1(val1);
+    optional<T> opt2(val2);
+    assert(opt1);
+    assert(opt2);
+    
+    try
+    {
+      opt1 = opt2; // throws
+    }
+    catch(...)
+    {
+      assert(opt1);
+      assert(opt2);
+    }
+
+This also applies to move assignments/constructors. However, move operations are made no-throw more often.
+
+Operation `emplace` provides basic exception safety guarantee. If it throws, the optional object becomes uninitialized regardless of its initial state, and its previous contained value (if any) is destroyed. It doesn't call any assignment or move/copy constructor on `T`.
+
+[heading Swap]
+
+Unless `swap` on optional is customized, its primary implementation forwards calls to `T`'s `swap` or move constructor (depending on the initialization state of the optional objects). Thus, if both `T`'s `swap` and move constructor never throw, `swap` on `optional<T>` never throws. similarly, if both `T`'s `swap` and move constructor offer strong guarantee, `swap` on `optional<T>` also offers a strong guarantee.
+
+In case `swap` on optional is customized, the call to `T`'s move constructor are replaced with the calls to `T`'s default constructor followed by `swap`. (This is more useful on older compilers that do not support move semantics, when one wants to achieve stronger exception safety guarantees.) In this case the exception safety guarantees for `swap` are reliant on the guarantees of `T`'s `swap` and default constructor
+[endsect]
+
+
@@ -0,0 +1,38 @@
+
+[section Type requirements]
+
+The very minimum requirement of `optional<T>` is that `T` is a complete type and that it has a publicly accessible destructor. `T` doesn't even need to be constructible. You can use a very minimum interface:
+
+    optional<T> o;     // uninitialized
+    assert(o == none); // check if initialized
+    assert(!o);        //
+    o.value();         // always throws
+
+But this is practically useless. In order for `optional<T>` to be able to do anything useful and offer all the spectrum of ways of accessing the contained value, `T` needs to have at least one accessible constructor. In that case you need to initialize the optional object with function `emplace()`, or if your compiler does not support it, resort to [link boost_optional_factories In-Place Factories]:
+
+    optional<T> o;
+    o.emplace("T", "ctor", "params");
+
+If `T` is __MOVE_CONSTRUCTIBLE__, `optional<T>` is also __MOVE_CONSTRUCTIBLE__ and can be easily initialized from an rvalue of type `T` and be passed by value:
+
+    optional<T> o = make_T();
+    optional<T> p = optional<T>();
+
+If `T` is __COPY_CONSTRUCTIBLE__, `optional<T>` is also __COPY_CONSTRUCTIBLE__ and can be easily initialized from an lvalue of type `T`:
+
+    T v = make_T();
+    optional<T> o = v;
+    optional<T> p = o;
+
+If `T` is not `MoveAssignable`, it is still possible to reset the value of `optional<T>` using function `emplace()`:
+
+    optional<const T> o = make_T();
+    o.emplace(make_another_T());
+
+If `T` is `Moveable` (both __MOVE_CONSTRUCTIBLE__ and `MoveAssignable`) then `optional<T>` is also `Moveable` and additionally can be constructed and assigned from an rvalue of type `T`.
+
+Similarly, if `T` is `Copyable` (both __COPY_CONSTRUCTIBLE__ and `CopyAssignable`) then `optional<T>` is also `Copyable` and additionally can be constructed and assigned from an lvalue of type `T`.
+
+`T` ['is not] required to be __STD_DEFAULT_CONSTRUCTIBLE__.
+
+[endsect]
@@ -0,0 +1,42 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+    Copyright (c) 2015 Andrzej Krzemieński
+
+    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)
+]
+
+[section Header <boost/none.hpp>]
+
+[section Synopsis]
+```
+namespace boost {
+
+class none_t
+{
+  friend constexpr bool operator==(none_t, none_t) = default;
+  /* see below */
+};
+
+inline constexpr none_t none (/* see below */);
+
+} // namespace boost
+```
+
+Class `none_t` is meant to serve as a tag for selecting appropriate overloads of from `optional`'s interface.
+It is an empty class.
+
+It is [@https://en.cppreference.com/w/cpp/named_req/TriviallyCopyable.html trivially copyable].
+
+It is ['not] [@https://en.cppreference.com/w/cpp/named_req/DefaultConstructible default-constructible].
+
+It models concept [@https://en.cppreference.com/w/cpp/concepts/equality_comparable `std::equality_comparable`].
+
+Constant `none` is used to indicate an optional object that does not contain a value in initialization, assignment and relational operations of `optional`.
+
+[endsect]
+
+[endsect]
@@ -0,0 +1,40 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+    Copyright (c) 2015 Andrzej Krzemienski
+
+    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)
+]
+
+[section Header <boost/optional/bad_optional_access.hpp>]
+
+[section Synopsis]
+```
+namespace boost {
+
+class bad_optional_access : public std::logic_error
+{
+public:
+    bad_optional_access(); ``[link reference_bad_optional_access_constructor __GO_TO__]``
+};
+    
+} // namespace boost
+```
+[endsect]
+
+[section Detailed semantics]
+
+__SPACE__
+
+[#reference_bad_optional_access_constructor]
+
+`bad_optional_access();`
+
+* [*Effect:] Constructs an object of class `bad_optional_access`.
+* [*Postconditions:] `what()` returns an implementation-defined NTBS.
+
+[endsect]
+[endsect]
@@ -0,0 +1,79 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+    Copyright (c) 2015 Andrzej Krzemienski
+
+    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)
+]
+
+[section:io_header Header <boost/optional/optional_io.hpp>]
+
+[section:io_synop Synopsis]
+```
+#include <istream>
+#include <ostream>
+#include <boost/optional/optional.hpp>
+
+namespace boost {
+
+template <class CharType, class CharTrait, class T>
+  std::basic_ostream<CharType, CharTrait>&
+  operator<<(std::basic_ostream<CharType, CharTrait>& out, optional<T> const& v); ``[link reference_operator_ostream __GO_TO__]``
+
+  template <class CharType, class CharTrait>
+  std::basic_ostream<CharType, CharTrait>&
+  operator<<(std::basic_ostream<CharType, CharTrait>& out, none_t const&); ``[link reference_operator_ostream_none __GO_TO__]``
+
+template<class CharType, class CharTrait, class T>
+  std::basic_istream<CharType, CharTrait>&
+  operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v); ``[link reference_operator_istream __GO_TO__]``
+
+} // namespace boost
+```
+
+[endsect]
+
+[section:io_semantics Detailed semantics]
+
+
+[#reference_operator_ostream]
+
+```
+template <class CharType, class CharTrait, class T>
+std::basic_ostream<CharType, CharTrait>&
+operator<<(std::basic_ostream<CharType, CharTrait>& out, optional<T> const& v);
+```
+
+* [*Effect:] Outputs an implementation-defined string. The output contains the information about whether the optional object contains a value or not. If `v` contains a value, the output contains result of calling `out << *v`.
+* [*Returns:] `out`.
+
+__SPACE__
+[#reference_operator_ostream_none]
+
+```
+template <class CharType, class CharTrait, class T>
+std::basic_ostream<CharType, CharTrait>&
+operator<<(std::basic_ostream<CharType, CharTrait>& out, none_t);
+```
+
+* [*Effect:] Outputs an implementation-defined string.
+* [*Returns:] `out`.
+
+__SPACE__
+[#reference_operator_istream]
+
+```
+template <class CharType, class CharTrait, class T>
+std::basic_ostream<CharType, CharTrait>&
+operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v);
+```
+
+* [*Requires:] `T` is __STD_DEFAULT_CONSTRUCTIBLE__ and __MOVE_CONSTRUCTIBLE__.
+* [*Effect:] Reads the value of optional object from `in`. If the string representation indicates that the optional object should contain a value, `v` contains a value and its contained value is obtained as if by default-constructing an object `o` of type `T` and then calling `in >> o`; otherwise `v` does not contain a value, and the previously contained value (if any) has been destroyed.
+* [*Returns:] `out`.
+
+[endsect]
+[endsect]
@@ -0,0 +1,32 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+    Copyright (c) 2015 Andrzej Krzemienski
+
+    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)
+]
+
+[section Header <boost/optional/optional_fwd.hpp>]
+
+[section Synopsis]
+```
+namespace boost {
+
+template <class T> class optional ;
+
+template <class T> void swap ( optional<T>& , optional<T>& );
+
+template <class T> struct optional_swap_should_use_default_constructor ;
+  
+} // namespace boost
+```
+
+This header only contains declarations.
+
+[endsect]
+
+
+[endsect]
@@ -0,0 +1,304 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+
+    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)
+]
+
+
+[#ref_header_optional_optional_hpp] [section:header_optional_optional Synopsis]
+
+    ```// In Header: <`[@boost:/boost/optional/optional.hpp boost/optional/optional.hpp]'''<phrase role="comment">&gt;</phrase>'''``
+
+    namespace boost {
+
+    class in_place_init_t { /* see below */ } ; ``[link reference_in_place_init __GO_TO__]``
+    inline constexpr in_place_init_t in_place_init ( /* see below */ ) ;
+
+    class in_place_init_if_t { /*see below*/ } ; ``[link reference_in_place_init_if __GO_TO__]``
+    inline constexpr in_place_init_if_t in_place_init_if ( /*see below*/ ) ;
+
+    template <class T>
+    class optional ; ``[link reference_operator_template __GO_TO__]``
+
+    template <class T>
+    class optional<T&> ; ``[link reference_operator_template_spec __GO_TO__]``
+
+    template<class T> inline bool operator == ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_equal_optional_optional __GO_TO__]``
+
+    template<class T> inline bool operator != ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_not_equal_optional_optional __GO_TO__]``
+
+    template<class T> inline bool operator <  ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_less_optional_optional __GO_TO__]``
+
+    template<class T> inline bool operator >  ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_greater_optional_optional __GO_TO__]``
+
+    template<class T> inline bool operator <= ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_less_or_equal_optional_optional __GO_TO__]``
+
+    template<class T> inline bool operator >= ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_greater_or_equal_optional_optional __GO_TO__]``
+
+    template<class T> inline bool operator == ( optional<T> const& x, none_t ) noexcept ; ``[link reference_operator_compare_equal_optional_none __GO_TO__]``
+
+    template<class T> inline bool operator != ( optional<T> const& x, none_t ) noexcept ; ``[link reference_operator_compare_not_equal_optional_none __GO_TO__]``
+
+    template<class T> inline optional<T> make_optional ( T const& v ) ; ``[link reference_make_optional_value __GO_TO__]``
+
+    template<class T> inline optional<std::decay_t<T>> make_optional ( T && v ) ; ``[link reference_make_optional_rvalue __GO_TO__]``
+
+    template<class T> inline optional<T> make_optional ( bool condition, T const& v ) ; ``[link reference_make_optional_bool_value __GO_TO__]``
+
+    template<class T> inline optional<std::decay_t<T>> make_optional ( bool condition, T && v ) ; ``[link reference_make_optional_bool_rvalue __GO_TO__]``
+
+    template<class T> inline auto get_optional_value_or ( optional<T> const& opt, typename optional<T>::reference_const_type def ) -> typename optional<T>::reference_const_type; ``[link reference_free_get_value_or __GO_TO__]``
+
+    template<class T> inline auto get_optional_value_or ( optional<T> const& opt, typename optional<T>::reference_type def ) -> typename optional<T>::reference_type ; ``[link reference_free_get_value_or __GO_TO__]``
+
+    template<class T> inline T const& get ( optional<T> const& opt ) ; ``[link reference_optional_get __GO_TO__]``
+
+    template<class T> inline T& get ( optional<T> & opt ) ; ``[link reference_optional_get __GO_TO__]``
+
+    template<class T> inline T const* get ( optional<T> const* opt ) ; ``[link reference_optional_get __GO_TO__]``
+
+    template<class T> inline T* get ( optional<T>* opt ) ; ``[link reference_optional_get __GO_TO__]``
+
+    template<class T> inline auto get_pointer ( optional<T> const& opt ) -> ``['see below]``; ``[link reference_free_get_pointer __GO_TO__]``
+
+    template<class T> inline auto get_pointer ( optional<T> & opt ) -> ``['see below]``; ``[link reference_free_get_pointer __GO_TO__]``
+
+    template<class T> inline void swap( optional<T>& x, optional<T>& y ) ; ``[link reference_swap_optional_optional __GO_TO__]``
+
+    template<class T> inline void swap( optional<T&>& x, optional<T&>& y ) ; ``[link reference_swap_optional_reference __GO_TO__]``
+
+    } // namespace boost
+
+    namespace std {
+
+    template <typename T>
+    struct hash<boost::optional<T> > ; ``[link reference_std_hash_spec __GO_TO__]``
+
+    template <typename T>
+    struct hash<boost::optional<T&> > ; ``[link reference_std_hash_spec __GO_TO__]``
+
+    } // namespace std
+
+
+[endsect]
+
+
+[section:header_optional_in_place_init Initialization tags]
+
+[#reference_in_place_init]
+[#reference_in_place_init_if]
+
+    namespace boost {
+
+    class in_place_init_t { /* see below */ } ;
+    inline constexpr in_place_init_t in_place_init ( /* see below */ ) ;
+
+    class in_place_init_if_t { /*see below*/ } ;
+    inline constexpr  in_place_init_if_t in_place_init_if ( /*see below*/ ) ;
+
+    }
+
+Classes `in_place_init_t` and `in_place_init_if_t` are empty classes. Their purpose is to control overload resolution in the initialization of optional objects.
+They are empty, trivially copyable classes with disabled default constructor.
+
+[endsect]
+
+[section:header_optional_optional_values Optional Values]
+
+[#reference_operator_template]
+
+    template <class T>
+    class optional
+    {
+    public :
+
+        typedef T         value_type ;
+        typedef T &       reference_type ;
+        typedef T const&  reference_const_type ;
+        typedef T &&      rval_reference_type ;
+        typedef T *       pointer_type ;
+        typedef T const*  pointer_const_type ;
+
+        constexpr optional () noexcept ; ``[link reference_optional_constructor __GO_TO__]``
+
+        constexpr optional ( none_t ) noexcept ; ``[link reference_optional_constructor_none_t __GO_TO__]``
+
+        constexpr optional ( T const& v ) ; ``[link reference_optional_constructor_value __GO_TO__]``
+
+        constexpr optional ( T&& v ) ; ``[link reference_optional_constructor_move_value __GO_TO__]``
+
+        constexpr optional ( bool condition, T const& v ) ; ``[link reference_optional_constructor_bool_value __GO_TO__]``
+
+        constexpr optional ( optional const& rhs ) ; ``[link reference_optional_constructor_optional __GO_TO__]``
+
+        constexpr optional ( optional&& rhs ) noexcept(``['see below]``) ; ``[link reference_optional_move_constructor_optional __GO_TO__]``
+
+        template<class U> constexpr explicit optional ( optional<U> const& rhs ) ; ``[link reference_optional_constructor_other_optional __GO_TO__]``
+
+        template<class U> constexpr explicit optional ( optional<U>&& rhs ) ; ``[link reference_optional_move_constructor_other_optional __GO_TO__]``
+
+        template<class... Args> constexpr explicit optional ( in_place_init_t, Args&&... args ) ; ``[link reference_optional_in_place_init __GO_TO__]``
+
+        template<class... Args> constexpr explicit optional ( in_place_init_if_t, bool condition, Args&&... args ) ; ``[link reference_optional_in_place_init_if __GO_TO__]``
+
+        template<class InPlaceFactory> explicit optional ( InPlaceFactory const& f ) ; ``[link reference_optional_constructor_factory __GO_TO__]``
+
+        template<class TypedInPlaceFactory> explicit optional ( TypedInPlaceFactory const& f ) ; ``[link reference_optional_constructor_factory __GO_TO__]``
+
+        constexpr optional& operator = ( none_t ) noexcept ; ``[link reference_optional_operator_equal_none_t __GO_TO__]``
+
+        optional& operator = ( T const& v ) ; ``[link reference_optional_operator_equal_value __GO_TO__]``
+
+        optional& operator = ( T&& v ) ; ``[link reference_optional_operator_move_equal_value __GO_TO__]``
+
+        optional& operator = ( optional const& rhs ) ; ``[link reference_optional_operator_equal_optional __GO_TO__]``
+
+        optional& operator = ( optional&& rhs ) noexcept(``['see below]``) ; ``[link reference_optional_operator_move_equal_optional __GO_TO__]``
+
+        template<class U> optional& operator = ( optional<U> const& rhs ) ; ``[link reference_optional_operator_equal_other_optional __GO_TO__]``
+
+        template<class U> optional& operator = ( optional<U>&& rhs ) ; ``[link reference_optional_operator_move_equal_other_optional __GO_TO__]``
+
+        template<class... Args> void emplace ( Args&&... args ) ; ``[link reference_optional_emplace __GO_TO__]``
+
+        template<class InPlaceFactory> optional& operator = ( InPlaceFactory const& f ) ; ``[link reference_optional_operator_equal_factory __GO_TO__]``
+
+        template<class TypedInPlaceFactory> optional& operator = ( TypedInPlaceFactory const& f ) ; ``[link reference_optional_operator_equal_factory __GO_TO__]``
+
+        constexpr T const& get() const ; ``[link reference_optional_get __GO_TO__]``
+        constexpr T&       get() ; ``[link reference_optional_get __GO_TO__]``
+
+        constexpr T const* operator ->() const ; ``[link reference_optional_operator_arrow __GO_TO__]``
+        constexpr T*       operator ->() ; ``[link reference_optional_operator_arrow __GO_TO__]``
+
+        constexpr T const& operator *() const& ; ``[link reference_optional_operator_asterisk __GO_TO__]``
+        constexpr T&       operator *() & ; ``[link reference_optional_operator_asterisk __GO_TO__]``
+        constexpr T&&      operator *() && ; ``[link reference_optional_operator_asterisk_move __GO_TO__]``
+
+        constexpr T const& value() const& ; ``[link reference_optional_value __GO_TO__]``
+        constexpr T&       value() & ; ``[link reference_optional_value __GO_TO__]``
+        constexpr T&&      value() && ; ``[link reference_optional_value_move __GO_TO__]``
+
+        template<class U> constexpr T value_or( U && v ) const& ; ``[link reference_optional_value_or __GO_TO__]``
+        template<class U> constexpr T value_or( U && v ) && ; ``[link reference_optional_value_or_move __GO_TO__]``
+
+        template<class F> constexpr T value_or_eval( F f ) const& ; ``[link reference_optional_value_or_call __GO_TO__]``
+        template<class F> constexpr T value_or_eval( F f ) && ; ``[link reference_optional_value_or_call_move __GO_TO__]``
+
+        template<class F> constexpr auto map( F f ) const& -> ``['see below]``; ``[link reference_optional_map __GO_TO__]``
+        template<class F> constexpr auto map( F f ) & -> ``['see below]``; ``[link reference_optional_map __GO_TO__]``
+        template<class F> constexpr auto map( F f ) && -> ``['see below]``; ``[link reference_optional_map_move __GO_TO__]``
+
+        template<class F> constexpr auto flat_map( F f ) const& -> ``['see below]``; ``[link reference_optional_flat_map __GO_TO__]``
+        template<class F> constexpr auto flat_map( F f ) & -> ``['see below]``; ``[link reference_optional_flat_map __GO_TO__]``
+        template<class F> constexpr auto flat_map( F f ) && -> ``['see below]``; ``[link reference_optional_flat_map_move __GO_TO__]``
+
+        constexpr operator optional<T&>() & noexcept; ``[link reference_optional_conversion_to_ref __GO_TO__]``
+        constexpr operator optional<T const&>() const& noexcept; ``[link reference_optional_conversion_to_ref __GO_TO__]``
+
+        T const* get_ptr() const ; ``[link reference_optional_get_ptr __GO_TO__]``
+        T*       get_ptr() ; ``[link reference_optional_get_ptr __GO_TO__]``
+
+        constexpr bool has_value() const noexcept ; ``[link reference_optional_operator_bool __GO_TO__]``
+
+        constexpr explicit operator bool() const noexcept ; ``[link reference_optional_operator_bool __GO_TO__]``
+
+        constexpr void reset() noexcept ; ``[link reference_optional_reset __GO_TO__]``
+
+        // deprecated methods
+
+        // (deprecated)
+        void reset ( T const& ) ; ``[link reference_optional_reset_value __GO_TO__]``
+
+        // (deprecated)
+        constexpr bool is_initialized() const ; ``[link reference_optional_is_initialized __GO_TO__]``
+
+        // (deprecated)
+        T const& get_value_or( T const& default ) const ; ``[link reference_optional_get_value_or_value __GO_TO__]``
+    };
+
+
+[endsect]
+
+
+[section:header_optional_optional_refs Optional References]
+
+[#reference_operator_template_spec]
+    template <class T>
+    class optional<T&> // specialization for lvalue references
+    {
+    public :
+
+        typedef T& value_type;
+        typedef T& reference_type;
+        typedef T& reference_const_type; // no const propagation
+        typedef T& rval_reference_type;
+        typedef T* pointer_type;
+        typedef T* pointer_const_type;   // no const propagation
+
+        constexpr optional () noexcept ; ``[link reference_optional_ref_default_ctor __GO_TO__]``
+
+        constexpr optional ( none_t ) noexcept ; ``[link reference_optional_ref_default_ctor __GO_TO__]``
+
+        template<class R> optional(R&& r) noexcept ;  ``[link reference_optional_ref_value_ctor __GO_TO__]``
+
+        template <class R> optional(bool cond, R&& r) noexcept ; ``[link reference_optional_ref_cond_value_ctor __GO_TO__]``
+
+        optional ( optional const& rhs ) noexcept ; ``[link reference_optional_ref_copy_ctor __GO_TO__]``
+
+        template<class U> explicit optional ( optional<U&> const& rhs ) noexcept ; ``[link reference_optional_ref_ctor_from_opt_U __GO_TO__]``
+
+        optional& operator = ( none_t ) noexcept ; ``[link reference_optional_ref_assign_none_t __GO_TO__]``
+
+        optional& operator = ( optional const& rhs ) noexcept; ``[link reference_optional_ref_copy_assign __GO_TO__]``
+
+        template<class U> optional& operator = ( optional<U&> const& rhs ) noexcept ; ``[link reference_optional_ref_assign_optional_U __GO_TO__]``
+
+        template<class R> optional& operator = (R&& r) noexcept ; ``[link reference_optional_ref_assign_R __GO_TO__]``
+
+        template<class R> void emplace ( R&& r ) noexcept ; ``[link reference_optional_ref_emplace_R __GO_TO__]``
+
+        T& get() const ; ``[link reference_optional_ref_get __GO_TO__]``
+        T& operator *() const ; ``[link reference_optional_ref_get __GO_TO__]``
+
+        T* operator ->() const ; ``[link reference_optional_ref_arrow __GO_TO__]``
+
+        T& value() const& ; ``[link reference_optional_ref_value __GO_TO__]``
+
+        template<class R> T& value_or( R && r ) const noexcept ; ``[link reference_optional_ref_value_or __GO_TO__]``
+
+        template<class F> T& value_or_eval( F f ) const ; ``[link reference_optional_ref_value_or_eval __GO_TO__]``
+
+        template<class F> auto map( F f ) const -> ``['see below]``; ``[link reference_optional_ref_map __GO_TO__]``
+
+        template<class F> auto flat_map( F f ) const -> ``['see below]``; ``[link reference_optional_ref_flat_map __GO_TO__]``
+
+        T* get_ptr() const noexcept ; ``[link reference_optional_ref_get_ptr __GO_TO__]``
+
+        bool has_value() const noexcept ; ``[link reference_optional_ref_operator_bool __GO_TO__]``
+
+        explicit operator bool() const noexcept ; ``[link reference_optional_ref_operator_bool __GO_TO__]``
+
+        bool operator!() const noexcept ; ``[link reference_optional_ref_operator_not __GO_TO__]``
+
+        void reset() noexcept ; ``[link reference_optional_ref_reset __GO_TO__]``
+
+        // deprecated methods
+
+        // (deprecated)
+        template<class R> void reset ( R && r ) noexcept ; ``[link reference_optional_ref_reset_value __GO_TO__]``
+
+        // (deprecated)
+        bool is_initialized() const noexcept ; ``[link reference_optional_ref_is_initialized __GO_TO__]``
+
+        // (deprecated)
+        template<class R> T& get_value_or( R && r ) constnoexcept; ``[link reference_optional_ref_get_value_or_value __GO_TO__]``
+
+    private:
+        T* ref; // exposition only
+    };
+[endsect]
@@ -2,16 +2,16 @@
    Boost.Optional

    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+    Copyright (c) 2015 Andrzej Krzemienski

    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)
 ]

+[section Header <boost/optional.hpp>]

-[section Dependencies and Portability]
+This is an alias for header [link ref_header_optional_optional_hpp `<boost/optional/optional.hpp>`].

-The implementation uses `type_traits/alignment_of.hpp` and
-`type_traits/type_with_alignment.hpp`

-[endsect]
+[endsect]
@@ -0,0 +1,37 @@
+
+[section When to use Optional]
+
+It is recommended to use `optional<T>` in situations where there is exactly one, clear (to all parties) reason for having no value of type `T`, and where the lack of value is as natural as having any regular value of `T`. One example of such situation is asking the user in some GUI form to optionally specify some limit on an `int` value, but the user is allowed to say 'I want the number not to be constrained by the maximum'. 
+For another example, consider a config parameter specifying how many threads the application should launch. Leaving this parameter unspecified means that the application should decide itself. For yet another example, consider a function returning the index of the smallest element in a `vector`. We need to be prepared for the situation, where the `vector` is empty. Therefore a natural signature for such function would be:
+
+    template <typename T>
+    optional<size_t> find_smallest_elem(const std::vector<T>& vec);
+
+Here, having received an empty `vec` and having no `size_t` to return is not a ['failure] but a ['normal], albeit irregular, situation.
+
+Another typical situation is to indicate that we do not have a value yet, but we expect to have it later. This notion can be used in implementing solutions like lazy initialization or a two-phase initialization.
+
+`optional` can be used to take a non-__STD_DEFAULT_CONSTRUCTIBLE__ type `T` and create a sibling type with a default constructor. This is a way to add a ['null-state] to any type that doesn't have it already.
+
+Sometimes type `T` already provides a built-in null-state, but it may still be useful to wrap it into `optional`. Consider `std::string`. When you read a piece of text from a GUI form or a DB table, it is hardly ever that the empty string indicates anything else but a missing text. And some data bases do not even distinguish between a null string entry and a non-null string of length 0. Still, it may be practical to use `optional<string>` to indicate in the returned type that we want to treat the empty string in a special dedicated program path:
+
+    if(boost::optional<std::string> name = ask_user_name()) {
+        assert(*name != "");
+        logon_as(*name);
+    }
+    else {
+        skip_logon();
+    }
+    
+In the example above, the assertion indicates that if we choose to use this technique, we must translate the empty string state to an optional object with no contained value (inside function  `ask_user_name`).
+
+[heading Not recommended usages]
+
+It is not recommended to use `optional` to indicate that we were not able to compute a value because of a ['failure]. It is difficult to define what a failure is, but it usually has one common characteristic: an associated information on the cause of the failure. This can be the type and member data of an exception object, or an error code. It is a bad design to signal a failure and not inform about the cause. If you do not want to use exceptions, and do not like the fact that by returning error codes you cannot return the computed value, you can use [@https://github.com/ptal/Boost.Expected Expected] library. It is sort of __BOOST_VARIANT__ that contains either a computed value or a reason why the computation failed.
+
+Sometimes the distinction into what is a failure and what is a valid but irregular result is blurry and depends on a particular usage and personal preference. Consider a function that converts a `string` to an `int`. Is it a failure that you cannot convert? It might in some cases, but in other you may call it exactly for the purpose of figuring out if a given `string` is convertible, and you are not even interested in the resulting value. Sometimes when a conversion fails you may not consider it a failure, but you need to know why it cannot be converted; for instance at which character it is determined that the conversion is impossible. In this case returning `optional<T>` will not suffice. Finally, there is a use case where an input string that does not represent an `int` is not a failure condition, but during the conversion we use resources whose acquisition may fail. In that case the natural representation is to both return `optional<int>` and signal failure:
+
+    optional<int> convert1(const string& str); // throws
+    expected<ErrorT, optional<int>> convert2(const string& str); // return either optional or error
+ 
+[endsect]
@@ -0,0 +1,156 @@
+
+[section Performance considerations]
+
+Technical details aside, the memory layout of `optional<T>` for a generic `T` is more-less this:
+
+  template <typename T>
+  class optional
+  {
+    bool _initialized;
+    std::aligned_storage_t<sizeof(t), alignof(T)> _storage;
+  };
+
+Lifetime of the `T` inside `_storage` is manually controlled with placement-`new`s and pseudo-destructor calls. However, for scalar `T`s we use a different way of storage, by simply holding a `T`:
+  
+  template <typename T>
+  class optional
+  {
+    bool _initialized;
+    T _storage;
+  };
+
+We call it a ['direct] storage. This makes `optional<T>` a trivially-copyable type for scalar `T`s. This only works for compilers that support defaulted functions (including defaulted move assignment and constructor). On compilers without defaulted functions we still use the direct storage, but `optional<T>` is no longer recognized as trivially-copyable. Apart from scalar types, we leave the programmer a way of customizing her type, so that it is recognized by `optional` as candidate for optimized storage, by specializing type trait `boost::optional_config::optional_uses_direct_storage_for`:
+
+  struct X // not trivial
+  {
+    X() {}
+  };
+
+  namespace boost { namespace optional_config {
+    
+    template <> struct optional_uses_direct_storage_for<X> : boost::true_type {};
+    
+  }}
+  
+
+[heading Controlling the size]
+  
+For the purpose of the following analysis, considering memory layouts, we can think of it as:
+
+  template <typename T>
+  class optional
+  {
+    bool _initialized;
+    T _storage;
+  };
+  
+Given type `optional<int>`, and assuming that `sizeof(int) == 4`, we will get `sizeof(optional<int>) == 8`. This is so because of the alignment rules, for our two members we get the following alignment:
+
+[$images/opt_align1.png]
+
+This means you can fit twice as many `int`s as `optional<int>`s into the same space of memory. Therefore, if the size of the objects is critical for your application (e.g., because you want to utilize your CPU cache in order to gain performance) and you have determined you are willing to trade the code clarity, it is recommended that you simply go with type `int` and use some 'magic value' to represent ['not-an-int], or use something like [@https://github.com/akrzemi1/markable `markable`] library.
+
+Even if you cannot spare any value of `int` to represent ['not-an-int] (e.g., because every value is useful, or you do want to signal ['not-an-int] explicitly), at least for `Trivial` types you should consider storing the value and the `bool` flag representing the ['null-state] separately. Consider the following class:
+
+  struct Record
+  {
+    optional<int> _min;
+    optional<int> _max;
+  };
+  
+Its memory layout can be depicted as follows:
+
+[$images/opt_align2.png]
+
+This is exactly the same as if we had the following members:
+
+  struct Record
+  {
+    bool _has_min;
+    int  _min;
+    bool _has_max;
+    int  _max;
+  };
+
+But when they are stored separately, we at least have an option to reorder them like this:
+
+  struct Record
+  {
+    bool _has_min;  
+    bool _has_max;
+    int  _min;
+    int  _max;
+  };
+
+Which gives us the following layout (and smaller total size):
+
+[$images/opt_align3.png]
+
+Sometimes it requires detailed consideration what data we make optional. In our case above, if we determine that both minimum and maximum value can be provided or not provided together, but one is never provided without the other, we can make only one optional member:
+
+  struct Limits
+  {
+    int  _min;
+    int  _max;
+  };
+  
+  struct Record
+  {
+    optional<Limits> _limits;  
+  };
+  
+This would give us the following layout:
+
+[$images/opt_align4.png]
+
+[heading Optional function parameters]
+
+Having function parameters of type `const optional<T>&` may incur certain unexpected run-time cost connected to copy construction of `T`. Consider the following code. 
+
+  void fun(const optional<Big>& v)
+  {
+    if (v) doSomethingWith(*v);
+    else   doSomethingElse();
+  }
+
+  int main()
+  {
+    optional<Big> ov;
+    Big v;
+    fun(none);
+    fun(ov); // no copy
+    fun(v);  // copy constructor of Big
+  }
+
+No copy elision or move semantics can save us from copying type `Big` here. Not that we need any copy, but this is how `optional` works. In order to avoid copying in this case, one could provide second overload of `fun`:
+
+  void fun(const Big& v)
+  {
+    doSomethingWith(v);
+  }
+
+  int main()
+  {
+    optional<Big> ov;
+    Big v;
+    fun(ov); // no copy
+    fun(v);  // no copy: second overload selected
+  }
+
+Alternatively, you could consider using an optional reference instead:
+
+  void fun(optional<const Big&> v) // note where the reference is
+  {
+    if (v) doSomethingWith(*v);
+    else   doSomethingElse();
+  }
+
+  int main()
+  {
+    optional<Big> ov;
+    Big v;
+    fun(none);
+    fun(ov); // doesn't compile
+    fun(v);  // no copy
+  }
+[endsect]
@@ -0,0 +1,131 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
+
+    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)
+]
+
+
+[section Dependencies and Portability][#minimum_system_requirements]
+
+
+[section Minimum System Requirements]
+This library requires C++11 as minimum. However, in C++11 some features are disabled.
+
+[section:constexpr Support for `constexpr`]
+
+[section C++11]
+For compilers fully supporting C++11 (including unconstrained unions and ref-qualifiers),
+for trivially-destructible `T`s, `optional<T>` is a ['literal type] and its constructors
+with `this->has_value() == false` as postcondition:
+
+* `optional()`,
+* `optional(none_t)`,
+
+are ['core constant expressions]. Even for other `T`s, these constructors are guaranteed to
+perform ['constant initialization]: they are never subject to "initialization order fiasco".
+
+Other constructors with `this->has_value() == true`
+as postcondition are core constant expressions if the expression required to initialize
+the contained value is a core constant expression. This includes constructors:
+
+* `template <typename... Args> optional(in_place_init, Args&&...)`,
+* `template <typename U> optional(U&&)`,
+* `optional(const T&)`,
+* `optional(T&&)`.
+
+Other constructors, including the copy and move constructos, are ['not] core constant expressions.
+
+Member functions `.has_value`, `operator bool` and (non)equality comparisons with `none` are core-constant expressions for trivially-destructible `T`s.
+
+Also all `const`-qualified non-static member functions and comparison operators are core constant expressions, if the corresponding operations on `T`
+are core constant expressions.
+[endsect]
+
+[section C++14]
+For C++14 and higher this library, for trivially-destructible `T`s provides the `constexpr` interface for all mutable and non-mutable
+member functions, as long as:
+
+* the corresponding operations on `T` are core constant expressions and
+* the member never attempts to change the `optional`'s state from not containing a value to containing a value.
+
+[note For types that overload unary `operator&` (address) some member functions in `optional`, like `operator->`,
+cannot be implemented as `constexpr` on some compilers.]
+[endsect]
+
+[section C++17]
+In C++17 all non-deprecated constructors are core constant expressions as long as
+`T` is a literal type and its constructor used is a core constant expression.
+[endsect]
+
+[endsect:constexpr]
+
+[endsect]
+
+
+[section Dependencies]
+The implementation uses the following other Boost modules:
+
+# assert
+# config
+# core
+# throw_exception
+# type_traits
+
+[endsect]
+
+
+[section Optional Reference Binding][#optional_reference_binding]
+
+A number of compilers incorrectly treat const lvalues of integral type as rvalues, and create an illegal temporary when binding to an lvalue reference to const in some expressions. This could result in creating an optional lvalue reference that is in fact bound to an unexpected temporary rather than to the intended object. In order to prevent hard to find run-time bugs, this library performs compile-time checks to prevent expressions that would otherwise bind an optional reference to an unexpected temporary. As a consequence, on certain compilers certain pieces of functionality in optional references are missing. In order to maintain a portability of your code across different compilers, it is recommended that you only stick to the minimum portable interface of optional references: prefer direct-initialization and copy assignment of optional references to copy-initialization and assignment from `T&`:
+
+    const int i = 0;
+    optional<const int&> or1;
+    optional<const int&> or2 = i;  // caution: not portable
+    or1 = i;                       // caution: not portable
+
+    optional<const int&> or3(i);   // portable
+    or1 = optional<const int&>(i); // portable
+
+Compilers known to have these deficiencies include GCC versions 4.2, 4.3, 4.4, 4.5, 5.1, 5.2; QCC 4.4.2; MSVC versions 8.0, 9.0, 10.0, 11.0, 12.0. In order to check if your compiler correctly implements reference binding use this test program.
+
+    #include <cassert>
+
+    const int global_i = 0;
+
+    struct TestingReferenceBinding
+    {
+      TestingReferenceBinding(const int& ii)
+      {
+        assert(&ii == &global_i);
+      }
+
+      void operator=(const int& ii)
+      {
+        assert(&ii == &global_i);
+      }
+
+      void operator=(int&&) // remove this if your compiler doesn't have rvalue refs
+      {
+        assert(false);
+      }
+    };
+
+    int main()
+    {
+      const int& iref = global_i;
+      assert(&iref == &global_i);
+
+      TestingReferenceBinding ttt = global_i;
+      ttt = global_i;
+
+      TestingReferenceBinding ttt2 = iref;
+      ttt2 = iref;
+    }
+
+[endsect]
+
+[endsect]
@@ -0,0 +1,63 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2015 - 2024 Andrzej Krzemieński
+
+    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)
+]
+
+
+[section:std_comp Comparison with `std::optional`]
+
+[table Comparison with `std::optional`
+  [ [[*`boost::optional`]] [[*`std::optional`]] [] ]
+  [ [`optional<int> o = none;`] [`optional<int> o = nullopt;`] [Different name for no-value tag.] ]
+  [ [`optional<X> o {in_place_init, a, b};`] [`optional<int> o {in_place, a, b};`] [Different name for in-place initialization tag.] ]
+  [ [] [`optional<vector<int>> o {in_place, {1, 2, 3}};`
+
+  `o.emplace({4, 5, 6});`] [No in-place initialization with initializer-list in `boost`.] ]
+  [ [`optional<X> o {in_place_init_if, cond, a, b};`] [] [No syntax for conditional in-place initialization in `std`.] ]
+  [ [`optional<X> o {cond, x};`] [] [No syntax for conditional initialization from `T` in `std`.] ]
+  [ [`optional<T> o {U{}};`
+
+  `optional<T> o {optional<U>{}};`] [`optional<T> o = U{};`
+
+  `optional<T> o = optional<U>{}`] [Constructors form `U` and `optional<U>` are explicit in `boost` and implicit in `std`.] ]
+  [ [] [`optional o = 1;`] [No clever deduction of of `optional`'s template parameters in initialization in `boost`. ]]
+  [ [`optional<X const&> o;`] [] [No optional references in `std`.] ]
+  [ [] [`constexpr optional<int> o;`] [No `constexpr` interface in `boost`.] ]
+  [ [`o.map(&f);`
+
+  `o.flat_map(&of);` ] [`o.transform(&f);`
+
+  `o.and_then(&of);`] [Different names and signatures for monadic interface functions. `boost` takes callbacks by value, `std` by universal reference.] ]
+  [ [] [`o.or_else(&of);`] [No `or_else` function in `boost`.] ]
+  [ [`o.value_or_eval(&f);`] [] [No `value_or_eval` function in `std`.] ]
+  [ [] [`optional<T>{} == U{}`;
+
+  `optional<T>{} == optional<U>{}`] [No comparisons with `U` or `optional<U>` in `boost`.] ]
+  [ [`make_optional(cond, v);`] [] [No `make_optional` with condition in `std`.] ]
+  [ [] [`make_optional<T>(a, b);`] [No `make_optional` with specified `T` in `boost`.] ]
+  [ [`std::cout << optional<int>{};`] [] [No printing to IOStreams in `std`.]]
+
+  [ [`std::vector<optional<int>> rng;`
+
+  `std::ranges::find(rng, boost::none)`] [`std::vector<optional<int>> rng;`
+
+  `std::ranges::find(rng, boost::optional<int>{})`] [optional<T> is never [@https://en.cppreference.com/w/cpp/concepts/equality_comparable `std::equality_comparable_with`] `nullopt_t` in `std`. ] ]
+
+  [ [```
+  void test(vector<optional<T>> rng, T val) {
+    std::ranges::find(rng, val);
+  }
+  ```] [```
+  void test(vector<optional<T>> rng, T val) {
+    std::ranges::find(rng, make_optional(val));
+  }
+  ```] [For `std::optional`, code without `make_optional()` compiles but is ['undefined behavior] when `T` is itself an `optional`. ] ]
+
+]
+
+[endsect][/ std_comp]
@@ -0,0 +1,210 @@
+[/
+    Boost.Optional
+
+    Copyright (c) 2015 - 2026 Andrzej Krzemienski
+
+    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)
+]
+
+
+[section:relnotes Release Notes]
+
+[heading Boost Release 1.91]
+
+* For compilers with full C++11 support (including "unrestricted  unions" and ref-qualifiers)
+  changed the implementation from aligned storage to union storage. This enables the gradual
+  `constexpr` support:
+
+    * In C++11, some constructors and `const`-qualified accessors become usable
+      in compile-time contexts (are ['core constant expressions]) for types
+      satisfying certain constraints.
+    * In C++14 even some mutating operations become core constant expressions (those
+      that do not require changing the state of `optional` from not having a value to
+      having a value), for co-operating types.
+    * In C++17 all constructors (including copy and move) become core constant expressions
+      for co-operating types.
+
+  This addresses issues [@https://github.com/boostorg/optional/issues/132 #132] and [@https://github.com/boostorg/optional/issues/143 #143].
+
+* *Breaking change.* In the said implementation, abandoned the mechanism for customizing
+  `swap`. Hardly anyone knows about this mechanism and it was never documented.
+
+* In the said implementation, applied a couple of small changes to get closer to the interface of `std::optional`:
+  * Enabled syntax `o = {}` for putting optional objects to no-value state.
+  * Enabled syntax `o.value_or({})`, which uses a default-constructed `T`.
+  * Construct `o = u`, where `o` is of type `optional<T>` and `u` is of type `U` convertible to `T`,
+    does not create a temporary `T`.
+
+* In the said implementation, added a conversion from `optional<T>&` to `optional<T&>`. This addresses [@https://github.com/boostorg/optional/issues/142 issue #142].
+
+* `none_t` is now `std::equality_comparable`, which means that `none_t` and `optional<T>`
+  model concept `std::equality_comparable_with` (for `std::equality_comparable` `T`s),
+  which means that you can `std::ranges::find(rng, boost::none)` for a range of optional objects.
+
+* *Warning.* In the future releases we intend to introduce the range interface
+  in `optional`, so that `std::ranges::range<optional<T>>` will be `true`.
+  This may affect the overload resolution in programs that make decisions based
+  on predicates such as `std::ranges::range`. For instance, the following code
+  will start behaving differently:
+
+  ```
+  template <typename T>
+  void serialize(T const& v)
+  {
+    if constexpr (std::ranges::range<T>)
+      serialize_as_range(v);
+    else if constexpr (custom::is_optional_like<T>)
+      serialize_as_optional(v);
+    else
+      serialize_as_value(v);
+  }
+  ```
+
+[heading Boost Release 1.87]
+
+* *Breaking change.* Dropped support for C++03. C++11 is now the required minimum; at least some C++11 features.
+* Dropped dependency on Boost.Utility.
+* Dropped dependency on Boost.Predef.
+* Dropped dependency on Boost.StaticAssert.
+* Dropped dependency on Boost.Move.
+* A bit faster implementation of some relational operations.
+* *Warning.* In the future releases we intend to introduce the range interface
+  into `optional`, so that `std::ranges::range<optional<T>>` will be `true`.
+  This may affect the overload resolution in programs that make decisions based
+  on predicates such as `std::ranges::range`.
+* Tags `in_place_init` and `in_place_init_if` become `inline constexpr` and therewith leave smaller footprint in the executable. This addresses [@https://github.com/boostorg/optional/issues/103 issue #103].
+
+
+[heading Boost Release 1.85]
+
+* Fixed the implementation for trivial types. Now it is slower, because it always initializes the `T`, but it avoids undefined behavior when `optional<T>` is copied. This fixes [@https://github.com/boostorg/optional/issues/108 issue #108].
+* Fixed some `-Wmaybe-uninitialized` warnings in GCC 12. Thanks to Christian Mazakas for the fix.
+* Dropped dependency on Boost.Detail.
+
+[heading Boost Release 1.83]
+
+* Deprecated support for C++03 and earlier, C++11 will be required in release 1.86.
+
+[heading Boost Release 1.80]
+
+* [*Breaking change:] Added specializations for `std::hash<boost::optional<T>>`. This fixes [@https://github.com/boostorg/optional/issues/55 issue #55]. You may get compiler errors when your program provides specializations for `std::hash<boost::optional<T>>`. If this happens, define macro `BOOST_OPTIONAL_CONFIG_DO_NOT_SPECIALIZE_STD_HASH` to suppress the specializations of `std::hash` in this library.
+
+[heading Boost Release 1.79]
+
+* Fixed [@https://github.com/boostorg/optional/issues/98 issue #98].
+* Fixed [@https://github.com/boostorg/optional/issues/92 issue #92].
+* Added support for `BOOST_NO_IOSTREAM`.
+* Now aligned storage uses `unsigned char` rather than `char` to avoid UB.
+* Now using cv-unqualified `value_type` with placement `new` to avoid UB.
+
+[heading Boost Release 1.76]
+
+* Fixed MSVC warning C4702.
+
+[heading Boost Release 1.75]
+
+* `boost::none` is `constexpr`-declared.
+
+* Fixed [@https://github.com/boostorg/optional/issues/78 issue #78].
+
+[heading Boost Release 1.73]
+
+* Fixed [@https://github.com/boostorg/optional/issues/78 issue #78].
+* `boost::none` is now declared as an inline variable (on compilers that support it): there is only one instance of `boost::none` across all translation units.
+* Fixed a number of compilation errors in GCC 4.4.7 in `optional<T>` for trivial `T`s. Thanks to Robert Leahy for the fix. For details see [@https://github.com/boostorg/optional/pull/80 pr #78].
+* Now suppressing warning `-Wweak-vtables`.
+
+[heading Boost Release 1.69]
+
+* Remove deprecation mark from `reset()` method (without arguments).
+* Fixed [@https://github.com/boostorg/optional/issues/59 issue #59].
+* Fixed bug with initialization of certain wrapper types in clang with -std=c++03. See [@https://github.com/boostorg/optional/pull/64 pr #64].
+
+[heading Boost Release 1.68]
+
+* Added member function `has_value()` for compatibility with `std::optional` ([@https://github.com/boostorg/optional/issues/52 issue #52]).
+* Added member function `map()` for transforming `optional<T>` into `optional<U>` using a function of type `T -> U`.
+* Added member function `flat_map()` for transforming `optional<T>` into `optional<U>` using a function of type `T -> optional<U>`.
+
+
+[heading Boost Release 1.67]
+
+* Fixed [@https://github.com/boostorg/optional/issues/46 issue #46].
+* Fixed `-Wzero-as-null-pointer-constant` warnings.
+
+
+[heading Boost Release 1.66]
+
+* On newer compilers `optional` is now trivially-copyable for scalar `T`s. This uses a different storage (just `T` rather than `aligned_storage`). We require the compiler to support defaulted functions.
+* Changed the implementation of `operator==` to get rid of the `-Wmaybe-uninitialized` false-positive warning from GCC.
+
+[heading Boost Release 1.63]
+* Added two new in-place constructors. They work similarly to `emplace()` functions: they initialize the contained value by perfect-forwarding the obtained arguments. One constructor always initializes the contained value, the other based on a boolean condition.
+* Syntax `o = {}` now correctly un-initializes optional, just like in `std::optional`.
+* Fixed [@https://svn.boost.org/trac/boost/ticket/12203 Trac #12203].
+* Fixed [@https://svn.boost.org/trac/boost/ticket/12563 Trac #12563].
+
+
+[heading Boost Release 1.62]
+
+* Fixed [@https://svn.boost.org/trac/boost/ticket/12179 Trac #12179].
+
+
+[heading Boost Release 1.61]
+
+* Now `boost::optional` is specialized for reference parameters. This addresses a couple of issues:
+  * the `sizeof` of optional reference is that of a pointer,
+  * some bugs connected to copying optional references are gone,
+  * all run-time bugs caused by incorrect reference binding on some compilers are now turned into compile-time errors,
+  * you can swap optional references: it is like swapping pointers: shallow, underlying objects are not affected,
+  * optional references to abstract types work.
+* Documented nested typedefs ([@https://svn.boost.org/trac/boost/ticket/5193 Trac #5193]).
+* Made the perfect-forwarding constructor SFINAE-friendly, which fixes [@https://svn.boost.org/trac/boost/ticket/12002 Trac #12002]. However, this only works in the newer platforms that correctly implement C++11 `<type_traits>`.
+* Fixed [@https://svn.boost.org/trac/boost/ticket/10445 Trac #10445].
+
+
+[heading Boost Release 1.60]
+
+* Changed the implementation of `boost::none` again. Now it is a const object with internal linkage (as any other tag). This fixes [@https://svn.boost.org/trac/boost/ticket/11203 Trac #11203].
+
+
+[heading Boost Release 1.59]
+
+* For C++03 compilers, added 0-argument overload for member function `emplace()`, and therewith removed the dependency on `<boost/utility/in_place_factory.hpp>`.
+* Fixed [@https://svn.boost.org/trac/boost/ticket/11241 Trac #11241].
+
+[heading Boost Release 1.58]
+
+* `boost::none_t` is no longer convertible from literal `0`. This avoids a bug where `optional<rational<int>> oi = 0;` would initialize an optional object with no contained value.
+* Improved the trick that prevents streaming out `optional` without header `optional_io.hpp` by using safe-bool idiom. This addresses [@https://svn.boost.org/trac/boost/ticket/10825 Trac #10825].
+* IOStream operators are now mentioned in documentation.
+* Added a way to manually disable move semantics: just define macro `BOOST_OPTIONAL_CONFIG_NO_RVALUE_REFERENCES`. This can be used to work around [@https://svn.boost.org/trac/boost/ticket/10399 Trac #10399].
+* It is no longer possible to assign `optional<U>` to `optional<T>` when `U` is not assignable or convertible to `T` ([@https://svn.boost.org/trac/boost/ticket/11087 Trac #11087]).
+* Value accessors now work correctly on rvalues of `optional<T&>` ([@https://svn.boost.org/trac/boost/ticket/10839 Trac #10839]).
+
+
+[heading Boost Release 1.57]
+
+* [@https://github.com/boostorg/optional/pull/9 Git pull #9]: ['"Supply `<string>` to fix C++03 compile error on `logic_error("...")`"].
+
+
+[heading Boost Release 1.56]
+
+* Added support for rvalue references. Now `optional<T>` works with moveable but non-copyable `T`'s,
+* Improved `swap` (now uses move operations),
+* Added function `emplace()`. This is the last of the requests from [@https://svn.boost.org/trac/boost/ticket/1841 Trac #1841],
+* `optional` is moveable, including conditional `noexcept` specifications, which make it `move_if_noexcept`-friendly,
+* Using explicit operator bool() on platforms that support it ([@https://svn.boost.org/trac/boost/ticket/4227 Trac #4227]) (breaking change),
+* Forward declaration of `operator<<(ostream&, optional const&)` to prevent inadvertent incorrect serialization of optional objects,
+* Removed deprecated function `reset()` from examples ([@https://svn.boost.org/trac/boost/ticket/9005 Trac #9005]),
+* Equality comparison with `boost::none` does not require that `T` be EqualityComparable,
+* Optional rvalue references are explicitly disallowed,
+* Binding temporaries to optional references is explicitly disallowed (breaking change),
+* More ways to access the contained value, functions `value()`, `value_or()`, `value_or_eval()`,
+* Updated and reorganized documentation, added tutorial and quick guide sections.
+
+
+
+[endsect][/ relnotes]
@@ -9,7 +9,7 @@
 ]


-[section Acknowledgments]
+[section:acknowledgements Acknowledgements]

 [heading Pre-formal review]

@@ -55,6 +55,8 @@ Rob Stewart, and others.
 with the proper semantics.
 * Mat Marcus shown the virtues of a value-oriented interface, influencing
 the current design, and contributed the idea of "none".
+* Vladimir Batov's design of Boost.Convert library motivated the development
+of value accessors for `optional`: functions `value`, `value_or`, `value_or_eval`.

 [endsect]

@@ -10,26 +10,46 @@
 # Quickbook
 # -----------------------------------------------------------------------------

+using boostbook ;
 import quickbook ;

 path-constant images : html ;

 xml optional
    :
-        optional.qbk
+        00_optional.qbk
+    ;
+
+install images
+    :
+        images/opt_align1.png
+        images/opt_align2.png
+        images/opt_align3.png
+        images/opt_align4.png
+        images/R.png
+        images/space.png
+    :
+        <location>html/images
    ;

 boostbook standalone
    :
        optional
    :
-        <xsl:param>boost.root=../../../..
-        <xsl:param>html.stylesheet=boostbook.css
-        <xsl:param>toc.max.depth=2
-        <xsl:param>toc.section.depth=2
-        <xsl:param>chunk.section.depth=1
-        <format>pdf:<xsl:param>img.src.path=$(images)/
-        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/optional/doc/html
+        <format>html:<xsl:param>"boost.root=../../../.."
+        <format>html:<xsl:param>"boost.libraries=../../../../libs/libraries.htm"
+        <xsl:param>"chapter.autolabel=0"
+        <xsl:param>"chunk.section.depth=8"
+        <xsl:param>"toc.section.depth=1"
+        <xsl:param>"toc.max.depth=2"
+        <xsl:param>"generate.section.toc.level=1"
+        <format>pdf:<xsl:param>"img.src.path=$(images)/"
+        <format>pdf:<xsl:param>"boost.url.prefix=http://www.boost.org/doc/libs/release/libs/optional/doc/html"
+        <format>docbook:<auto-index-internal>on
    ;

-
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : standalone ;
+explicit boostrelease ;
@@ -1,251 +0,0 @@
-[/
-    Boost.Optional
-
-    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
-
-    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)
-]
-
-[section Development]
-
-[section The models]
-
-In C++, we can ['declare] an object (a variable) of type `T`, and we can give this
-variable an ['initial value] (through an ['initializer]. (c.f. 8.5)).
-When a declaration includes a non-empty initializer (an initial value is given),
-it is said that the object has been initialized.
-If the declaration uses an empty initializer (no initial value is given), and
-neither default nor value initialization applies, it is said that the object is
-[*uninitialized]. Its actual value exist but has an ['indeterminate initial value]
-(c.f. 8.5.9).
-`optional<T>` intends to formalize the notion of initialization (or lack of it)
-allowing a program to test whether an object has been initialized and stating
-that access to the value of an uninitialized object is undefined behavior. That
-is, when a variable is declared as `optional<T>` and no initial value is given,
-the variable is ['formally] uninitialized. A formally uninitialized optional object
-has conceptually no value at all and this situation can be tested at runtime. It
-is formally ['undefined behavior] to try to access the value of an uninitialized
-optional. An uninitialized optional can be assigned a value, in which case its initialization state changes to initialized. Furthermore, given the formal
-treatment of initialization states in optional objects, it is even possible to
-reset an optional to ['uninitialized].
-
-In C++ there is no formal notion of uninitialized objects, which means that
-objects always have an initial value even if indeterminate.
-As discussed on the previous section, this has a drawback because you need
-additional information to tell if an object has been effectively initialized.
-One of the typical ways in which this has been historically dealt with is via
-a special value: `EOF`, `npos`, -1, etc... This is equivalent to adding the
-special value to the set of possible values of a given type. This super set of
-`T` plus some ['nil_t]—were `nil_t` is some stateless POD-can be modeled in modern
-languages as a [*discriminated union] of T and nil_t. Discriminated unions are
-often called ['variants]. A variant has a ['current type], which in our case is either
-`T` or `nil_t`.
-Using the __BOOST_VARIANT__ library, this model can be implemented in terms of `boost::variant<T,nil_t>`.
-There is precedent for a discriminated union as a model for an optional value:
-the __HASKELL__ [*Maybe] built-in type constructor. Thus, a discriminated union
-`T+nil_t` serves as a conceptual foundation.
-
-A `variant<T,nil_t>` follows naturally from the traditional idiom of extending
-the range of possible values adding an additional sentinel value with the
-special meaning of ['Nothing].  However, this additional ['Nothing] value is largely
-irrelevant for our purpose since our goal is to formalize the notion of
-uninitialized objects and, while a special extended value can be used to convey
-that meaning, it is not strictly necessary in order to do so.
-
-The observation made in the last paragraph about the irrelevant nature of the
-additional `nil_t` with respect to [_purpose] of `optional<T>` suggests an 
-alternative model: a ['container] that either has a value of `T` or nothing.
-
-As of this writing I don't know of any precedent for a variable-size
-fixed-capacity (of 1) stack-based container model for optional values, yet I
-believe this is the consequence of the lack of practical implementations of
-such a container rather than an inherent shortcoming of the container model.
-
-In any event, both the discriminated-union or the single-element container
-models serve as a conceptual ground for a class representing optional—i.e.
-possibly uninitialized—objects.
-For instance, these models show the ['exact] semantics required for a wrapper
-of optional values:
-
-Discriminated-union:
-
-* [*deep-copy] semantics: copies of the variant implies copies of the value.
-* [*deep-relational] semantics: comparisons between variants matches both
-current types and values
-* If the variant's current type is `T`, it is modeling an ['initialized] optional.
-* If the variant's current type is not `T`, it is modeling an ['uninitialized]
-optional.
-* Testing if the variant's current type is `T` models testing if the optional
-is initialized
-* Trying to extract a `T` from a variant when its current type is not `T`, models
-the undefined behavior of trying to access the value of an uninitialized optional
-
-Single-element container:
-
-* [*deep-copy] semantics: copies of the container implies copies of the value.
-* [*deep-relational] semantics: comparisons between containers compare container
-size and if match, contained value
-* If the container is not empty (contains an object of type `T`), it is modeling
-an ['initialized] optional.
-* If the container is empty, it is modeling an ['uninitialized] optional.
-* Testing if the container is empty models testing if the optional is
-initialized
-* Trying to extract a `T` from an empty container models the undefined behavior
-of trying to access the value of an uninitialized optional
-
-[endsect]
-
-[section The semantics]
-
-Objects of type `optional<T>` are intended to be used in places where objects of
-type `T` would but which might be uninitialized. Hence, `optional<T>`'s purpose is
-to formalize the additional possibly uninitialized state.
-From the perspective of this role, `optional<T>` can have the same operational
-semantics of `T` plus the additional semantics corresponding to this special
-state.
-As such, `optional<T>` could be thought of as a ['supertype] of `T`. Of course, we 
-can't do that in C++, so we need to compose the desired semantics using a
-different mechanism.
-Doing it the other way around, that is, making `optional<T>` a ['subtype] of `T`
-is not only conceptually wrong but also impractical: it is not allowed to
-derive from a non-class type, such as a built-in type.
-
-We can draw from the purpose of `optional<T>` the required basic semantics:
-
-* [*Default Construction:] To introduce a formally uninitialized wrapped
-object.
-* [*Direct Value Construction via copy:] To introduce a formally initialized
-wrapped object whose value is obtained as a copy of some object.
-* [*Deep Copy Construction:] To obtain a new yet equivalent wrapped object.
-* [*Direct Value Assignment (upon initialized):] To assign a value to the
-wrapped object.
-* [*Direct Value Assignment (upon uninitialized):] To initialize the wrapped
-object with a value obtained as a copy of some object.
-* [*Assignment (upon initialized):] To assign to the wrapped object the value
-of another wrapped object.
-* [*Assignment (upon uninitialized):] To initialize the wrapped object with
-value of another wrapped object.
-* [*Deep Relational Operations (when supported by the type T):] To compare
-wrapped object values taking into account the presence of uninitialized states.
-* [*Value access:] To unwrap the wrapped object.
-* [*Initialization state query:] To determine if the object is formally
-initialized or not.
-* [*Swap:] To exchange wrapped objects. (with whatever exception safety
-guarantees are provided by `T`'s swap).
-* [*De-initialization:] To release the wrapped object (if any) and leave the
-wrapper in the uninitialized state.
-
-Additional operations are useful, such as converting constructors and
-converting assignments, in-place construction and assignment, and safe
-value access via a pointer to the wrapped object or null.
-
-[endsect]
-
-[section The Interface]
-
-Since the purpose of optional is to allow us to use objects with a formal
-uninitialized additional state, the interface could try to follow the
-interface of the underlying `T` type as much as possible. In order to choose
-the proper degree of adoption of the native `T` interface, the following must
-be noted: Even if all the operations supported by an instance of type `T` are
-defined for the entire range of values for such a type, an `optional<T>`
-extends such a set of values with a new value for which most
-(otherwise valid) operations are not defined in terms of `T`.
-
-Furthermore, since `optional<T>` itself is merely a `T` wrapper (modeling a `T`
-supertype), any attempt to define such operations upon uninitialized optionals
-will be totally artificial w.r.t. `T`.
-
-This library chooses an interface which follows from `T`'s interface only for
-those operations which are well defined (w.r.t the type `T`) even if any of the
-operands are uninitialized. These operations include: construction,
-copy-construction, assignment, swap and relational operations.
-
-For the value access operations, which are undefined (w.r.t the type `T`) when
-the operand is uninitialized, a different interface is chosen (which will be
-explained next).
-
-Also, the presence of the possibly uninitialized state requires additional
-operations not provided by `T` itself which are supported by a special interface.
-
-[heading Lexically-hinted Value Access in the presence of possibly
-untitialized optional objects: The operators * and ->]
-
-A relevant feature of a pointer is that it can have a [*null pointer value].
-This is a ['special] value which is used to indicate that the pointer is not
-referring to any object at all. In other words, null pointer values convey
-the notion of nonexistent objects.
-
-This meaning of the null pointer value allowed pointers to became a ['de
-facto] standard for handling optional objects because all you have to do
-to refer to a value which you don't really have is to use a null pointer
-value of the appropriate type. Pointers have been used for decades—from
-the days of C APIs to modern C++ libraries—to ['refer] to optional (that is,
-possibly nonexistent) objects; particularly as optional arguments to a
-function, but also quite often as optional data members.
-
-The possible presence of a null pointer value makes the operations that
-access the pointee's value possibly undefined, therefore, expressions which
-use dereference and access operators, such as: `( *p = 2 )` and `( p->foo() )`,
-implicitly convey the notion of optionality, and this information is tied to
-the ['syntax] of the expressions. That is, the presence of operators `*` and `->`
-tell by themselves —without any additional context— that the expression will
-be undefined unless the implied pointee actually exist.
-
-Such a ['de facto] idiom for referring to optional objects can be formalized
-in the form of a concept: the __OPTIONAL_POINTEE__ concept.
-This concept captures the syntactic usage of operators `*`, `->` and
-conversion to `bool` to convey the notion of optionality.
-
-However, pointers are good to [_refer] to optional objects, but not particularly
-good to handle the optional objects in all other respects, such as initializing
-or moving/copying them. The problem resides in the shallow-copy of pointer
-semantics: if you need to effectively move or copy the object, pointers alone
-are not enough. The problem is that copies of pointers do not imply copies of
-pointees. For example, as was discussed in the motivation, pointers alone
-cannot be used to return optional objects from a function because the object
-must move outside from the function and into the caller's context.
-
-A solution to the shallow-copy problem that is often used is to resort to
-dynamic allocation and use a smart pointer to automatically handle the details
-of this. For example, if a function is to optionally return an object `X`, it can
-use `shared_ptr<X>` as the return value. However, this requires dynamic allocation
-of `X`. If `X` is a built-in or small POD, this technique is very poor in terms of
-required resources. Optional objects are essentially values so it is very
-convenient to be able to use automatic storage and deep-copy semantics to
-manipulate optional values just as we do with ordinary values. Pointers do
-not have this semantics, so are inappropriate for the initialization and
-transport of optional values, yet are quite convenient for handling the access
-to the possible undefined value because of the idiomatic aid present in the
-__OPTIONAL_POINTEE__ concept incarnated by pointers.
-
-
-[heading Optional<T> as a model of OptionalPointee]
-
-For value access operations `optional<>` uses operators `*` and `->` to
-lexically warn about the possibly uninitialized state appealing to the
-familiar pointer semantics w.r.t. to null pointers.
-
-[warning
-However, it is particularly important to note that `optional<>` objects
-are not pointers. [_`optional<>` is not, and does not model, a pointer].
-]
-
-For instance, `optional<>` does not have shallow-copy so does not alias:
-two different optionals never refer to the ['same] value unless `T` itself is
-a reference (but may have ['equivalent] values).
-The difference between an `optional<T>` and a pointer must be kept in mind,
-particularly because the semantics of relational operators are different:
-since `optional<T>` is a value-wrapper, relational operators are deep: they
-compare optional values; but relational operators for pointers are shallow:
-they do not compare pointee values.
-As a result, you might be able to replace `optional<T>` by `T*` on some
-situations but not always. Specifically, on generic code written for both,
-you cannot use relational operators directly, and must use the template
-functions __FUNCTION_EQUAL_POINTEES__ and __FUNCTION_LESS_POINTEES__ instead.
-
-[endsect]
-
-[endsect]
@@ -1,102 +0,0 @@
-[/
-    Boost.Optional
-
-    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
-
-    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)
-]
-
-
-[section Examples]
-
-[section Optional return values]
-
-    optional<char> get_async_input()
-    {
-        if ( !queue.empty() )
-            return optional<char>(queue.top());
-        else return optional<char>(); // uninitialized
-    }
-
-    void receive_async_message()
-    {
-        optional<char> rcv ;
-        // The safe boolean conversion from 'rcv' is used here.
-        while ( (rcv = get_async_input()) && !timeout() )
-            output(*rcv);
-    }
-
-[endsect]
-
-[section Optional local variables]
-
-    optional<string> name ;
-    if ( database.open() )
-    {
-        name.reset ( database.lookup(employer_name) ) ;
-    }
-    else
-    {
-        if ( can_ask_user )
-            name.reset ( user.ask(employer_name) ) ;
-    }
-
-    if ( name )
-        print(*name);
-    else print("employer's name not found!");
-
-[endsect]
-
-[section Optional data members]
-
-    class figure
-    {
-        public:
-
-        figure()
-        {
-            // data member 'm_clipping_rect' is uninitialized at this point.
-        }
-
-        void clip_in_rect ( rect const& rect )
-        {
-            ....
-            m_clipping_rect.reset ( rect ) ; // initialized here.
-        }
-
-        void draw ( canvas& cvs )
-        {
-            if ( m_clipping_rect )
-                do_clipping(*m_clipping_rect);
-
-            cvs.drawXXX(..);
-        }
-
-        // this can return NULL.
-        rect const* get_clipping_rect() { return get_pointer(m_clipping_rect); }
-
-        private :
-
-        optional<rect> m_clipping_rect ;
-
-    };
-
-[endsect]
-
-[section Bypassing expensive unnecessary default construction]
-
-    class ExpensiveCtor { ... } ;
-    class Fred
-    {
-        Fred() : mLargeVector(10000) {}
-
-        std::vector< optional<ExpensiveCtor> > mLargeVector ;
-    } ;
-
-[endsect]
-
-[endsect]
-
- 
@@ -1,14 +0,0 @@
-index.html
-boost_optional/development.html
-boost_optional/synopsis.html
-boost_optional/detailed_semantics.html
-boost_optional/examples.html
-boost_optional/optional_references.html
-boost_optional/rebinding_semantics_for_assignment_of_optional_references.html
-boost_optional/in_place_factories.html
-boost_optional/a_note_about_optional_bool_.html
-boost_optional/exception_safety_guarantees.html
-boost_optional/type_requirements.html
-boost_optional/implementation_notes.html
-boost_optional/dependencies_and_portability.html
-boost_optional/acknowledgments.html
@@ -1,84 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>A note about optional&lt;bool&gt;</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="prev" href="in_place_factories.html" title="In-Place Factories">
-<link rel="next" href="exception_safety_guarantees.html" title="Exception Safety Guarantees">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="in_place_factories.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exception_safety_guarantees.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_optional.a_note_about_optional_bool_"></a><a class="link" href="a_note_about_optional_bool_.html" title="A note about optional&lt;bool&gt;">A note about
-    optional&lt;bool&gt;</a>
-</h2></div></div></div>
-<p>
-      <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">&gt;</span></code> should
-      be used with special caution and consideration.
-    </p>
-<p>
-      First, it is functionally similar to a tristate boolean (false,maybe,true)
-      &#8212;such as <a href="../../../../../doc/html/tribool.html" target="_top">boost::tribool</a>&#8212;
-      except that in a tristate boolean, the maybe state <span class="underline">represents
-      a valid value</span>, unlike the corresponding state of an uninitialized
-      <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">&gt;</span></code>. It
-      should be carefully considered if an <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">&gt;</span></code>
-      instead of a <code class="computeroutput"><span class="identifier">tribool</span></code> is really
-      needed.
-    </p>
-<p>
-      Second, <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;&gt;</span></code>
-      provides an implicit conversion to <code class="computeroutput"><span class="keyword">bool</span></code>.
-      This conversion refers to the initialization state and not to the contained
-      value. Using <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">&gt;</span></code> can
-      lead to subtle errors due to the implicit <code class="computeroutput"><span class="keyword">bool</span></code>
-      conversion:
-    </p>
-<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">foo</span> <span class="special">(</span> <span class="keyword">bool</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span>
-<span class="keyword">void</span> <span class="identifier">bar</span><span class="special">()</span>
-<span class="special">{</span>
-    <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">&gt;</span> <span class="identifier">v</span> <span class="special">=</span> <span class="keyword">try</span><span class="special">();</span>
-
-    <span class="comment">// The following intended to pass the value of 'v' to foo():
-</span>    <span class="identifier">foo</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>
-    <span class="comment">// But instead, the initialization state is passed
-</span>    <span class="comment">// due to a typo: it should have been foo(*v).
-</span><span class="special">}</span>
-</pre>
-<p>
-      The only implicit conversion is to <code class="computeroutput"><span class="keyword">bool</span></code>,
-      and it is safe in the sense that typical integral promotions don't apply (i.e.
-      if <code class="computeroutput"><span class="identifier">foo</span><span class="special">()</span></code>
-      takes an <code class="computeroutput"><span class="keyword">int</span></code> instead, it won't
-      compile).
-    </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="in_place_factories.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="exception_safety_guarantees.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
@@ -1,125 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Acknowledgments</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="prev" href="dependencies_and_portability.html" title="Dependencies and Portability">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="dependencies_and_portability.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_optional.acknowledgments"></a><a class="link" href="acknowledgments.html" title="Acknowledgments">Acknowledgments</a>
-</h2></div></div></div>
-<a name="boost_optional.acknowledgments.pre_formal_review"></a><h4>
-<a name="boost_optional.acknowledgments.pre_formal_review-heading"></a>
-      <a class="link" href="acknowledgments.html#boost_optional.acknowledgments.pre_formal_review">Pre-formal
-      review</a>
-    </h4>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          Peter Dimov suggested the name 'optional', and was the first to point out
-          the need for aligned storage.
-        </li>
-<li class="listitem">
-          Douglas Gregor developed 'type_with_alignment', and later Eric Friedman
-          coded 'aligned_storage', which are the core of the optional class implementation.
-        </li>
-<li class="listitem">
-          Andrei Alexandrescu and Brian Parker also worked with aligned storage techniques
-          and their work influenced the current implementation.
-        </li>
-<li class="listitem">
-          Gennadiy Rozental made extensive and important comments which shaped the
-          design.
-        </li>
-<li class="listitem">
-          Vesa Karvonen and Douglas Gregor made quite useful comparisons between
-          optional, variant and any; and made other relevant comments.
-        </li>
-<li class="listitem">
-          Douglas Gregor and Peter Dimov commented on comparisons and evaluation
-          in boolean contexts.
-        </li>
-<li class="listitem">
-          Eric Friedman helped understand the issues involved with aligned storage,
-          move/copy operations and exception safety.
-        </li>
-<li class="listitem">
-          Many others have participated with useful comments: Aleksey Gurotov, Kevlin
-          Henney, David Abrahams, and others I can't recall.
-        </li>
-</ul></div>
-<a name="boost_optional.acknowledgments.post_formal_review"></a><h4>
-<a name="boost_optional.acknowledgments.post_formal_review-heading"></a>
-      <a class="link" href="acknowledgments.html#boost_optional.acknowledgments.post_formal_review">Post-formal
-      review</a>
-    </h4>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          William Kempf carefully considered the originally proposed interface and
-          suggested the new interface which is currently used. He also started and
-          fueled the discussion about the analogy optional&lt;&gt;/smart pointer
-          and about relational operators.
-        </li>
-<li class="listitem">
-          Peter Dimov, Joel de Guzman, David Abrahams, Tanton Gibbs and Ian Hanson
-          focused on the relational semantics of optional (originally undefined);
-          concluding with the fact that the pointer-like interface doesn't make it
-          a pointer so it shall have deep relational operators.
-        </li>
-<li class="listitem">
-          Augustus Saunders also explored the different relational semantics between
-          optional&lt;&gt; and a pointer and developed the OptionalPointee concept
-          as an aid against potential conflicts on generic code.
-        </li>
-<li class="listitem">
-          Joel de Guzman noticed that optional&lt;&gt; can be seen as an API on top
-          of variant&lt;T,nil_t&gt;.
-        </li>
-<li class="listitem">
-          Dave Gomboc explained the meaning and usage of the Haskell analog to optional&lt;&gt;:
-          the Maybe type constructor (analogy originally pointed out by David Sankel).
-        </li>
-<li class="listitem">
-          Other comments were posted by Vincent Finn, Anthony Williams, Ed Brey,
-          Rob Stewart, and others.
-        </li>
-<li class="listitem">
-          Joel de Guzman made the case for the support of references and helped with
-          the proper semantics.
-        </li>
-<li class="listitem">
-          Mat Marcus shown the virtues of a value-oriented interface, influencing
-          the current design, and contributed the idea of "none".
-        </li>
-</ul></div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="dependencies_and_portability.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
-</div>
-</body>
-</html>
@@ -1,48 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Dependencies and Portability</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="prev" href="implementation_notes.html" title="Implementation Notes">
-<link rel="next" href="acknowledgments.html" title="Acknowledgments">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="implementation_notes.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgments.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_optional.dependencies_and_portability"></a><a class="link" href="dependencies_and_portability.html" title="Dependencies and Portability">Dependencies
-    and Portability</a>
-</h2></div></div></div>
-<p>
-      The implementation uses <code class="computeroutput"><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">alignment_of</span><span class="special">.</span><span class="identifier">hpp</span></code> and
-      <code class="computeroutput"><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">type_with_alignment</span><span class="special">.</span><span class="identifier">hpp</span></code>
-    </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="implementation_notes.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgments.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
@@ -1,413 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Development</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="prev" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="next" href="synopsis.html" title="Synopsis">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="synopsis.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_optional.development"></a><a class="link" href="development.html" title="Development">Development</a>
-</h2></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="development.html#boost_optional.development.the_models">The models</a></span></dt>
-<dt><span class="section"><a href="development.html#boost_optional.development.the_semantics">The semantics</a></span></dt>
-<dt><span class="section"><a href="development.html#boost_optional.development.the_interface">The Interface</a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_optional.development.the_models"></a><a class="link" href="development.html#boost_optional.development.the_models" title="The models">The models</a>
-</h3></div></div></div>
-<p>
-        In C++, we can <span class="emphasis"><em>declare</em></span> an object (a variable) of type
-        <code class="computeroutput"><span class="identifier">T</span></code>, and we can give this variable
-        an <span class="emphasis"><em>initial value</em></span> (through an <span class="emphasis"><em>initializer</em></span>.
-        (c.f. 8.5)). When a declaration includes a non-empty initializer (an initial
-        value is given), it is said that the object has been initialized. If the
-        declaration uses an empty initializer (no initial value is given), and neither
-        default nor value initialization applies, it is said that the object is
-        <span class="bold"><strong>uninitialized</strong></span>. Its actual value exist but
-        has an <span class="emphasis"><em>indeterminate initial value</em></span> (c.f. 8.5.9). <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> intends
-        to formalize the notion of initialization (or lack of it) allowing a program
-        to test whether an object has been initialized and stating that access to
-        the value of an uninitialized object is undefined behavior. That is, when
-        a variable is declared as <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
-        and no initial value is given, the variable is <span class="emphasis"><em>formally</em></span>
-        uninitialized. A formally uninitialized optional object has conceptually
-        no value at all and this situation can be tested at runtime. It is formally
-        <span class="emphasis"><em>undefined behavior</em></span> to try to access the value of an
-        uninitialized optional. An uninitialized optional can be assigned a value,
-        in which case its initialization state changes to initialized. Furthermore,
-        given the formal treatment of initialization states in optional objects,
-        it is even possible to reset an optional to <span class="emphasis"><em>uninitialized</em></span>.
-      </p>
-<p>
-        In C++ there is no formal notion of uninitialized objects, which means that
-        objects always have an initial value even if indeterminate. As discussed
-        on the previous section, this has a drawback because you need additional
-        information to tell if an object has been effectively initialized. One of
-        the typical ways in which this has been historically dealt with is via a
-        special value: <code class="computeroutput"><span class="identifier">EOF</span></code>, <code class="computeroutput"><span class="identifier">npos</span></code>, -1, etc... This is equivalent to
-        adding the special value to the set of possible values of a given type. This
-        super set of <code class="computeroutput"><span class="identifier">T</span></code> plus some
-        <span class="emphasis"><em>nil_t</em></span>&#8212;were <code class="computeroutput"><span class="identifier">nil_t</span></code>
-        is some stateless POD-can be modeled in modern languages as a <span class="bold"><strong>discriminated
-        union</strong></span> of T and nil_t. Discriminated unions are often called <span class="emphasis"><em>variants</em></span>.
-        A variant has a <span class="emphasis"><em>current type</em></span>, which in our case is either
-        <code class="computeroutput"><span class="identifier">T</span></code> or <code class="computeroutput"><span class="identifier">nil_t</span></code>.
-        Using the <a href="../../../../variant/index.html" target="_top">Boost.Variant</a>
-        library, this model can be implemented in terms of <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">variant</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">nil_t</span><span class="special">&gt;</span></code>.
-        There is precedent for a discriminated union as a model for an optional value:
-        the <a href="http://www.haskell.org/" target="_top">Haskell</a> <span class="bold"><strong>Maybe</strong></span>
-        built-in type constructor. Thus, a discriminated union <code class="computeroutput"><span class="identifier">T</span><span class="special">+</span><span class="identifier">nil_t</span></code>
-        serves as a conceptual foundation.
-      </p>
-<p>
-        A <code class="computeroutput"><span class="identifier">variant</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">nil_t</span><span class="special">&gt;</span></code> follows naturally from the traditional
-        idiom of extending the range of possible values adding an additional sentinel
-        value with the special meaning of <span class="emphasis"><em>Nothing</em></span>. However,
-        this additional <span class="emphasis"><em>Nothing</em></span> value is largely irrelevant
-        for our purpose since our goal is to formalize the notion of uninitialized
-        objects and, while a special extended value can be used to convey that meaning,
-        it is not strictly necessary in order to do so.
-      </p>
-<p>
-        The observation made in the last paragraph about the irrelevant nature of
-        the additional <code class="computeroutput"><span class="identifier">nil_t</span></code> with
-        respect to <span class="underline">purpose</span> of <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> suggests
-        an alternative model: a <span class="emphasis"><em>container</em></span> that either has a
-        value of <code class="computeroutput"><span class="identifier">T</span></code> or nothing.
-      </p>
-<p>
-        As of this writing I don't know of any precedent for a variable-size fixed-capacity
-        (of 1) stack-based container model for optional values, yet I believe this
-        is the consequence of the lack of practical implementations of such a container
-        rather than an inherent shortcoming of the container model.
-      </p>
-<p>
-        In any event, both the discriminated-union or the single-element container
-        models serve as a conceptual ground for a class representing optional&#8212;i.e.
-        possibly uninitialized&#8212;objects. For instance, these models show the <span class="emphasis"><em>exact</em></span>
-        semantics required for a wrapper of optional values:
-      </p>
-<p>
-        Discriminated-union:
-      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-            <span class="bold"><strong>deep-copy</strong></span> semantics: copies of the variant
-            implies copies of the value.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>deep-relational</strong></span> semantics: comparisons
-            between variants matches both current types and values
-          </li>
-<li class="listitem">
-            If the variant's current type is <code class="computeroutput"><span class="identifier">T</span></code>,
-            it is modeling an <span class="emphasis"><em>initialized</em></span> optional.
-          </li>
-<li class="listitem">
-            If the variant's current type is not <code class="computeroutput"><span class="identifier">T</span></code>,
-            it is modeling an <span class="emphasis"><em>uninitialized</em></span> optional.
-          </li>
-<li class="listitem">
-            Testing if the variant's current type is <code class="computeroutput"><span class="identifier">T</span></code>
-            models testing if the optional is initialized
-          </li>
-<li class="listitem">
-            Trying to extract a <code class="computeroutput"><span class="identifier">T</span></code>
-            from a variant when its current type is not <code class="computeroutput"><span class="identifier">T</span></code>,
-            models the undefined behavior of trying to access the value of an uninitialized
-            optional
-          </li>
-</ul></div>
-<p>
-        Single-element container:
-      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-            <span class="bold"><strong>deep-copy</strong></span> semantics: copies of the container
-            implies copies of the value.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>deep-relational</strong></span> semantics: comparisons
-            between containers compare container size and if match, contained value
-          </li>
-<li class="listitem">
-            If the container is not empty (contains an object of type <code class="computeroutput"><span class="identifier">T</span></code>), it is modeling an <span class="emphasis"><em>initialized</em></span>
-            optional.
-          </li>
-<li class="listitem">
-            If the container is empty, it is modeling an <span class="emphasis"><em>uninitialized</em></span>
-            optional.
-          </li>
-<li class="listitem">
-            Testing if the container is empty models testing if the optional is initialized
-          </li>
-<li class="listitem">
-            Trying to extract a <code class="computeroutput"><span class="identifier">T</span></code>
-            from an empty container models the undefined behavior of trying to access
-            the value of an uninitialized optional
-          </li>
-</ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_optional.development.the_semantics"></a><a class="link" href="development.html#boost_optional.development.the_semantics" title="The semantics">The semantics</a>
-</h3></div></div></div>
-<p>
-        Objects of type <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
-        are intended to be used in places where objects of type <code class="computeroutput"><span class="identifier">T</span></code>
-        would but which might be uninitialized. Hence, <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>'s
-        purpose is to formalize the additional possibly uninitialized state. From
-        the perspective of this role, <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
-        can have the same operational semantics of <code class="computeroutput"><span class="identifier">T</span></code>
-        plus the additional semantics corresponding to this special state. As such,
-        <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> could
-        be thought of as a <span class="emphasis"><em>supertype</em></span> of <code class="computeroutput"><span class="identifier">T</span></code>.
-        Of course, we can't do that in C++, so we need to compose the desired semantics
-        using a different mechanism. Doing it the other way around, that is, making
-        <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> a
-        <span class="emphasis"><em>subtype</em></span> of <code class="computeroutput"><span class="identifier">T</span></code>
-        is not only conceptually wrong but also impractical: it is not allowed to
-        derive from a non-class type, such as a built-in type.
-      </p>
-<p>
-        We can draw from the purpose of <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
-        the required basic semantics:
-      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-            <span class="bold"><strong>Default Construction:</strong></span> To introduce a
-            formally uninitialized wrapped object.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Direct Value Construction via copy:</strong></span>
-            To introduce a formally initialized wrapped object whose value is obtained
-            as a copy of some object.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Deep Copy Construction:</strong></span> To obtain a
-            new yet equivalent wrapped object.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Direct Value Assignment (upon initialized):</strong></span>
-            To assign a value to the wrapped object.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Direct Value Assignment (upon uninitialized):</strong></span>
-            To initialize the wrapped object with a value obtained as a copy of some
-            object.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Assignment (upon initialized):</strong></span> To assign
-            to the wrapped object the value of another wrapped object.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Assignment (upon uninitialized):</strong></span> To
-            initialize the wrapped object with value of another wrapped object.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Deep Relational Operations (when supported by the
-            type T):</strong></span> To compare wrapped object values taking into account
-            the presence of uninitialized states.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Value access:</strong></span> To unwrap the wrapped
-            object.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Initialization state query:</strong></span> To determine
-            if the object is formally initialized or not.
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>Swap:</strong></span> To exchange wrapped objects. (with
-            whatever exception safety guarantees are provided by <code class="computeroutput"><span class="identifier">T</span></code>'s
-            swap).
-          </li>
-<li class="listitem">
-            <span class="bold"><strong>De-initialization:</strong></span> To release the wrapped
-            object (if any) and leave the wrapper in the uninitialized state.
-          </li>
-</ul></div>
-<p>
-        Additional operations are useful, such as converting constructors and converting
-        assignments, in-place construction and assignment, and safe value access
-        via a pointer to the wrapped object or null.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_optional.development.the_interface"></a><a class="link" href="development.html#boost_optional.development.the_interface" title="The Interface">The Interface</a>
-</h3></div></div></div>
-<p>
-        Since the purpose of optional is to allow us to use objects with a formal
-        uninitialized additional state, the interface could try to follow the interface
-        of the underlying <code class="computeroutput"><span class="identifier">T</span></code> type
-        as much as possible. In order to choose the proper degree of adoption of
-        the native <code class="computeroutput"><span class="identifier">T</span></code> interface, the
-        following must be noted: Even if all the operations supported by an instance
-        of type <code class="computeroutput"><span class="identifier">T</span></code> are defined for
-        the entire range of values for such a type, an <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
-        extends such a set of values with a new value for which most (otherwise valid)
-        operations are not defined in terms of <code class="computeroutput"><span class="identifier">T</span></code>.
-      </p>
-<p>
-        Furthermore, since <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
-        itself is merely a <code class="computeroutput"><span class="identifier">T</span></code> wrapper
-        (modeling a <code class="computeroutput"><span class="identifier">T</span></code> supertype),
-        any attempt to define such operations upon uninitialized optionals will be
-        totally artificial w.r.t. <code class="computeroutput"><span class="identifier">T</span></code>.
-      </p>
-<p>
-        This library chooses an interface which follows from <code class="computeroutput"><span class="identifier">T</span></code>'s
-        interface only for those operations which are well defined (w.r.t the type
-        <code class="computeroutput"><span class="identifier">T</span></code>) even if any of the operands
-        are uninitialized. These operations include: construction, copy-construction,
-        assignment, swap and relational operations.
-      </p>
-<p>
-        For the value access operations, which are undefined (w.r.t the type <code class="computeroutput"><span class="identifier">T</span></code>) when the operand is uninitialized, a
-        different interface is chosen (which will be explained next).
-      </p>
-<p>
-        Also, the presence of the possibly uninitialized state requires additional
-        operations not provided by <code class="computeroutput"><span class="identifier">T</span></code>
-        itself which are supported by a special interface.
-      </p>
-<a name="boost_optional.development.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_untitialized_optional_objects__the_operators___and___gt_"></a><h5>
-<a name="boost_optional.development.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_untitialized_optional_objects__the_operators___and___gt_-heading"></a>
-        <a class="link" href="development.html#boost_optional.development.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_untitialized_optional_objects__the_operators___and___gt_">Lexically-hinted
-        Value Access in the presence of possibly untitialized optional objects: The
-        operators * and -&gt;</a>
-      </h5>
-<p>
-        A relevant feature of a pointer is that it can have a <span class="bold"><strong>null
-        pointer value</strong></span>. This is a <span class="emphasis"><em>special</em></span> value which
-        is used to indicate that the pointer is not referring to any object at all.
-        In other words, null pointer values convey the notion of nonexistent objects.
-      </p>
-<p>
-        This meaning of the null pointer value allowed pointers to became a <span class="emphasis"><em>de
-        facto</em></span> standard for handling optional objects because all you have
-        to do to refer to a value which you don't really have is to use a null pointer
-        value of the appropriate type. Pointers have been used for decades&#8212;from
-        the days of C APIs to modern C++ libraries&#8212;to <span class="emphasis"><em>refer</em></span>
-        to optional (that is, possibly nonexistent) objects; particularly as optional
-        arguments to a function, but also quite often as optional data members.
-      </p>
-<p>
-        The possible presence of a null pointer value makes the operations that access
-        the pointee's value possibly undefined, therefore, expressions which use
-        dereference and access operators, such as: <code class="computeroutput"><span class="special">(</span>
-        <span class="special">*</span><span class="identifier">p</span> <span class="special">=</span> <span class="number">2</span> <span class="special">)</span></code>
-        and <code class="computeroutput"><span class="special">(</span> <span class="identifier">p</span><span class="special">-&gt;</span><span class="identifier">foo</span><span class="special">()</span> <span class="special">)</span></code>, implicitly
-        convey the notion of optionality, and this information is tied to the <span class="emphasis"><em>syntax</em></span>
-        of the expressions. That is, the presence of operators <code class="computeroutput"><span class="special">*</span></code>
-        and <code class="computeroutput"><span class="special">-&gt;</span></code> tell by themselves
-        &#8212;without any additional context&#8212; that the expression will be undefined
-        unless the implied pointee actually exist.
-      </p>
-<p>
-        Such a <span class="emphasis"><em>de facto</em></span> idiom for referring to optional objects
-        can be formalized in the form of a concept: the <a href="../../../../utility/OptionalPointee.html" target="_top">OptionalPointee</a>
-        concept. This concept captures the syntactic usage of operators <code class="computeroutput"><span class="special">*</span></code>, <code class="computeroutput"><span class="special">-&gt;</span></code>
-        and conversion to <code class="computeroutput"><span class="keyword">bool</span></code> to convey
-        the notion of optionality.
-      </p>
-<p>
-        However, pointers are good to <span class="underline">refer</span>
-        to optional objects, but not particularly good to handle the optional objects
-        in all other respects, such as initializing or moving/copying them. The problem
-        resides in the shallow-copy of pointer semantics: if you need to effectively
-        move or copy the object, pointers alone are not enough. The problem is that
-        copies of pointers do not imply copies of pointees. For example, as was discussed
-        in the motivation, pointers alone cannot be used to return optional objects
-        from a function because the object must move outside from the function and
-        into the caller's context.
-      </p>
-<p>
-        A solution to the shallow-copy problem that is often used is to resort to
-        dynamic allocation and use a smart pointer to automatically handle the details
-        of this. For example, if a function is to optionally return an object <code class="computeroutput"><span class="identifier">X</span></code>, it can use <code class="computeroutput"><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;</span></code>
-        as the return value. However, this requires dynamic allocation of <code class="computeroutput"><span class="identifier">X</span></code>. If <code class="computeroutput"><span class="identifier">X</span></code>
-        is a built-in or small POD, this technique is very poor in terms of required
-        resources. Optional objects are essentially values so it is very convenient
-        to be able to use automatic storage and deep-copy semantics to manipulate
-        optional values just as we do with ordinary values. Pointers do not have
-        this semantics, so are inappropriate for the initialization and transport
-        of optional values, yet are quite convenient for handling the access to the
-        possible undefined value because of the idiomatic aid present in the <a href="../../../../utility/OptionalPointee.html" target="_top">OptionalPointee</a> concept
-        incarnated by pointers.
-      </p>
-<a name="boost_optional.development.the_interface.optional_lt_t_gt__as_a_model_of_optionalpointee"></a><h5>
-<a name="boost_optional.development.the_interface.optional_lt_t_gt__as_a_model_of_optionalpointee-heading"></a>
-        <a class="link" href="development.html#boost_optional.development.the_interface.optional_lt_t_gt__as_a_model_of_optionalpointee">Optional&lt;T&gt;
-        as a model of OptionalPointee</a>
-      </h5>
-<p>
-        For value access operations <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;&gt;</span></code> uses operators <code class="computeroutput"><span class="special">*</span></code>
-        and <code class="computeroutput"><span class="special">-&gt;</span></code> to lexically warn
-        about the possibly uninitialized state appealing to the familiar pointer
-        semantics w.r.t. to null pointers.
-      </p>
-<div class="warning"><table border="0" summary="Warning">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../../doc/src/images/warning.png"></td>
-<th align="left">Warning</th>
-</tr>
-<tr><td align="left" valign="top"><p>
-          However, it is particularly important to note that <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;&gt;</span></code> objects are not pointers. <span class="underline"><code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;&gt;</span></code> is not, and does not model, a pointer</span>.
-        </p></td></tr>
-</table></div>
-<p>
-        For instance, <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;&gt;</span></code>
-        does not have shallow-copy so does not alias: two different optionals never
-        refer to the <span class="emphasis"><em>same</em></span> value unless <code class="computeroutput"><span class="identifier">T</span></code>
-        itself is a reference (but may have <span class="emphasis"><em>equivalent</em></span> values).
-        The difference between an <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
-        and a pointer must be kept in mind, particularly because the semantics of
-        relational operators are different: since <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
-        is a value-wrapper, relational operators are deep: they compare optional
-        values; but relational operators for pointers are shallow: they do not compare
-        pointee values. As a result, you might be able to replace <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
-        by <code class="computeroutput"><span class="identifier">T</span><span class="special">*</span></code>
-        on some situations but not always. Specifically, on generic code written
-        for both, you cannot use relational operators directly, and must use the
-        template functions <a href="../../../../utility/OptionalPointee.html#equal" target="_top"><code class="computeroutput"><span class="identifier">equal_pointees</span><span class="special">()</span></code></a>
-        and <a href="../../../../utility/OptionalPointee.html#less" target="_top"><code class="computeroutput"><span class="identifier">less_pointees</span><span class="special">()</span></code></a>
-        instead.
-      </p>
-</div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="synopsis.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
@@ -1,147 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Examples</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="prev" href="detailed_semantics.html" title="Detailed Semantics">
-<link rel="next" href="optional_references.html" title="Optional references">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="detailed_semantics.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="optional_references.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_optional.examples"></a><a class="link" href="examples.html" title="Examples">Examples</a>
-</h2></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="examples.html#boost_optional.examples.optional_return_values">Optional
-      return values</a></span></dt>
-<dt><span class="section"><a href="examples.html#boost_optional.examples.optional_local_variables">Optional
-      local variables</a></span></dt>
-<dt><span class="section"><a href="examples.html#boost_optional.examples.optional_data_members">Optional
-      data members</a></span></dt>
-<dt><span class="section"><a href="examples.html#boost_optional.examples.bypassing_expensive_unnecessary_default_construction">Bypassing
-      expensive unnecessary default construction</a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_optional.examples.optional_return_values"></a><a class="link" href="examples.html#boost_optional.examples.optional_return_values" title="Optional return values">Optional
-      return values</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;</span> <span class="identifier">get_async_input</span><span class="special">()</span>
-<span class="special">{</span>
-    <span class="keyword">if</span> <span class="special">(</span> <span class="special">!</span><span class="identifier">queue</span><span class="special">.</span><span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span>
-        <span class="keyword">return</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;(</span><span class="identifier">queue</span><span class="special">.</span><span class="identifier">top</span><span class="special">());</span>
-    <span class="keyword">else</span> <span class="keyword">return</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;();</span> <span class="comment">// uninitialized
-</span><span class="special">}</span>
-
-<span class="keyword">void</span> <span class="identifier">receive_async_message</span><span class="special">()</span>
-<span class="special">{</span>
-    <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;</span> <span class="identifier">rcv</span> <span class="special">;</span>
-    <span class="comment">// The safe boolean conversion from 'rcv' is used here.
-</span>    <span class="keyword">while</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">rcv</span> <span class="special">=</span> <span class="identifier">get_async_input</span><span class="special">())</span> <span class="special">&amp;&amp;</span> <span class="special">!</span><span class="identifier">timeout</span><span class="special">()</span> <span class="special">)</span>
-        <span class="identifier">output</span><span class="special">(*</span><span class="identifier">rcv</span><span class="special">);</span>
-<span class="special">}</span>
-</pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_optional.examples.optional_local_variables"></a><a class="link" href="examples.html#boost_optional.examples.optional_local_variables" title="Optional local variables">Optional
-      local variables</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">name</span> <span class="special">;</span>
-<span class="keyword">if</span> <span class="special">(</span> <span class="identifier">database</span><span class="special">.</span><span class="identifier">open</span><span class="special">()</span> <span class="special">)</span>
-<span class="special">{</span>
-    <span class="identifier">name</span><span class="special">.</span><span class="identifier">reset</span> <span class="special">(</span> <span class="identifier">database</span><span class="special">.</span><span class="identifier">lookup</span><span class="special">(</span><span class="identifier">employer_name</span><span class="special">)</span> <span class="special">)</span> <span class="special">;</span>
-<span class="special">}</span>
-<span class="keyword">else</span>
-<span class="special">{</span>
-    <span class="keyword">if</span> <span class="special">(</span> <span class="identifier">can_ask_user</span> <span class="special">)</span>
-        <span class="identifier">name</span><span class="special">.</span><span class="identifier">reset</span> <span class="special">(</span> <span class="identifier">user</span><span class="special">.</span><span class="identifier">ask</span><span class="special">(</span><span class="identifier">employer_name</span><span class="special">)</span> <span class="special">)</span> <span class="special">;</span>
-<span class="special">}</span>
-
-<span class="keyword">if</span> <span class="special">(</span> <span class="identifier">name</span> <span class="special">)</span>
-    <span class="identifier">print</span><span class="special">(*</span><span class="identifier">name</span><span class="special">);</span>
-<span class="keyword">else</span> <span class="identifier">print</span><span class="special">(</span><span class="string">"employer's name not found!"</span><span class="special">);</span>
-</pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_optional.examples.optional_data_members"></a><a class="link" href="examples.html#boost_optional.examples.optional_data_members" title="Optional data members">Optional
-      data members</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">figure</span>
-<span class="special">{</span>
-    <span class="keyword">public</span><span class="special">:</span>
-
-    <span class="identifier">figure</span><span class="special">()</span>
-    <span class="special">{</span>
-        <span class="comment">// data member 'm_clipping_rect' is uninitialized at this point.
-</span>    <span class="special">}</span>
-
-    <span class="keyword">void</span> <span class="identifier">clip_in_rect</span> <span class="special">(</span> <span class="identifier">rect</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rect</span> <span class="special">)</span>
-    <span class="special">{</span>
-        <span class="special">....</span>
-        <span class="identifier">m_clipping_rect</span><span class="special">.</span><span class="identifier">reset</span> <span class="special">(</span> <span class="identifier">rect</span> <span class="special">)</span> <span class="special">;</span> <span class="comment">// initialized here.
-</span>    <span class="special">}</span>
-
-    <span class="keyword">void</span> <span class="identifier">draw</span> <span class="special">(</span> <span class="identifier">canvas</span><span class="special">&amp;</span> <span class="identifier">cvs</span> <span class="special">)</span>
-    <span class="special">{</span>
-        <span class="keyword">if</span> <span class="special">(</span> <span class="identifier">m_clipping_rect</span> <span class="special">)</span>
-            <span class="identifier">do_clipping</span><span class="special">(*</span><span class="identifier">m_clipping_rect</span><span class="special">);</span>
-
-        <span class="identifier">cvs</span><span class="special">.</span><span class="identifier">drawXXX</span><span class="special">(..);</span>
-    <span class="special">}</span>
-
-    <span class="comment">// this can return NULL.
-</span>    <span class="identifier">rect</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">get_clipping_rect</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">get_pointer</span><span class="special">(</span><span class="identifier">m_clipping_rect</span><span class="special">);</span> <span class="special">}</span>
-
-    <span class="keyword">private</span> <span class="special">:</span>
-
-    <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">rect</span><span class="special">&gt;</span> <span class="identifier">m_clipping_rect</span> <span class="special">;</span>
-
-<span class="special">};</span>
-</pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_optional.examples.bypassing_expensive_unnecessary_default_construction"></a><a class="link" href="examples.html#boost_optional.examples.bypassing_expensive_unnecessary_default_construction" title="Bypassing expensive unnecessary default construction">Bypassing
-      expensive unnecessary default construction</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">ExpensiveCtor</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span> <span class="special">;</span>
-<span class="keyword">class</span> <span class="identifier">Fred</span>
-<span class="special">{</span>
-    <span class="identifier">Fred</span><span class="special">()</span> <span class="special">:</span> <span class="identifier">mLargeVector</span><span class="special">(</span><span class="number">10000</span><span class="special">)</span> <span class="special">{}</span>
-
-    <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">ExpensiveCtor</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">mLargeVector</span> <span class="special">;</span>
-<span class="special">}</span> <span class="special">;</span>
-</pre>
-</div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="detailed_semantics.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="optional_references.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
@@ -1,152 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Exception Safety Guarantees</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="prev" href="a_note_about_optional_bool_.html" title="A note about optional&lt;bool&gt;">
-<link rel="next" href="type_requirements.html" title="Type requirements">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="a_note_about_optional_bool_.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="type_requirements.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_optional.exception_safety_guarantees"></a><a class="link" href="exception_safety_guarantees.html" title="Exception Safety Guarantees">Exception Safety
-    Guarantees</a>
-</h2></div></div></div>
-<p>
-      Because of the current implementation (see <a class="link" href="implementation_notes.html" title="Implementation Notes">Implementation
-      Notes</a>), all of the assignment methods:
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code>
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code>
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code>
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">InPlaceFactory</span>
-          <span class="keyword">const</span><span class="special">&amp;</span>
-          <span class="special">)</span></code>
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">TypedInPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory</span>
-          <span class="keyword">const</span><span class="special">&amp;</span>
-          <span class="special">)</span> </code>
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;:::</span><span class="identifier">reset</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span></code>
-        </li>
-</ul></div>
-<p>
-      Can only <span class="emphasis"><em>guarantee</em></span> the <span class="underline">basic
-      exception safety</span>: The lvalue optional is left <span class="underline">uninitialized</span>
-      if an exception is thrown (any previous value is <span class="emphasis"><em>first</em></span>
-      destroyed using <code class="computeroutput"><span class="identifier">T</span><span class="special">::~</span><span class="identifier">T</span><span class="special">()</span></code>)
-    </p>
-<p>
-      On the other hand, the <span class="emphasis"><em>uninitializing</em></span> methods:
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">none_t</span> <span class="special">)</span></code>
-        </li>
-<li class="listitem">
-          <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">reset</span><span class="special">()</span></code>
-        </li>
-</ul></div>
-<p>
-      Provide the no-throw guarantee (assuming a no-throw <code class="computeroutput"><span class="identifier">T</span><span class="special">::~</span><span class="identifier">T</span><span class="special">()</span></code>)
-    </p>
-<p>
-      However, since <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;&gt;</span></code>
-      itself doesn't throw any exceptions, the only source for exceptions here are
-      <code class="computeroutput"><span class="identifier">T</span></code>'s constructor, so if you
-      know the exception guarantees for <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span> <span class="special">(</span>
-      <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code>, you
-      know that <code class="computeroutput"><span class="identifier">optional</span></code>'s assignment
-      and reset has the same guarantees.
-    </p>
-<pre class="programlisting"><span class="comment">//
-</span><span class="comment">// Case 1: Exception thrown during assignment.
-</span><span class="comment">//
-</span><span class="identifier">T</span> <span class="identifier">v0</span><span class="special">(</span><span class="number">123</span><span class="special">);</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">opt0</span><span class="special">(</span><span class="identifier">v0</span><span class="special">);</span>
-<span class="keyword">try</span>
-<span class="special">{</span>
-    <span class="identifier">T</span> <span class="identifier">v1</span><span class="special">(</span><span class="number">456</span><span class="special">);</span>
-    <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">opt1</span><span class="special">(</span><span class="identifier">v1</span><span class="special">);</span>
-    <span class="identifier">opt0</span> <span class="special">=</span> <span class="identifier">opt1</span> <span class="special">;</span>
-
-    <span class="comment">// If no exception was thrown, assignment succeeded.
-</span>    <span class="identifier">assert</span><span class="special">(</span> <span class="special">*</span><span class="identifier">opt0</span> <span class="special">==</span> <span class="identifier">v1</span> <span class="special">)</span> <span class="special">;</span>
-<span class="special">}</span>
-<span class="keyword">catch</span><span class="special">(...)</span>
-<span class="special">{</span>
-    <span class="comment">// If any exception was thrown, 'opt0' is reset to uninitialized.
-</span>    <span class="identifier">assert</span><span class="special">(</span> <span class="special">!</span><span class="identifier">opt0</span> <span class="special">)</span> <span class="special">;</span>
-<span class="special">}</span>
-
-<span class="comment">//
-</span><span class="comment">// Case 2: Exception thrown during reset(v)
-</span><span class="comment">//
-</span><span class="identifier">T</span> <span class="identifier">v0</span><span class="special">(</span><span class="number">123</span><span class="special">);</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">opt</span><span class="special">(</span><span class="identifier">v0</span><span class="special">);</span>
-<span class="keyword">try</span>
-<span class="special">{</span>
-    <span class="identifier">T</span> <span class="identifier">v1</span><span class="special">(</span><span class="number">456</span><span class="special">);</span>
-    <span class="identifier">opt</span><span class="special">.</span><span class="identifier">reset</span> <span class="special">(</span> <span class="identifier">v1</span> <span class="special">)</span> <span class="special">;</span>
-
-    <span class="comment">// If no exception was thrown, reset succeeded.
-</span>    <span class="identifier">assert</span><span class="special">(</span> <span class="special">*</span><span class="identifier">opt</span> <span class="special">==</span> <span class="identifier">v1</span> <span class="special">)</span> <span class="special">;</span>
-<span class="special">}</span>
-<span class="keyword">catch</span><span class="special">(...)</span>
-<span class="special">{</span>
-    <span class="comment">// If any exception was thrown, 'opt' is reset to uninitialized.
-</span>    <span class="identifier">assert</span><span class="special">(</span> <span class="special">!</span><span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span>
-<span class="special">}</span>
-</pre>
-<a name="boost_optional.exception_safety_guarantees.swap"></a><h4>
-<a name="boost_optional.exception_safety_guarantees.swap-heading"></a>
-      <a class="link" href="exception_safety_guarantees.html#boost_optional.exception_safety_guarantees.swap">Swap</a>
-    </h4>
-<p>
-      <code class="computeroutput"><span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;,</span>
-      <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="special">)</span></code> has the same exception guarantee as <code class="computeroutput"><span class="identifier">swap</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;,</span><span class="identifier">T</span><span class="special">&amp;)</span></code>
-      when both optionals are initialized. If only one of the optionals is initialized,
-      it gives the same <span class="emphasis"><em>basic</em></span> exception guarantee as <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">reset</span><span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span></code> (since
-      <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">reset</span><span class="special">()</span></code> doesn't throw). If none of the optionals
-      is initialized, it has no-throw guarantee since it is a no-op.
-    </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="a_note_about_optional_bool_.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="type_requirements.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
@@ -1,55 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Implementation Notes</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="prev" href="type_requirements.html" title="Type requirements">
-<link rel="next" href="dependencies_and_portability.html" title="Dependencies and Portability">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="type_requirements.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="dependencies_and_portability.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_optional.implementation_notes"></a><a class="link" href="implementation_notes.html" title="Implementation Notes">Implementation Notes</a>
-</h2></div></div></div>
-<p>
-      <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is
-      currently implemented using a custom aligned storage facility built from <code class="computeroutput"><span class="identifier">alignment_of</span></code> and <code class="computeroutput"><span class="identifier">type_with_alignment</span></code>
-      (both from Type Traits). It uses a separate boolean flag to indicate the initialization
-      state. Placement new with <code class="computeroutput"><span class="identifier">T</span></code>'s
-      copy constructor and <code class="computeroutput"><span class="identifier">T</span></code>'s destructor
-      are explicitly used to initialize,copy and destroy optional values. As a result,
-      <code class="computeroutput"><span class="identifier">T</span></code>'s default constructor is
-      effectively by-passed, but the exception guarantees are basic. It is planned
-      to replace the current implementation with another with stronger exception
-      safety, such as a future <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">variant</span></code>.
-    </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="type_requirements.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="dependencies_and_portability.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
@@ -1,196 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>In-Place Factories</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="prev" href="rebinding_semantics_for_assignment_of_optional_references.html" title="Rebinding semantics for assignment of optional references">
-<link rel="next" href="a_note_about_optional_bool_.html" title="A note about optional&lt;bool&gt;">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="rebinding_semantics_for_assignment_of_optional_references.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="a_note_about_optional_bool_.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_optional.in_place_factories"></a><a class="link" href="in_place_factories.html" title="In-Place Factories">In-Place Factories</a>
-</h2></div></div></div>
-<p>
-      One of the typical problems with wrappers and containers is that their interfaces
-      usually provide an operation to initialize or assign the contained object as
-      a copy of some other object. This not only requires the underlying type to
-      be <a href="../../../../utility/CopyConstructible.html" target="_top">Copy Constructible</a>,
-      but also requires the existence of a fully constructed object, often temporary,
-      just to follow the copy from:
-    </p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
-<span class="special">{</span>
-    <span class="identifier">X</span> <span class="special">(</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">:::</span><span class="identifier">string</span> <span class="special">)</span> <span class="special">;</span>
-<span class="special">}</span> <span class="special">;</span>
-
-<span class="keyword">class</span> <span class="identifier">W</span>
-<span class="special">{</span>
-    <span class="identifier">X</span> <span class="identifier">wrapped_</span> <span class="special">;</span>
-
-    <span class="keyword">public</span><span class="special">:</span>
-
-    <span class="identifier">W</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span> <span class="special">{}</span>
-<span class="special">}</span> <span class="special">;</span>
-
-<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">()</span>
-<span class="special">{</span>
-    <span class="comment">// Temporary object created.
-</span>    <span class="identifier">W</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">(</span><span class="number">123</span><span class="special">,</span><span class="string">"hello"</span><span class="special">)</span> <span class="special">)</span> <span class="special">;</span>
-<span class="special">}</span>
-</pre>
-<p>
-      A solution to this problem is to support direct construction of the contained
-      object right in the container's storage. In this scheme, the user only needs
-      to supply the arguments to the constructor to use in the wrapped object construction.
-    </p>
-<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">W</span>
-<span class="special">{</span>
-    <span class="identifier">X</span> <span class="identifier">wrapped_</span> <span class="special">;</span>
-
-    <span class="keyword">public</span><span class="special">:</span>
-
-    <span class="identifier">W</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span> <span class="special">{}</span>
-    <span class="identifier">W</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">a0</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">a1</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">a0</span><span class="special">,</span><span class="identifier">a1</span><span class="special">)</span> <span class="special">{}</span>
-<span class="special">}</span> <span class="special">;</span>
-
-<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">()</span>
-<span class="special">{</span>
-    <span class="comment">// Wrapped object constructed in-place
-</span>    <span class="comment">// No temporary created.
-</span>    <span class="identifier">W</span> <span class="special">(</span><span class="number">123</span><span class="special">,</span><span class="string">"hello"</span><span class="special">)</span> <span class="special">;</span>
-<span class="special">}</span>
-</pre>
-<p>
-      A limitation of this method is that it doesn't scale well to wrapped objects
-      with multiple constructors nor to generic code were the constructor overloads
-      are unknown.
-    </p>
-<p>
-      The solution presented in this library is the family of <span class="bold"><strong>InPlaceFactories</strong></span>
-      and <span class="bold"><strong>TypedInPlaceFactories</strong></span>. These factories
-      are a family of classes which encapsulate an increasing number of arbitrary
-      constructor parameters and supply a method to construct an object of a given
-      type using those parameters at an address specified by the user via placement
-      new.
-    </p>
-<p>
-      For example, one member of this family looks like:
-    </p>
-<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span><span class="keyword">class</span> <span class="identifier">A0</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">&gt;</span>
-<span class="keyword">class</span> <span class="identifier">TypedInPlaceFactory2</span>
-<span class="special">{</span>
-    <span class="identifier">A0</span> <span class="identifier">m_a0</span> <span class="special">;</span> <span class="identifier">A1</span> <span class="identifier">m_a1</span> <span class="special">;</span>
-
-    <span class="keyword">public</span><span class="special">:</span>
-
-    <span class="identifier">TypedInPlaceFactory2</span><span class="special">(</span> <span class="identifier">A0</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">a0</span><span class="special">,</span> <span class="identifier">A1</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">a1</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_a0</span><span class="special">(</span><span class="identifier">a0</span><span class="special">),</span> <span class="identifier">m_a1</span><span class="special">(</span><span class="identifier">a1</span><span class="special">)</span> <span class="special">{}</span>
-
-    <span class="keyword">void</span> <span class="identifier">construct</span> <span class="special">(</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">p</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">new</span> <span class="special">(</span><span class="identifier">p</span><span class="special">)</span> <span class="identifier">T</span><span class="special">(</span><span class="identifier">m_a0</span><span class="special">,</span><span class="identifier">m_a1</span><span class="special">)</span> <span class="special">;</span> <span class="special">}</span>
- <span class="special">}</span> <span class="special">;</span>
-</pre>
-<p>
-      A wrapper class aware of this can use it as:
-    </p>
-<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">W</span>
-<span class="special">{</span>
-    <span class="identifier">X</span> <span class="identifier">wrapped_</span> <span class="special">;</span>
-
-    <span class="keyword">public</span><span class="special">:</span>
-
-    <span class="identifier">W</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span> <span class="special">{}</span>
-    <span class="identifier">W</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory2</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">fac</span> <span class="special">)</span> <span class="special">{</span> <span class="identifier">fac</span><span class="special">.</span><span class="identifier">construct</span><span class="special">(&amp;</span><span class="identifier">wrapped_</span><span class="special">)</span> <span class="special">;</span> <span class="special">}</span>
-<span class="special">}</span> <span class="special">;</span>
-
-<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">()</span>
-<span class="special">{</span>
-    <span class="comment">// Wrapped object constructed in-place via a TypedInPlaceFactory.
-</span>    <span class="comment">// No temporary created.
-</span>    <span class="identifier">W</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory2</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">,</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;(</span><span class="number">123</span><span class="special">,</span><span class="string">"hello"</span><span class="special">))</span> <span class="special">;</span>
-<span class="special">}</span>
-</pre>
-<p>
-      The factories are divided in two groups:
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          <span class="underline">TypedInPlaceFactories</span>: those which
-          take the target type as a primary template parameter.
-        </li>
-<li class="listitem">
-          <span class="underline">InPlaceFactories</span>: those with a template
-          <code class="computeroutput"><span class="identifier">construct</span><span class="special">(</span><span class="keyword">void</span><span class="special">*)</span></code> member
-          function taking the target type.
-        </li>
-</ul></div>
-<p>
-      Within each group, all the family members differ only in the number of parameters
-      allowed.
-    </p>
-<p>
-      This library provides an overloaded set of helper template functions to construct
-      these factories without requiring unnecessary template parameters:
-    </p>
-<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">A0</span><span class="special">,...,</span><span class="keyword">class</span> <span class="identifier">AN</span><span class="special">&gt;</span>
-<span class="identifier">InPlaceFactoryN</span> <span class="special">&lt;</span><span class="identifier">A0</span><span class="special">,...,</span><span class="identifier">AN</span><span class="special">&gt;</span> <span class="identifier">in_place</span> <span class="special">(</span> <span class="identifier">A0</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">a0</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">AN</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">aN</span><span class="special">)</span> <span class="special">;</span>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span><span class="keyword">class</span> <span class="identifier">A0</span><span class="special">,...,</span><span class="keyword">class</span> <span class="identifier">AN</span><span class="special">&gt;</span>
-<span class="identifier">TypedInPlaceFactoryN</span> <span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">A0</span><span class="special">,...,</span><span class="identifier">AN</span><span class="special">&gt;</span> <span class="identifier">in_place</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">a0</span><span class="special">,</span> <span class="identifier">A0</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">a0</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">AN</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">aN</span><span class="special">)</span> <span class="special">;</span>
-</pre>
-<p>
-      In-place factories can be used generically by the wrapper and user as follows:
-    </p>
-<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">W</span>
-<span class="special">{</span>
-    <span class="identifier">X</span> <span class="identifier">wrapped_</span> <span class="special">;</span>
-
-    <span class="keyword">public</span><span class="special">:</span>
-
-    <span class="identifier">W</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span> <span class="special">{}</span>
-
-    <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">InPlaceFactory</span> <span class="special">&gt;</span>
-    <span class="identifier">W</span> <span class="special">(</span> <span class="identifier">InPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">fac</span> <span class="special">)</span> <span class="special">{</span> <span class="identifier">fac</span><span class="special">.</span><span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;</span><span class="identifier">construct</span><span class="special">(&amp;</span><span class="identifier">wrapped_</span><span class="special">)</span> <span class="special">;</span> <span class="special">}</span>
-
-<span class="special">}</span> <span class="special">;</span>
-
-<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">()</span>
-<span class="special">{</span>
-    <span class="comment">// Wrapped object constructed in-place via a InPlaceFactory.
-</span>    <span class="comment">// No temporary created.
-</span>    <span class="identifier">W</span> <span class="special">(</span> <span class="identifier">in_place</span><span class="special">(</span><span class="number">123</span><span class="special">,</span><span class="string">"hello"</span><span class="special">)</span> <span class="special">)</span> <span class="special">;</span>
-<span class="special">}</span>
-</pre>
-<p>
-      The factories are implemented in the headers: <a href="../../../../../boost/utility/in_place_factory.hpp" target="_top">in_place_factory.hpp</a>
-      and <a href="../../../../../boost/utility/typed_in_place_factory.hpp" target="_top">typed_in_place_factory.hpp</a>
-    </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="rebinding_semantics_for_assignment_of_optional_references.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="a_note_about_optional_bool_.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
@@ -1,85 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Optional references</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="prev" href="examples.html" title="Examples">
-<link rel="next" href="rebinding_semantics_for_assignment_of_optional_references.html" title="Rebinding semantics for assignment of optional references">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="examples.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rebinding_semantics_for_assignment_of_optional_references.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_optional.optional_references"></a><a class="link" href="optional_references.html" title="Optional references">Optional references</a>
-</h2></div></div></div>
-<p>
-      This library allows the template parameter <code class="computeroutput"><span class="identifier">T</span></code>
-      to be of reference type: <code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span></code>, and to some extent, <code class="computeroutput"><span class="identifier">T</span>
-      <span class="keyword">const</span><span class="special">&amp;</span></code>.
-    </p>
-<p>
-      However, since references are not real objects some restrictions apply and
-      some operations are not available in this case:
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          Converting constructors
-        </li>
-<li class="listitem">
-          Converting assignment
-        </li>
-<li class="listitem">
-          InPlace construction
-        </li>
-<li class="listitem">
-          InPlace assignment
-        </li>
-<li class="listitem">
-          Value-access via pointer
-        </li>
-</ul></div>
-<p>
-      Also, even though <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span></code>
-      treats it wrapped pseudo-object much as a real value, a true real reference
-      is stored so aliasing will ocurr:
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          Copies of <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span></code>
-          will copy the references but all these references will nonetheless reefer
-          to the same object.
-        </li>
-<li class="listitem">
-          Value-access will actually provide access to the referenced object rather
-          than the reference itself.
-        </li>
-</ul></div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="examples.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rebinding_semantics_for_assignment_of_optional_references.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
@@ -1,148 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Rebinding semantics for assignment of optional references</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="prev" href="optional_references.html" title="Optional references">
-<link rel="next" href="in_place_factories.html" title="In-Place Factories">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="optional_references.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="in_place_factories.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_optional.rebinding_semantics_for_assignment_of_optional_references"></a><a class="link" href="rebinding_semantics_for_assignment_of_optional_references.html" title="Rebinding semantics for assignment of optional references">Rebinding
-    semantics for assignment of optional references</a>
-</h2></div></div></div>
-<p>
-      If you assign to an <span class="emphasis"><em>uninitialized </em></span> <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span></code>
-      the effect is to bind (for the first time) to the object. Clearly, there is
-      no other choice.
-    </p>
-<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">1</span> <span class="special">;</span>
-<span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">rx</span> <span class="special">=</span> <span class="identifier">x</span> <span class="special">;</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;</span> <span class="identifier">ora</span> <span class="special">;</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;</span> <span class="identifier">orb</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span> <span class="special">;</span>
-<span class="identifier">ora</span> <span class="special">=</span> <span class="identifier">orb</span> <span class="special">;</span> <span class="comment">// now 'ora' is bound to 'x' through 'rx'
-</span><span class="special">*</span><span class="identifier">ora</span> <span class="special">=</span> <span class="number">2</span> <span class="special">;</span> <span class="comment">// Changes value of 'x' through 'ora'
-</span><span class="identifier">assert</span><span class="special">(</span><span class="identifier">x</span><span class="special">==</span><span class="number">2</span><span class="special">);</span> 
-</pre>
-<p>
-      If you assign to a bare C++ reference, the assignment is forwarded to the referenced
-      object; its value changes but the reference is never rebound.
-    </p>
-<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">a</span> <span class="special">=</span> <span class="number">1</span> <span class="special">;</span>
-<span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">ra</span> <span class="special">=</span> <span class="identifier">a</span> <span class="special">;</span>
-<span class="keyword">int</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span> <span class="special">;</span>
-<span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">rb</span> <span class="special">=</span> <span class="identifier">b</span> <span class="special">;</span>
-<span class="identifier">ra</span> <span class="special">=</span> <span class="identifier">rb</span> <span class="special">;</span> <span class="comment">// Changes the value of 'a' to 'b'
-</span><span class="identifier">assert</span><span class="special">(</span><span class="identifier">a</span><span class="special">==</span><span class="identifier">b</span><span class="special">);</span>
-<span class="identifier">b</span> <span class="special">=</span> <span class="number">3</span> <span class="special">;</span>
-<span class="identifier">assert</span><span class="special">(</span><span class="identifier">ra</span><span class="special">!=</span><span class="identifier">b</span><span class="special">);</span> <span class="comment">// 'ra' is not rebound to 'b'
-</span></pre>
-<p>
-      Now, if you assign to an <span class="emphasis"><em>initialized </em></span> <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span></code>,
-      the effect is to <span class="bold"><strong>rebind</strong></span> to the new object
-      instead of assigning the referee. This is unlike bare C++ references.
-    </p>
-<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">a</span> <span class="special">=</span> <span class="number">1</span> <span class="special">;</span>
-<span class="keyword">int</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span> <span class="special">;</span>
-<span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">ra</span> <span class="special">=</span> <span class="identifier">a</span> <span class="special">;</span>
-<span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">rb</span> <span class="special">=</span> <span class="identifier">b</span> <span class="special">;</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;</span> <span class="identifier">ora</span><span class="special">(</span><span class="identifier">ra</span><span class="special">)</span> <span class="special">;</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;</span> <span class="identifier">orb</span><span class="special">(</span><span class="identifier">rb</span><span class="special">)</span> <span class="special">;</span>
-<span class="identifier">ora</span> <span class="special">=</span> <span class="identifier">orb</span> <span class="special">;</span> <span class="comment">// 'ora' is rebound to 'b'
-</span><span class="special">*</span><span class="identifier">ora</span> <span class="special">=</span> <span class="number">3</span> <span class="special">;</span> <span class="comment">// Changes value of 'b' (not 'a')
-</span><span class="identifier">assert</span><span class="special">(</span><span class="identifier">a</span><span class="special">==</span><span class="number">1</span><span class="special">);</span> 
-<span class="identifier">assert</span><span class="special">(</span><span class="identifier">b</span><span class="special">==</span><span class="number">3</span><span class="special">);</span> 
-</pre>
-<a name="boost_optional.rebinding_semantics_for_assignment_of_optional_references.rationale"></a><h4>
-<a name="boost_optional.rebinding_semantics_for_assignment_of_optional_references.rationale-heading"></a>
-      <a class="link" href="rebinding_semantics_for_assignment_of_optional_references.html#boost_optional.rebinding_semantics_for_assignment_of_optional_references.rationale">Rationale</a>
-    </h4>
-<p>
-      Rebinding semantics for the assignment of <span class="emphasis"><em>initialized </em></span>
-      <code class="computeroutput"><span class="identifier">optional</span></code> references has been
-      chosen to provide <span class="bold"><strong>consistency among initialization states</strong></span>
-      even at the expense of lack of consistency with the semantics of bare C++ references.
-      It is true that <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span></code> strives
-      to behave as much as possible as <code class="computeroutput"><span class="identifier">U</span></code>
-      does whenever it is initialized; but in the case when <code class="computeroutput"><span class="identifier">U</span></code>
-      is <code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span></code>,
-      doing so would result in inconsistent behavior w.r.t to the lvalue initialization
-      state.
-    </p>
-<p>
-      Imagine <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span></code>
-      forwarding assignment to the referenced object (thus changing the referenced
-      object value but not rebinding), and consider the following code:
-    </p>
-<pre class="programlisting"><span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;</span> <span class="identifier">a</span> <span class="special">=</span> <span class="identifier">get</span><span class="special">();</span>
-<span class="keyword">int</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">1</span> <span class="special">;</span>
-<span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">rx</span> <span class="special">=</span> <span class="identifier">x</span> <span class="special">;</span>
-<span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">rx</span><span class="special">);</span>
-<span class="identifier">a</span> <span class="special">=</span> <span class="identifier">b</span> <span class="special">;</span>
-</pre>
-<p>
-      What does the assignment do?
-    </p>
-<p>
-      If <code class="computeroutput"><span class="identifier">a</span></code> is <span class="emphasis"><em>uninitialized</em></span>,
-      the answer is clear: it binds to <code class="computeroutput"><span class="identifier">x</span></code>
-      (we now have another reference to <code class="computeroutput"><span class="identifier">x</span></code>).
-      But what if <code class="computeroutput"><span class="identifier">a</span></code> is already <span class="emphasis"><em>initialized</em></span>?
-      it would change the value of the referenced object (whatever that is); which
-      is inconsistent with the other possible case.
-    </p>
-<p>
-      If <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span></code>
-      would assign just like <code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span></code>
-      does, you would never be able to use Optional's assignment without explicitly
-      handling the previous initialization state unless your code is capable of functioning
-      whether after the assignment, <code class="computeroutput"><span class="identifier">a</span></code>
-      aliases the same object as <code class="computeroutput"><span class="identifier">b</span></code>
-      or not.
-    </p>
-<p>
-      That is, you would have to discriminate in order to be consistent.
-    </p>
-<p>
-      If in your code rebinding to another object is not an option, then it is very
-      likely that binding for the first time isn't either. In such case, assignment
-      to an <span class="emphasis"><em>uninitialized </em></span> <code class="computeroutput"><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;</span></code>
-      shall be prohibited. It is quite possible that in such a scenario it is a precondition
-      that the lvalue must be already initialized. If it isn't, then binding for
-      the first time is OK while rebinding is not which is IMO very unlikely. In
-      such a scenario, you can assign the value itself directly, as in:
-    </p>
-<pre class="programlisting"><span class="identifier">assert</span><span class="special">(!!</span><span class="identifier">opt</span><span class="special">);</span>
-<span class="special">*</span><span class="identifier">opt</span><span class="special">=</span><span class="identifier">value</span><span class="special">;</span>
-</pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="optional_references.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="in_place_factories.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
@@ -1,152 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Synopsis</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="prev" href="development.html" title="Development">
-<link rel="next" href="detailed_semantics.html" title="Detailed Semantics">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="development.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="detailed_semantics.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_optional.synopsis"></a><a class="link" href="synopsis.html" title="Synopsis">Synopsis</a>
-</h2></div></div></div>
-<pre class="programlisting"><code class="computeroutput"><span class="comment">// In Header: &lt;</span></code><a href="../../../../../boost/optional/optional.hpp" target="_top">boost/optional/optional.hpp</a><span class="comment">&gt;</span>
-
-<span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-<span class="keyword">class</span> <span class="identifier">optional</span>
-<span class="special">{</span>
-    <span class="keyword">public</span> <span class="special">:</span>
-
-    <span class="comment">// (If T is of reference type, the parameters and results by reference are by value)
-</span>
-    <span class="identifier">optional</span> <span class="special">()</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">none_t</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor_none_t"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="comment">// [new in 1.34]
-</span>    <span class="identifier">optional</span> <span class="special">(</span> <span class="keyword">bool</span> <span class="identifier">condition</span><span class="special">,</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor_bool_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a> 
-
-    <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor_other_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InPlaceFactory</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">InPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor_factory"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">TypedInPlaceFactory</span><span class="special">&gt;</span> <span class="keyword">explicit</span> <span class="identifier">optional</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_constructor_factory"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">none_t</span> <span class="special">)</span> <span class="special">;</span> 
-
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_equal_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_equal_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">rhs</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_equal_other_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">InPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_equal_factory"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">TypedInPlaceFactory</span><span class="special">&gt;</span> <span class="identifier">optional</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">TypedInPlaceFactory</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_equal_factory"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-    <span class="identifier">T</span><span class="special">&amp;</span>       <span class="identifier">get</span><span class="special">()</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="comment">// [new in 1.34]
-</span>    <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_value_or</span><span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="keyword">default</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get_value_or_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a> 
-
-    <span class="identifier">T</span> <span class="keyword">const</span><span class="special">*</span> <span class="keyword">operator</span> <span class="special">-&gt;()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_arrow"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-    <span class="identifier">T</span><span class="special">*</span>       <span class="keyword">operator</span> <span class="special">-&gt;()</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_arrow"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">*()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-    <span class="identifier">T</span><span class="special">&amp;</span>       <span class="keyword">operator</span> <span class="special">*()</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="identifier">T</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">get_ptr</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get_ptr"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-    <span class="identifier">T</span><span class="special">*</span>       <span class="identifier">get_ptr</span><span class="special">()</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get_ptr"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="keyword">operator</span> <span class="identifier">unspecified</span><span class="special">-</span><span class="keyword">bool</span><span class="special">-</span><span class="identifier">type</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_bool"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_operator_not"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="comment">// deprecated methods
-</span>
-    <span class="comment">// (deprecated)
-</span>    <span class="keyword">void</span> <span class="identifier">reset</span><span class="special">()</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_reset"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="comment">// (deprecated)
-</span>    <span class="keyword">void</span> <span class="identifier">reset</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_reset_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-    <span class="comment">// (deprecated)
-</span>    <span class="keyword">bool</span> <span class="identifier">is_initialized</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_is_initialized"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="special">};</span>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">bool</span> <span class="keyword">operator</span> <span class="special">==</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_operator_compare_equal_optional_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">bool</span> <span class="keyword">operator</span> <span class="special">!=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_operator_compare_not_equal_optional_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">bool</span> <span class="keyword">operator</span> <span class="special">&lt;</span>  <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_operator_compare_less_optional_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">bool</span> <span class="keyword">operator</span> <span class="special">&gt;</span>  <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_operator_compare_greater_optional_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">bool</span> <span class="keyword">operator</span> <span class="special">&lt;=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_operator_compare_less_or_equal_optional_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">bool</span> <span class="keyword">operator</span> <span class="special">&gt;=</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_operator_compare_greater_or_equal_optional_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="comment">// [new in 1.34]
-</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">make_optional</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_make_optional_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="comment">// [new in 1.34]
-</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">make_optional</span> <span class="special">(</span> <span class="keyword">bool</span> <span class="identifier">condition</span><span class="special">,</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_make_optional_bool_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="comment">// [new in 1.34]
-</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get_optional_value_or</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">opt</span><span class="special">,</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="keyword">default</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get_value_or_value"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a> 
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">get</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">get</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">get</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;*</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">get_pointer</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get_ptr"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">get_pointer</span> <span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span> <span class="identifier">opt</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_optional_get_ptr"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">;</span> <a class="link" href="detailed_semantics.html#reference_swap_optional_optional"><span class="inlinemediaobject"><img src="../images/callouts/R.png" alt="R"></span></a>
-
-<span class="special">}</span> <span class="comment">// namespace boost
-</span></pre>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="development.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="detailed_semantics.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
@@ -1,53 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Type requirements</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="prev" href="exception_safety_guarantees.html" title="Exception Safety Guarantees">
-<link rel="next" href="implementation_notes.html" title="Implementation Notes">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="exception_safety_guarantees.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="implementation_notes.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_optional.type_requirements"></a><a class="link" href="type_requirements.html" title="Type requirements">Type requirements</a>
-</h2></div></div></div>
-<p>
-      In general, <code class="computeroutput"><span class="identifier">T</span></code> must be <a href="../../../../utility/CopyConstructible.html" target="_top">Copy Constructible</a> and
-      have a no-throw destructor. The copy-constructible requirement is not needed
-      if <span class="bold"><strong>InPlaceFactories</strong></span> are used.
-    </p>
-<p>
-      <code class="computeroutput"><span class="identifier">T</span></code> <span class="underline">is
-      not</span> required to be <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html" target="_top">Default
-      Constructible</a>.
-    </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="exception_safety_guarantees.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="implementation_notes.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>
@@ -1,582 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2004 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-
-/*=============================================================================
-    Body defaults
-=============================================================================*/
-
-    body 
-    {
-        margin: 1em;
-        font-family: sans-serif;
-    }
-
-/*=============================================================================
-    Paragraphs
-=============================================================================*/
-
-    p 
-    {
-        text-align: left;
-        font-size: 10pt; 
-        line-height: 1.15;
-    }
-
-/*=============================================================================
-    Program listings
-=============================================================================*/
-
-    /* Code on paragraphs */
-    p tt.computeroutput
-    {
-        font-size: 10pt;
-    }
-
-    pre.synopsis
-    {
-        font-size: 10pt;
-        margin: 1pc 4% 0pc 4%;
-        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
-    }
-
-    .programlisting, 
-    .screen
-    {
-        font-size: 10pt;
-        display: block;
-        margin: 1pc 4% 0pc 4%;
-        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
-    }
-
-    /* Program listings in tables don't get borders */
-    td .programlisting,
-    td .screen
-    {
-        margin: 0pc 0pc 0pc 0pc;
-        padding:  0pc 0pc 0pc 0pc;
-    }
-
-/*=============================================================================
-    Headings
-=============================================================================*/
-
-    h1, h2, h3, h4, h5, h6 
-    { 
-        text-align: left;
-        margin: 1em 0em 0.5em 0em;
-        font-weight: bold;
-    }
-
-    h1 { font: 140% }
-    h2 { font: bold 140% }
-    h3 { font: bold 130% }
-    h4 { font: bold 120% }
-    h5 { font: italic 110% }
-    h6 { font: italic 100% }
-
-    /* Top page titles */
-    title, 
-    h1.title, 
-    h2.title
-    h3.title, 
-    h4.title, 
-    h5.title, 
-    h6.title, 
-    .refentrytitle
-    {
-        font-weight: bold;
-        margin-bottom: 1pc;
-    }
-
-    h1.title { font-size: 140% }
-    h2.title { font-size: 140% }
-    h3.title { font-size: 130% }
-    h4.title { font-size: 120% }
-    h5.title { font-size: 110% }
-    h6.title { font-size: 100% }
-
-    .section h1 
-    {
-        margin: 0em 0em 0.5em 0em;
-        font-size: 140%;
-    }
-
-    .section h2 { font-size: 140% }
-    .section h3 { font-size: 130% }
-    .section h4 { font-size: 120% }
-    .section h5 { font-size: 110% }
-    .section h6 { font-size: 100% }
-
-    /* Code on titles */
-    h1 tt.computeroutput { font-size: 140% }
-    h2 tt.computeroutput { font-size: 140% }
-    h3 tt.computeroutput { font-size: 130% }
-    h4 tt.computeroutput { font-size: 120% }
-    h5 tt.computeroutput { font-size: 110% }
-    h6 tt.computeroutput { font-size: 100% }
-
-/*=============================================================================
-    Author
-=============================================================================*/
-
-    h3.author 
-    { 
-        font-size: 100% 
-    }
-
-/*=============================================================================
-    Lists
-=============================================================================*/
-
-    li
-    {
-        font-size: 10pt;
-        line-height: 1.3;
-    }
-
-    /* Unordered lists */
-    ul 
-    {
-        text-align: left;
-    }
-
-    /* Ordered lists */
-    ol 
-    {
-        text-align: left;
-    }
-
-/*=============================================================================
-    Links
-=============================================================================*/
-
-    a
-    {
-        text-decoration: none; /* no underline */
-    }
-
-    a:hover
-    {
-        text-decoration: underline;
-    }
-
-/*=============================================================================
-    Spirit style navigation
-=============================================================================*/
-
-    .spirit-nav
-    {
-        text-align: right;
-    }
-
-    .spirit-nav a
-    {
-        color: white;
-        padding-left: 0.5em;
-    }
-
-    .spirit-nav img
-    {
-        border-width: 0px;
-    }
-
-/*=============================================================================
-    Table of contents
-=============================================================================*/
-
-    .toc
-    {
-       margin: 1pc 4% 0pc 4%;
-       padding: 0.1pc 1pc 0.1pc 1pc;
-       font-size: 10pt;
-       line-height: 1.15;
-    }
-
-    .toc-main
-    {
-       text-align: center;
-       margin: 3pc 16% 3pc 16%;
-       padding: 3pc 1pc 3pc 1pc;
-       line-height: 0.1;
-    }
-
-    .boost-toc
-    {
-       float: right;
-       padding: 0.5pc;
-    }
-
-/*=============================================================================
-    Tables
-=============================================================================*/
-
-    .table-title, 
-    div.table p.title
-    {
-        margin-left: 4%;
-        padding-right: 0.5em; 
-        padding-left: 0.5em;
-    }
-
-    .informaltable table, 
-    .table table
-    {
-        width: 92%;
-        margin-left: 4%;
-        margin-right: 4%;
-    }
-
-    div.informaltable table, 
-    div.table table
-    {
-        padding: 4px;
-    }
-
-    /* Table Cells */
-    div.informaltable table tr td, 
-    div.table table tr td
-    {
-        padding: 0.5em;
-        text-align: left;
-    }
-
-    div.informaltable table tr th, 
-    div.table table tr th
-    {
-        padding: 0.5em 0.5em 0.5em 0.5em;
-        border: 1pt solid white;
-        font-size: 120%;
-    }
-
-/*=============================================================================
-    Blurbs
-=============================================================================*/
-
-    div.note,
-    div.tip,
-    div.important,
-    div.caution,
-    div.warning,
-    div.sidebar
-    {
-        font-size: 10pt;
-        line-height: 1.2;
-        display: block;
-        margin: 1pc 4% 0pc 4%;
-        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
-    }
-
-    div.sidebar img
-    {
-        padding: 1pt;
-    }
-
-
-
-/*=============================================================================
-    Callouts
-=============================================================================*/
-    .line_callout_bug img
-    {
-        float: left;
-        position:relative;
-        left: 4px;
-        top: -12px;
-        clear: left;
-        margin-left:-22px;
-    }
-
-    .callout_bug img
-    {
-    }
-
-
-
-/*=============================================================================
-    Variable Lists
-=============================================================================*/
-
-    /* Make the terms in definition lists bold */
-    div.variablelist dl dt,
-    span.term
-    {
-        font-weight: bold;
-        font-size: 10pt;
-    }
-
-    div.variablelist table tbody tr td
-    {
-        text-align: left;
-        vertical-align: top;
-        padding: 0em 2em 0em 0em;
-        font-size: 10pt;
-        margin: 0em 0em 0.5em 0em;
-        line-height: 1;
-    }
-
-    /* Make the terms in definition lists bold */
-    div.variablelist dl dt
-    {
-        margin-bottom: 0.2em;
-    }
-
-    div.variablelist dl dd
-    {
-        margin: 0em 0em 0.5em 2em;
-        font-size: 10pt;
-    }
-
-    div.variablelist table tbody tr td p
-    div.variablelist dl dd p
-    {
-        margin: 0em 0em 0.5em 0em;
-        line-height: 1;
-    }
-
-/*=============================================================================
-    Misc
-=============================================================================*/
-
-    /* Title of books and articles in bibliographies */
-    span.title
-    {
-        font-style: italic;
-    }
-
-    span.underline
-    {
-        text-decoration: underline;
-    }
-
-    span.strikethrough
-    {
-        text-decoration: line-through;
-    }
-
-    /* Copyright, Legal Notice */
-    div div.legalnotice p
-    {
-        text-align: left
-    }
-
-/*=============================================================================
-    Colors
-=============================================================================*/
-
-    @media screen
-    {
-        /* Links */
-        a
-        {
-            color: #0C7445;
-        }
-
-        a:visited
-        {
-            color: #663974;
-        }
-
-        h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
-        h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
-        h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
-        {
-            text-decoration: none; /* no underline */
-            color: #000000;
-        }
-
-        /* Syntax Highlighting */
-        .keyword        { color: #0000AA; }
-        .identifier     { color: #000000; }
-        .special        { color: #707070; }
-        .preprocessor   { color: #402080; }
-        .char           { color: teal; }
-        .comment        { color: #800000; }
-        .string         { color: teal; }
-        .number         { color: teal; }
-        .white_bkd      { background-color: #E8FBE9; }
-        .dk_grey_bkd    { background-color: #A0DAAC; }
-
-        /* Copyright, Legal Notice */
-        .copyright
-        { 
-            color: #666666; 
-            font-size: small; 
-        }
-
-        div div.legalnotice p
-        {
-            color: #666666;
-        }
-
-        /* Program listing */
-        pre.synopsis
-        {
-            border: 1px solid #DCDCDC;
-            border-bottom: 3px solid #9D9D9D;
-            border-right: 3px solid #9D9D9D;
-            background-color: #FAFFFB;
-        }
-
-        .programlisting, 
-        .screen
-        {
-            border: 1px solid #DCDCDC;
-            border-bottom: 3px solid #9D9D9D;
-            border-right: 3px solid #9D9D9D;
-            background-color: #FAFFFB;
-        }
-
-        td .programlisting,
-        td .screen
-        {
-            border: 0px solid #DCDCDC;
-        }
-
-        /* Blurbs */
-        div.note,
-        div.tip,
-        div.important,
-        div.caution,
-        div.warning,
-        div.sidebar
-        {
-            border: 1px solid #DCDCDC;
-            border-bottom: 3px solid #9D9D9D;
-            border-right: 3px solid #9D9D9D;
-            background-color: #FAFFFB;
-        }
-
-        /* Table of contents */
-        .toc
-        {
-            border: 1px solid #DCDCDC;
-            border-bottom: 3px solid #9D9D9D;
-            border-right: 3px solid #9D9D9D;
-            background-color: #FAFFFB;
-        }
-
-        /* Table of contents */
-        .toc-main
-        {
-            border: 1px solid #DCDCDC;
-            border-bottom: 3px solid #9D9D9D;
-            border-right: 3px solid #9D9D9D;
-            background-color: #FAFFFB;
-        }
-
-
-        /* Tables */
-        div.informaltable table tr td, 
-        div.table table tr td
-        {
-            border: 1px solid #DCDCDC;
-            background-color: #FAFFFB;
-        }
-
-        div.informaltable table tr th, 
-        div.table table tr th
-        {
-            background-color: #E3F9E4;
-            border: 1px solid #DCDCDC;
-        }
-
-        /* Misc */
-        span.highlight
-        {
-            color: #00A000;
-        }
-    }
-
-    @media print
-    {
-        /* Links */
-        a
-        {
-            color: black;
-        }
-
-        a:visited
-        {
-            color: black;
-        }
-
-        .spirit-nav
-        {
-            display: none;
-        }
-
-        /* Program listing */
-        pre.synopsis
-        {
-            border: 1px solid gray;
-            background-color: #FAFFFB;
-        }
-
-        .programlisting, 
-        .screen
-        {
-            border: 1px solid gray;
-            background-color: #FAFFFB;
-        }
-
-        td .programlisting,
-        td .screen
-        {
-            border: 0px solid #DCDCDC;
-        }
-
-        /* Table of contents */
-        .toc
-        {
-            border: 1px solid #DCDCDC;
-            border-bottom: 3px solid #9D9D9D;
-            border-right: 3px solid #9D9D9D;
-            background-color: #FAFFFB;
-        }
-
-        /* Table of contents */
-        .toc-main
-        {
-            border: 1px solid #DCDCDC;
-            border-bottom: 3px solid #9D9D9D;
-            border-right: 3px solid #9D9D9D;
-            background-color: #FAFFFB;
-        }
-
-        .informaltable table, 
-        .table table
-        {
-            border: 1px solid #DCDCDC;
-            border-bottom: 3px solid #9D9D9D;
-            border-right: 3px solid #9D9D9D;
-            border-collapse: collapse;
-            background-color: #FAFFFB;
-        }
-
-        /* Tables */
-        div.informaltable table tr td, 
-        div.table table tr td
-        {
-            border: 1px solid #DCDCDC;
-            background-color: #FAFFFB;
-        }
-
-        div.informaltable table tr th, 
-        div.table table tr th
-        {
-            border: 1px solid #DCDCDC;
-            background-color: #FAFFFB;
-        }
-
-        /* Misc */
-        span.highlight
-        {
-            font-weight: bold;
-        }
-    }
@@ -1,172 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Chapter&#160;1.&#160;Boost.Optional</title>
-<link rel="stylesheet" href="boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="index.html" title="Chapter&#160;1.&#160;Boost.Optional">
-<link rel="next" href="boost_optional/development.html" title="Development">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
-<td align="center"><a href="../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav"><a accesskey="n" href="boost_optional/development.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
-<div class="chapter">
-<div class="titlepage"><div>
-<div><h2 class="title">
-<a name="optional"></a>Chapter&#160;1.&#160;Boost.Optional</h2></div>
-<div><div class="author"><h3 class="author">
-<span class="firstname">Fernando Luis</span> <span class="surname">Cacciola Carballal</span>
-</h3></div></div>
-<div><p class="copyright">Copyright &#169; 2003-2007 Fernando Luis Cacciola Carballal</p></div>
-<div><div class="legalnotice">
-<a name="id2833979"></a><p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></div>
-</div></div>
-<div class="toc">
-<p><b>Table of Contents</b></p>
-<dl>
-<dt><span class="section"><a href="index.html#optional.motivation">Motivation</a></span></dt>
-<dt><span class="section"><a href="boost_optional/development.html">Development</a></span></dt>
-<dd><dl>
-<dt><span class="section"><a href="boost_optional/development.html#boost_optional.development.the_models">The models</a></span></dt>
-<dt><span class="section"><a href="boost_optional/development.html#boost_optional.development.the_semantics">The semantics</a></span></dt>
-<dt><span class="section"><a href="boost_optional/development.html#boost_optional.development.the_interface">The Interface</a></span></dt>
-</dl></dd>
-<dt><span class="section"><a href="boost_optional/synopsis.html">Synopsis</a></span></dt>
-<dt><span class="section"><a href="boost_optional/detailed_semantics.html">Detailed Semantics</a></span></dt>
-<dt><span class="section"><a href="boost_optional/examples.html">Examples</a></span></dt>
-<dd><dl>
-<dt><span class="section"><a href="boost_optional/examples.html#boost_optional.examples.optional_return_values">Optional
-      return values</a></span></dt>
-<dt><span class="section"><a href="boost_optional/examples.html#boost_optional.examples.optional_local_variables">Optional
-      local variables</a></span></dt>
-<dt><span class="section"><a href="boost_optional/examples.html#boost_optional.examples.optional_data_members">Optional
-      data members</a></span></dt>
-<dt><span class="section"><a href="boost_optional/examples.html#boost_optional.examples.bypassing_expensive_unnecessary_default_construction">Bypassing
-      expensive unnecessary default construction</a></span></dt>
-</dl></dd>
-<dt><span class="section"><a href="boost_optional/optional_references.html">Optional references</a></span></dt>
-<dt><span class="section"><a href="boost_optional/rebinding_semantics_for_assignment_of_optional_references.html">Rebinding
-    semantics for assignment of optional references</a></span></dt>
-<dt><span class="section"><a href="boost_optional/in_place_factories.html">In-Place Factories</a></span></dt>
-<dt><span class="section"><a href="boost_optional/a_note_about_optional_bool_.html">A note about
-    optional&lt;bool&gt;</a></span></dt>
-<dt><span class="section"><a href="boost_optional/exception_safety_guarantees.html">Exception Safety
-    Guarantees</a></span></dt>
-<dt><span class="section"><a href="boost_optional/type_requirements.html">Type requirements</a></span></dt>
-<dt><span class="section"><a href="boost_optional/implementation_notes.html">Implementation Notes</a></span></dt>
-<dt><span class="section"><a href="boost_optional/dependencies_and_portability.html">Dependencies
-    and Portability</a></span></dt>
-<dt><span class="section"><a href="boost_optional/acknowledgments.html">Acknowledgments</a></span></dt>
-</dl>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="optional.motivation"></a><a class="link" href="index.html#optional.motivation" title="Motivation">Motivation</a>
-</h2></div></div></div>
-<p>
-      Consider these functions which should return a value but which might not have
-      a value to return:
-    </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          (A) <code class="computeroutput"><span class="keyword">double</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">n</span> <span class="special">);</span></code>
-        </li>
-<li class="listitem">
-          (B) <code class="computeroutput"><span class="keyword">char</span> <span class="identifier">get_async_input</span><span class="special">();</span></code>
-        </li>
-<li class="listitem">
-          (C) <code class="computeroutput"><span class="identifier">point</span> <span class="identifier">polygon</span><span class="special">::</span><span class="identifier">get_any_point_effectively_inside</span><span class="special">();</span></code>
-        </li>
-</ul></div>
-<p>
-      There are different approaches to the issue of not having a value to return.
-    </p>
-<p>
-      A typical approach is to consider the existence of a valid return value as
-      a postcondition, so that if the function cannot compute the value to return,
-      it has either undefined behavior (and can use assert in a debug build) or uses
-      a runtime check and throws an exception if the postcondition is violated. This
-      is a reasonable choice for example, for function (A), because the lack of a
-      proper return value is directly related to an invalid parameter (out of domain
-      argument), so it is appropriate to require the callee to supply only parameters
-      in a valid domain for execution to continue normally.
-    </p>
-<p>
-      However, function (B), because of its asynchronous nature, does not fail just
-      because it can't find a value to return; so it is incorrect to consider such
-      a situation an error and assert or throw an exception. This function must return,
-      and somehow, must tell the callee that it is not returning a meaningful value.
-    </p>
-<p>
-      A similar situation occurs with function (C): it is conceptually an error to
-      ask a <span class="emphasis"><em>null-area</em></span> polygon to return a point inside itself,
-      but in many applications, it is just impractical for performance reasons to
-      treat this as an error (because detecting that the polygon has no area might
-      be too expensive to be required to be tested previously), and either an arbitrary
-      point (typically at infinity) is returned, or some efficient way to tell the
-      callee that there is no such point is used.
-    </p>
-<p>
-      There are various mechanisms to let functions communicate that the returned
-      value is not valid. One such mechanism, which is quite common since it has
-      zero or negligible overhead, is to use a special value which is reserved to
-      communicate this. Classical examples of such special values are <code class="computeroutput"><span class="identifier">EOF</span></code>, <code class="computeroutput"><span class="identifier">string</span><span class="special">::</span><span class="identifier">npos</span></code>, points
-      at infinity, etc...
-    </p>
-<p>
-      When those values exist, i.e. the return type can hold all meaningful values
-      <span class="emphasis"><em>plus</em></span> the <span class="emphasis"><em>signal</em></span> value, this mechanism
-      is quite appropriate and well known. Unfortunately, there are cases when such
-      values do not exist. In these cases, the usual alternative is either to use
-      a wider type, such as <code class="computeroutput"><span class="keyword">int</span></code> in place
-      of <code class="computeroutput"><span class="keyword">char</span></code>; or a compound type, such
-      as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">point</span><span class="special">,</span><span class="keyword">bool</span><span class="special">&gt;</span></code>.
-    </p>
-<p>
-      Returning a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="keyword">bool</span><span class="special">&gt;</span></code>, thus attaching a boolean flag to the result
-      which indicates if the result is meaningful, has the advantage that can be
-      turned into a consistent idiom since the first element of the pair can be whatever
-      the function would conceptually return. For example, the last two functions
-      could have the following interface:
-    </p>
-<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span><span class="keyword">bool</span><span class="special">&gt;</span> <span class="identifier">get_async_input</span><span class="special">();</span>
-<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">point</span><span class="special">,</span><span class="keyword">bool</span><span class="special">&gt;</span> <span class="identifier">polygon</span><span class="special">::</span><span class="identifier">get_any_point_effectively_inside</span><span class="special">();</span>
-</pre>
-<p>
-      These functions use a consistent interface for dealing with possibly nonexistent
-      results:
-    </p>
-<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">point</span><span class="special">,</span><span class="keyword">bool</span><span class="special">&gt;</span> <span class="identifier">p</span> <span class="special">=</span> <span class="identifier">poly</span><span class="special">.</span><span class="identifier">get_any_point_effectively_inside</span><span class="special">();</span>
-<span class="keyword">if</span> <span class="special">(</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span> <span class="special">)</span>
-    <span class="identifier">flood_fill</span><span class="special">(</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span><span class="special">);</span>
-</pre>
-<p>
-      However, not only is this quite a burden syntactically, it is also error prone
-      since the user can easily use the function result (first element of the pair)
-      without ever checking if it has a valid value.
-    </p>
-<p>
-      Clearly, we need a better idiom.
-    </p>
-</div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: April 07, 2011 at 21:02:08 GMT</small></p></td>
-<td align="right"><div class="copyright-footer"></div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav"><a accesskey="n" href="boost_optional/development.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
-</body>
-</html>
@@ -1,26 +0,0 @@
-[/
-    Boost.Optional
-
-    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
-
-    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)
-]
-
-
-
-[section Implementation Notes]
-
-`optional<T>` is currently implemented using a custom aligned storage facility
-built from `alignment_of` and `type_with_alignment` (both from Type Traits). It
-uses a separate boolean flag to indicate the initialization state.
-Placement new with `T`'s copy constructor and `T`'s destructor are explicitly used
-to initialize,copy and destroy optional values.
-As a result, `T`'s default constructor is effectively by-passed, but the exception
-guarantees are basic.
-It is planned to replace the current implementation with another with stronger
-exception safety, such as a future `boost::variant`.
-
-[endsect]
- 
@@ -1,126 +0,0 @@
-[library Boost.Optional
-    [quickbook 1.4]
-    [authors [Cacciola Carballal, Fernando Luis]]
-    [copyright 2003-2007 Fernando Luis Cacciola Carballal]
-    [category miscellaneous]
-    [id optional]
-    [dirname optional]
-    [purpose
-        Discriminated-union wrapper for optional values
-    ]
-    [source-mode c++]
-    [license
-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])
-    ]
-]
-
-[/ Macros will be used for links so we have a central place to change them ]
-
-
-[/ Cited Boost resources ]
-
-[def __BOOST_VARIANT__ [@../../../variant/index.html Boost.Variant]]
-[def __BOOST_TRIBOOL__ [@../../../../doc/html/tribool.html boost::tribool]]
-
-[def __OPTIONAL_POINTEE__ [@../../../utility/OptionalPointee.html OptionalPointee]]
-[def __COPY_CONSTRUCTIBLE__ [@../../../utility/CopyConstructible.html Copy Constructible]]
-[def __FUNCTION_EQUAL_POINTEES__ [@../../../utility/OptionalPointee.html#equal `equal_pointees()`]]
-[def __FUNCTION_LESS_POINTEES__ [@../../../utility/OptionalPointee.html#less `less_pointees()`]]
-
-[def __IN_PLACE_FACTORY_HPP__ [@../../../../boost/utility/in_place_factory.hpp in_place_factory.hpp]]
-[def __TYPED_IN_PLACE_FACTORY_HPP__ [@../../../../boost/utility/typed_in_place_factory.hpp typed_in_place_factory.hpp]]
-
-[/ Other web resources ]
-
-[def __HASKELL__ [@http://www.haskell.org/ Haskell]]
-[def __SGI_DEFAULT_CONSTRUCTIBLE__ [@http://www.sgi.com/tech/stl/DefaultConstructible.html Default Constructible]]
-
-
-[/ Icons ]
-
-[def __SPACE__ [$images/space.png]]
-[def __GO_TO__ [$images/callouts/R.png]]
-
-
-[section Motivation]
-
-Consider these functions which should return a value but which might not have
-a value to return:
-
-* (A) `double sqrt(double n );`
-* (B) `char get_async_input();`
-* (C) `point polygon::get_any_point_effectively_inside();`
-
-There are different approaches to the issue of not having a value to return.
-
-A typical approach is to consider the existence of a valid return value as a
-postcondition, so that if the function cannot compute the value to return, it
-has either undefined behavior (and can use assert in a debug build) or uses a
-runtime check and throws an exception if the postcondition is violated. This
-is a reasonable choice for example, for function (A), because the lack of a
-proper return value is directly related to an invalid parameter (out of domain
-argument), so it is appropriate to require the callee to supply only parameters
-in a valid domain for execution to continue normally.
-
-However, function (B), because of its asynchronous nature, does not fail just
-because it can't find a value to return; so it is incorrect to consider such
-a situation an error and assert or throw an exception. This function must
-return, and somehow, must tell the callee that it is not returning a meaningful
-value.
-
-A similar situation occurs with function (C): it is conceptually an error to
-ask a ['null-area] polygon to return a point inside itself, but in many
-applications, it is just impractical for performance reasons to treat this as
-an error (because detecting that the polygon has no area might be too expensive
-to be required to be tested previously), and either an arbitrary point
-(typically at infinity) is returned, or some efficient way to tell the callee
-that there is no such point is used.
-
-There are various mechanisms to let functions communicate that the returned
-value is not valid. One such mechanism, which is quite common since it has
-zero or negligible overhead, is to use a special value which is reserved to
-communicate this. Classical examples of such special values are `EOF`,
-`string::npos`, points at infinity, etc...
-
-When those values exist, i.e. the return type can hold all meaningful values
-['plus] the ['signal] value, this mechanism is quite appropriate and well known.
-Unfortunately, there are cases when such values do not exist. In these cases,
-the usual alternative is either to use a wider type, such as `int` in place of
-`char`; or a compound type, such as `std::pair<point,bool>`.
-
-Returning a `std::pair<T,bool>`, thus attaching a boolean flag to the result
-which indicates if the result is meaningful, has the advantage that can be
-turned into a consistent idiom since the first element of the pair can be
-whatever the function would conceptually return. For example, the last two
-functions could have the following interface:
-
-    std::pair<char,bool> get_async_input();
-    std::pair<point,bool> polygon::get_any_point_effectively_inside();
-
-These functions use a consistent interface for dealing with possibly nonexistent
-results:
-
-    std::pair<point,bool> p = poly.get_any_point_effectively_inside();
-    if ( p.second )
-        flood_fill(p.first);
-
-However, not only is this quite a burden syntactically, it is also error prone
-since the user can easily use the function result (first element of the pair)
-without ever checking if it has a valid value.
-
-Clearly, we need a better idiom.
-
-[endsect]
-
-
-[include development.qbk]
-[include reference.qbk]
-[include examples.qbk]
-[include special_cases.qbk]
-[include implementation_notes.qbk]
-[include dependencies.qbk]
-[include acknowledgments.qbk]
-
-
@@ -1,900 +0,0 @@
-[/
-    Boost.Optional
-
-    Copyright (c) 2003-2007 Fernando Luis Cacciola Carballal
-
-    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)
-]
-
-
-[section Synopsis]
-
-    ```// In Header: <`[@boost:/boost/optional/optional.hpp boost/optional/optional.hpp]'''<phrase role="comment">&gt;</phrase>'''``
-
-    namespace boost {
-
-    template<class T>
-    class optional
-    {
-        public :
-
-        // (If T is of reference type, the parameters and results by reference are by value)
-
-        optional () ; ``[link reference_optional_constructor __GO_TO__]``
-
-        optional ( none_t ) ; ``[link reference_optional_constructor_none_t __GO_TO__]``
-
-        optional ( T const& v ) ; ``[link reference_optional_constructor_value __GO_TO__]``
-
-        // [new in 1.34]
-        optional ( bool condition, T const& v ) ; ``[link reference_optional_constructor_bool_value __GO_TO__]`` 
-
-        optional ( optional const& rhs ) ; ``[link reference_optional_constructor_optional __GO_TO__]``
-
-        template<class U> explicit optional ( optional<U> const& rhs ) ; ``[link reference_optional_constructor_other_optional __GO_TO__]``
-
-        template<class InPlaceFactory> explicit optional ( InPlaceFactory const& f ) ; ``[link reference_optional_constructor_factory __GO_TO__]``
-
-        template<class TypedInPlaceFactory> explicit optional ( TypedInPlaceFactory const& f ) ; ``[link reference_optional_constructor_factory __GO_TO__]``
-
-        optional& operator = ( none_t ) ; ``[/[link reference_optional_operator_equal_none_t __GO_TO__]]``
-
-        optional& operator = ( T const& v ) ; ``[link reference_optional_operator_equal_value __GO_TO__]``
-
-        optional& operator = ( optional const& rhs ) ; ``[link reference_optional_operator_equal_optional __GO_TO__]``
-
-        template<class U> optional& operator = ( optional<U> const& rhs ) ; ``[link reference_optional_operator_equal_other_optional __GO_TO__]``
-
-        template<class InPlaceFactory> optional& operator = ( InPlaceFactory const& f ) ; ``[link reference_optional_operator_equal_factory __GO_TO__]``
-
-        template<class TypedInPlaceFactory> optional& operator = ( TypedInPlaceFactory const& f ) ; ``[link reference_optional_operator_equal_factory __GO_TO__]``
-
-        T const& get() const ; ``[link reference_optional_get __GO_TO__]``
-        T&       get() ; ``[link reference_optional_get __GO_TO__]``
-
-        // [new in 1.34]
-        T const& get_value_or( T const& default ) const ; ``[link reference_optional_get_value_or_value __GO_TO__]`` 
-
-        T const* operator ->() const ; ``[link reference_optional_operator_arrow __GO_TO__]``
-        T*       operator ->() ; ``[link reference_optional_operator_arrow __GO_TO__]``
-
-        T const& operator *() const ; ``[link reference_optional_get __GO_TO__]``
-        T&       operator *() ; ``[link reference_optional_get __GO_TO__]``
-
-        T const* get_ptr() const ; ``[link reference_optional_get_ptr __GO_TO__]``
-        T*       get_ptr() ; ``[link reference_optional_get_ptr __GO_TO__]``
-
-        operator unspecified-bool-type() const ; ``[link reference_optional_operator_bool __GO_TO__]``
-
-        bool operator!() const ; ``[link reference_optional_operator_not __GO_TO__]``
-
-        // deprecated methods
-
-        // (deprecated)
-        void reset() ; ``[link reference_optional_reset __GO_TO__]``
-
-        // (deprecated)
-        void reset ( T const& ) ; ``[link reference_optional_reset_value __GO_TO__]``
-
-        // (deprecated)
-        bool is_initialized() const ; ``[link reference_optional_is_initialized __GO_TO__]``
-
-    };
-
-    template<class T> inline bool operator == ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_equal_optional_optional __GO_TO__]``
-
-    template<class T> inline bool operator != ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_not_equal_optional_optional __GO_TO__]``
-
-    template<class T> inline bool operator <  ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_less_optional_optional __GO_TO__]``
-
-    template<class T> inline bool operator >  ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_greater_optional_optional __GO_TO__]``
-
-    template<class T> inline bool operator <= ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_less_or_equal_optional_optional __GO_TO__]``
-
-    template<class T> inline bool operator >= ( optional<T> const& x, optional<T> const& y ) ; ``[link reference_operator_compare_greater_or_equal_optional_optional __GO_TO__]``
-
-    // [new in 1.34]
-    template<class T> inline optional<T> make_optional ( T const& v ) ; ``[link reference_make_optional_value __GO_TO__]``
-
-    // [new in 1.34]
-    template<class T> inline optional<T> make_optional ( bool condition, T const& v ) ; ``[link reference_make_optional_bool_value __GO_TO__]``
-
-    // [new in 1.34]
-    template<class T> inline T const& get_optional_value_or ( optional<T> const& opt, T const& default ) ; ``[link reference_optional_get_value_or_value __GO_TO__]`` 
-
-    template<class T> inline T const& get ( optional<T> const& opt ) ; ``[link reference_optional_get __GO_TO__]``
-
-    template<class T> inline T& get ( optional<T> & opt ) ; ``[link reference_optional_get __GO_TO__]``
-
-    template<class T> inline T const* get ( optional<T> const* opt ) ; ``[link reference_optional_get __GO_TO__]``
-
-    template<class T> inline T* get ( optional<T>* opt ) ; ``[link reference_optional_get __GO_TO__]``
-
-    template<class T> inline T const* get_pointer ( optional<T> const& opt ) ; ``[link reference_optional_get_ptr __GO_TO__]``
-
-    template<class T> inline T* get_pointer ( optional<T> & opt ) ; ``[link reference_optional_get_ptr __GO_TO__]``
-
-    template<class T> inline void swap( optional<T>& x, optional<T>& y ) ; ``[link reference_swap_optional_optional __GO_TO__]``
-
-    } // namespace boost
-
-
-[endsect]
-
-[section Detailed Semantics]
-
-Because `T` might be of reference type, in the sequel, those entries whose
-semantic depends on `T` being of reference type or not will be distinguished
-using the following convention:
-
-* If the entry reads: `optional<T`['(not a ref)]`>`, the description
-corresponds only to the case where `T` is not of reference type.
-* If the entry reads: `optional<T&>`, the description corresponds only to
-the case where `T` is of reference type.
-* If the entry reads: `optional<T>`, the description is the same for both
-cases.
-
-[note
-The following section contains various `assert()` which are used only to show
-the postconditions as sample code. It is not implied that the type `T` must
-support each particular expression but that if the expression is supported,
-the implied condition holds.
-]
-
-__SPACE__
-
-[heading optional class member functions]
-
-__SPACE__
-
-[#reference_optional_constructor]
-
-[: `optional<T>::optional();`]
-
-* [*Effect:] Default-Constructs an `optional`.
-* [*Postconditions:] `*this` is [_uninitialized].
-* [*Throws:] Nothing.
-* Notes: T's default constructor [_is not] called.
-* [*Example:]
-``
-optional<T> def ;
-assert ( !def ) ;
-``
-
-__SPACE__
-
-[#reference_optional_constructor_none_t]
-
-[: `optional<T>::optional( none_t );`]
-
-* [*Effect:] Constructs an `optional` uninitialized.
-* [*Postconditions:] `*this` is [_uninitialized].
-* [*Throws:] Nothing.
-* [*Notes:] `T`'s default constructor [_is not] called. The expression
-`boost::none` denotes an instance of `boost::none_t` that can be used as
-the parameter.
-* [*Example:]
-``
-#include <boost/none.hpp>
-optional<T> n(none) ;
-assert ( !n ) ;
-``
-
-__SPACE__
-
-[#reference_optional_constructor_value]
-
-[: `optional<T `['(not a ref)]`>::optional( T const& v )`]
-
-* [*Effect:] Directly-Constructs an `optional`.
-* [*Postconditions:] `*this` is [_initialized] and its value is a['copy]
-of `v`.
-* [*Throws:] Whatever `T::T( T const& )` throws.
-* [*Notes: ] `T::T( T const& )` is called.
-* [*Exception Safety:] Exceptions can only be thrown during
-`T::T( T const& );` in that case, this constructor has no effect.
-* [*Example:]
-``
-T v;
-optional<T> opt(v);
-assert ( *opt == v ) ;
-``
-
-__SPACE__
-
-[: `optional<T&>::optional( T& ref )`]
-
-* [*Effect:] Directly-Constructs an `optional`.
-* [*Postconditions:] `*this` is [_initialized] and its value is an instance
-of an internal type wrapping the reference `ref`.
-* [*Throws:] Nothing.
-* [*Example:]
-``
-T v;
-T& vref = v ;
-optional<T&> opt(vref);
-assert ( *opt == v ) ;
-++ v ; // mutate referee
-assert (*opt == v);
-``
-
-__SPACE__
-
-[#reference_optional_constructor_bool_value]
-
-[: `optional<T` ['(not a ref)]`>::optional( bool condition, T const& v ) ;` ]
-[: `optional<T&>           ::optional( bool condition, T&       v ) ;` ]
-
-* If condition is true, same as:
-
-[: `optional<T` ['(not a ref)]`>::optional( T const& v )`]
-[: `optional<T&>           ::optional( T&       v )`]
-
-* otherwise, same as:
-
-[: `optional<T `['(not a ref)]`>::optional()`]
-[: `optional<T&>           ::optional()`]
-
-__SPACE__
-
-[#reference_optional_constructor_optional]
-
-[: `optional<T `['(not a ref)]`>::optional( optional const& rhs );`]
-
-* [*Effect:] Copy-Constructs an `optional`.
-* [*Postconditions:] If rhs is initialized, `*this` is initialized and
-its value is a ['copy] of the value of `rhs`; else `*this` is uninitialized.
-* [*Throws:] Whatever `T::T( T const& )` throws.
-* [*Notes:] If rhs is initialized, `T::T(T const& )` is called.
-* [*Exception Safety:] Exceptions can only be thrown during
-`T::T( T const& );` in that case, this constructor has no effect.
-* [*Example:]
-``
-optional<T> uninit ;
-assert (!uninit);
-
-optional<T> uinit2 ( uninit ) ;
-assert ( uninit2 == uninit );
-
-optional<T> init( T(2) );
-assert ( *init == T(2) ) ;
-
-optional<T> init2 ( init ) ;
-assert ( init2 == init ) ;
-``
-
-__SPACE__
-
-[: `optional<T&>::optional( optional const& rhs );`]
-
-* [*Effect:] Copy-Constructs an `optional`.
-* [*Postconditions:] If `rhs` is initialized, `*this` is initialized and its
-value is another reference to the same object referenced by `*rhs`; else
-`*this` is uninitialized.
-* [*Throws:] Nothing.
-* [*Notes:] If `rhs` is initialized, both `*this` and `*rhs` will reefer to the
-same object (they alias).
-* [*Example:]
-``
-optional<T&> uninit ;
-assert (!uninit);
-
-optional<T&> uinit2 ( uninit ) ;
-assert ( uninit2 == uninit );
-
-T v = 2 ; T& ref = v ;
-optional<T> init(ref);
-assert ( *init == v ) ;
-
-optional<T> init2 ( init ) ;
-assert ( *init2 == v ) ;
-
-v = 3 ;
-
-assert ( *init  == 3 ) ;
-assert ( *init2 == 3 ) ;
-``
-
-__SPACE__
-
-[#reference_optional_constructor_other_optional]
-
-[: `template<U> explicit optional<T` ['(not a ref)]`>::optional( optional<U> const& rhs );`]
-
-* [*Effect:] Copy-Constructs an `optional`.
-* [*Postconditions:] If `rhs` is initialized, `*this` is initialized and its
-value is a ['copy] of the value of rhs converted to type `T`; else `*this` is
-uninitialized.
-* [*Throws:] Whatever `T::T( U const& )` throws.
-* [*Notes: ] `T::T( U const& )` is called if `rhs` is initialized, which requires a
-valid conversion from `U` to `T`.
-* [*Exception Safety:] Exceptions can only be thrown during `T::T( U const& );`
-in that case, this constructor has no effect.
-* [*Example:]
-``
-optional<double> x(123.4);
-assert ( *x == 123.4 ) ;
-
-optional<int> y(x) ;
-assert( *y == 123 ) ;
-``
-
-__SPACE__
-
-[#reference_optional_constructor_factory]
-
-[: `template<InPlaceFactory> explicit optional<T` ['(not a ref)]`>::optional( InPlaceFactory const& f );`]
-[: `template<TypedInPlaceFactory> explicit optional<T` ['(not a ref)]`>::optional( TypedInPlaceFactory const& f );`]
-
-* [*Effect:] Constructs an `optional` with a value of `T` obtained from the
-factory.
-* [*Postconditions: ] `*this` is [_initialized] and its value is ['directly given]
-from the factory `f` (i.e., the value [_is not copied]).
-* [*Throws:] Whatever the `T` constructor called by the factory throws.
-* [*Notes:] See [link boost_optional.in_place_factories In-Place Factories]
-* [*Exception Safety:] Exceptions can only be thrown during the call to
-the `T` constructor used by the factory; in that case, this constructor has
-no effect.
-* [*Example:]
-``
-class C { C ( char, double, std::string ) ; } ;
-
-C v('A',123.4,"hello");
-
-optional<C> x( in_place   ('A', 123.4, "hello") ); // InPlaceFactory used
-optional<C> y( in_place<C>('A', 123.4, "hello") ); // TypedInPlaceFactory used
-
-assert ( *x == v ) ;
-assert ( *y == v ) ;
-``
-
-__SPACE__
-
-[#reference_optional_operator_equal_value]
-
-[: `optional& optional<T` ['(not a ref)]`>::operator= ( T const& rhs ) ;`]
-
-* [*Effect:] Assigns the value `rhs` to an `optional`.
-* [*Postconditions: ] `*this` is initialized and its value is a ['copy] of `rhs`.
-* [*Throws:] Whatever `T::operator=( T const& )` or `T::T(T const&)` throws.
-* [*Notes:] If `*this` was initialized, `T`'s assignment operator is used,
-otherwise, its copy-constructor is used.
-* [*Exception Safety:] In the event of an exception, the initialization
-state of `*this` is unchanged and its value unspecified as far as `optional`
-is concerned (it is up to `T`'s `operator=()`). If `*this` is initially
-uninitialized and `T`'s ['copy constructor] fails, `*this` is left properly
-uninitialized.
-* [*Example:]
-``
-T x;
-optional<T> def ;
-optional<T> opt(x) ;
-
-T y;
-def = y ;
-assert ( *def == y ) ;
-opt = y ;
-assert ( *opt == y ) ;
-``
-
-__SPACE__
-
-[: `optional<T&>& optional<T&>::operator= ( T& rhs ) ;`]
-
-* [*Effect:] (Re)binds the wrapped reference.
-* [*Postconditions: ] `*this` is initialized and it references the same
-object referenced by `rhs`.
-* [*Notes:] If `*this` was initialized, is is ['rebound] to the new object.
-See [link boost_optional.rebinding_semantics_for_assignment_of_optional_references here] for details on this behavior.
-* [*Example:]
-``
-int a = 1 ;
-int b = 2 ;
-T& ra = a ;
-T& rb = b ;
-optional<int&> def ;
-optional<int&> opt(ra) ;
-
-def = rb ; // binds 'def' to 'b' through 'rb'
-assert ( *def == b ) ;
-*def = a ; // changes the value of 'b' to a copy of the value of 'a'
-assert ( b == a ) ;
-int c = 3;
-int& rc = c ;
-opt = rc ; // REBINDS to 'c' through 'rc'
-c = 4 ;
-assert ( *opt == 4 ) ;
-``
-
-__SPACE__
-
-[#reference_optional_operator_equal_optional]
-
-[: `optional& optional<T` ['(not a ref)]`>::operator= ( optional const& rhs ) ;`]
-
-* [*Effect:] Assigns another `optional` to an `optional`.
-* [*Postconditions:] If `rhs` is initialized, `*this` is initialized and
-its value is a ['copy] of the value of `rhs`; else `*this` is uninitialized.
-* [*Throws:] Whatever `T::operator( T const&)` or  `T::T( T const& )` throws.
-* [*Notes:] If both `*this` and `rhs` are initially initialized, `T`'s
-['assignment operator] is used. If `*this` is initially initialized but `rhs` is
-uninitialized, `T`'s [destructor] is called. If `*this` is initially uninitialized
-but `rhs` is initialized, `T`'s ['copy constructor] is called.
-* [*Exception Safety:] In the event of an exception, the initialization state of
-`*this` is unchanged and its value unspecified as far as optional is concerned
-(it is up to `T`'s `operator=()`). If `*this` is initially uninitialized and
-`T`'s ['copy constructor] fails, `*this` is left properly uninitialized.
-* [*Example:]
-``
-T v;
-optional<T> opt(v);
-optional<T> def ;
-
-opt = def ;
-assert ( !def ) ;
-// previous value (copy of 'v') destroyed from within 'opt'.
-``
-
-__SPACE__
-
-[: `optional<T&> & optional<T&>::operator= ( optional<T&> const& rhs ) ;`]
-
-* [*Effect:] (Re)binds thee wrapped reference.
-* [*Postconditions:] If `*rhs` is initialized, `*this` is initialized and it
-references the same object referenced by `*rhs`; otherwise, `*this` is
-uninitialized (and references no object).
-* [*Notes:] If `*this` was initialized and so is *rhs, this is is ['rebound] to
-the new object. See [link boost_optional.rebinding_semantics_for_assignment_of_optional_references here] for details on this behavior.
-* [*Example:]
-``
-int a = 1 ;
-int b = 2 ;
-T& ra = a ;
-T& rb = b ;
-optional<int&> def ;
-optional<int&> ora(ra) ;
-optional<int&> orb(rb) ;
-
-def = orb ; // binds 'def' to 'b' through 'rb' wrapped within 'orb'
-assert ( *def == b ) ;
-*def = ora ; // changes the value of 'b' to a copy of the value of 'a'
-assert ( b == a ) ;
-int c = 3;
-int& rc = c ;
-optional<int&> orc(rc) ;
-ora = orc ; // REBINDS ora to 'c' through 'rc'
-c = 4 ;
-assert ( *ora == 4 ) ;
-``
-
-__SPACE__
-
-[#reference_optional_operator_equal_other_optional]
-
-[: `template<U> optional& optional<T` ['(not a ref)]`>::operator= ( optional<U> const& rhs ) ;`]
-
-* [*Effect:] Assigns another convertible optional to an optional.
-* [*Postconditions:] If `rhs` is initialized, `*this` is initialized and
-its value is a ['copy] of the value of `rhs` ['converted] to type `T`; else
-`*this` is uninitialized. 
-* [*Throws:] Whatever `T::operator=( U const& )` or `T::T( U const& )` throws.
-* [*Notes:] If both `*this` and rhs are initially initialized, `T`'s
-['assignment operator] (from `U`) is used. If `*this` is initially initialized
-but `rhs` is uninitialized, `T`'s ['destructor] is called. If `*this` is
-initially uninitialized but rhs is initialized, `T`'s ['converting constructor]
-(from `U`) is called.
-* [*Exception Safety:] In the event of an exception, the initialization state
-of `*this` is unchanged and its value unspecified as far as optional is
-concerned (it is up to `T`'s `operator=()`). If `*this` is initially
-uninitialized and `T`'s converting constructor fails, `*this` is left properly
-uninitialized.
-* [*Example:]
-``
-T v;
-optional<T> opt0(v);
-optional<U> opt1;
-
-opt1 = opt0 ;
-assert ( *opt1 == static_cast<U>(v) ) ;
-``
-
-__SPACE__
-
-[#reference_optional_operator_equal_factory]
-
-[: `template<InPlaceFactory> optional<T>& optional<T` ['(not a ref)]`>::operator=( InPlaceFactory const& f );`]
-[: `template<TypedInPlaceFactory> optional<T>& optional<T` ['(not a ref)]`>::operator=( TypedInPlaceFactory const& f );`]
-
-* [*Effect:] Assigns an `optional` with a value of `T` obtained from the
-factory.
-* [*Postconditions: ] `*this` is [_initialized] and its value is ['directly given]
-from the factory `f` (i.e., the value [_is not copied]).
-* [*Throws:] Whatever the `T` constructor called by the factory throws.
-* [*Notes:] See [link boost_optional.in_place_factories In-Place Factories]
-* [*Exception Safety:] Exceptions can only be thrown during the call to
-the `T` constructor used by the factory; in that case, the `optional` object
-will be reset to be ['uninitialized].
-
-__SPACE__
-
-[#reference_optional_reset_value]
-
-[: `void optional<T` ['(not a ref)]`>::reset( T const& v ) ;`]
-* [*Deprecated:] same as `operator= ( T const& v) ;`
-
-__SPACE__
-
-[#reference_optional_reset]
-
-[: `void optional<T>::reset() ;`]
-* [*Deprecated:] Same as `operator=( detail::none_t );`
-
-__SPACE__
-
-[#reference_optional_get]
-
-[: `T const& optional<T` ['(not a ref)]`>::operator*() const ;`]
-[: `T&       optional<T` ['(not a ref)]`>::operator*();`]
-[: `T const& optional<T` ['(not a ref)]`>::get() const ;`]
-[: `T&       optional<T` ['(not a ref)]`>::get() ;`]
-
-[: `inline T const& get ( optional<T` ['(not a ref)]`> const& ) ;`]
-[: `inline T&       get ( optional<T` ['(not a ref)]`> &) ;`]
-
-* [*Requirements:] `*this` is initialized
-* [*Returns:] A reference to the contained value
-* [*Throws:] Nothing.
-* [*Notes:] The requirement is asserted via `BOOST_ASSERT()`.
-* [*Example:]
-``
-T v ;
-optional<T> opt ( v );
-T const& u = *opt;
-assert ( u == v ) ;
-T w ;
-*opt = w ;
-assert ( *opt == w ) ;
-``
-
-__SPACE__
-
-[#reference_optional_get_value_or_value]
-
-[: `T const& optional<T` ['(not a ref)]`>::get_value_or( T const& default) const ;`]
-[: `T&       optional<T` ['(not a ref)]`>::get_value_or( T&       default ) ;`]
-
-[: `inline T const& get_optional_value_or ( optional<T` ['(not a ref)]`> const& o, T const& default ) ;`]
-[: `inline T&       get_optional_value_or ( optional<T` ['(not a ref)]`>&       o, T&       default ) ;`]
-
-* [*Returns:] A reference to the contained value, if any, or `default`.
-* [*Throws:] Nothing.
-* [*Example:]
-``
-T v, z ;
-optional<T> def;
-T const& y = def.get_value_or(z);
-assert ( y == z ) ;
-
-optional<T> opt ( v );
-T const& u = get_optional_value_or(opt,z);
-assert ( u == v ) ;
-assert ( u != z ) ;
-``
-
-__SPACE__
-
-[: `T const& optional<T&>::operator*() const ;`]
-[: `T      & optional<T&>::operator*();`]
-[: `T const& optional<T&>::get() const ;`]
-[: `T&       optional<T&>::get() ;`]
-
-[: `inline T const& get ( optional<T&> const& ) ;`]
-[: `inline T&       get ( optional<T&> &) ;`]
-
-* [*Requirements: ] `*this` is initialized
-* [*Returns:] [_The] reference contained.
-* [*Throws:] Nothing.
-* [*Notes:] The requirement is asserted via `BOOST_ASSERT()`.
-* [*Example:]
-``
-T v ;
-T& vref = v ;
-optional<T&> opt ( vref );
-T const& vref2 = *opt;
-assert ( vref2 == v ) ;
-++ v ;
-assert ( *opt == v ) ;
-``
-
-__SPACE__
-
-[#reference_optional_get_ptr]
-
-[: `T const* optional<T` ['(not a ref)]`>::get_ptr() const ;`]
-[: `T*       optional<T` ['(not a ref)]`>::get_ptr() ;`]
-
-[: `inline T const* get_pointer ( optional<T` ['(not a ref)]`> const& ) ;`]
-[: `inline T*       get_pointer ( optional<T` ['(not a ref)]`> &) ;`]
-
-* [*Returns:] If `*this` is initialized, a pointer to the contained value;
-else `0` (['null]).
-* [*Throws:] Nothing.
-* [*Notes:] The contained value is permanently stored within `*this`, so you
-should not hold nor delete this pointer
-* [*Example:]
-``
-T v;
-optional<T> opt(v);
-optional<T> const copt(v);
-T* p = opt.get_ptr() ;
-T const* cp = copt.get_ptr();
-assert ( p == get_pointer(opt) );
-assert ( cp == get_pointer(copt) ) ;
-``
-
-__SPACE__
-
-[#reference_optional_operator_arrow]
-
-[: `T const* optional<T` ['(not a ref)]`>::operator ->() const ;`]
-[: `T*       optional<T` ['(not a ref)]`>::operator ->()       ;`]
-
-* [*Requirements: ] `*this` is initialized.
-* [*Returns:] A pointer to the contained value.
-* [*Throws:] Nothing.
-* [*Notes:] The requirement is asserted via `BOOST_ASSERT()`.
-* [*Example:]
-``
-struct X { int mdata ; } ;
-X x ;
-optional<X> opt (x);
-opt->mdata = 2 ;
-``
-
-__SPACE__
-
-[#reference_optional_operator_bool]
-
-[: `optional<T>::operator `['unspecified-bool-type]`() const ;`]
-
-* [*Returns:] An unspecified value which if used on a boolean context
-is equivalent to (`get() != 0`)
-* [*Throws:] Nothing.
-* [*Example:]
-``
-optional<T> def ;
-assert ( def == 0 );
-optional<T> opt ( v ) ;
-assert ( opt );
-assert ( opt != 0 );
-``
-
-__SPACE__
-
-[#reference_optional_operator_not]
-
-[: `bool optional<T>::operator!() ;`]
-
-* [*Returns:] If `*this` is uninitialized, `true`; else `false`.
-* [*Throws:] Nothing.
-* [*Notes:] This operator is provided for those compilers which can't
-use the ['unspecified-bool-type operator] in certain boolean contexts.
-* [*Example:]
-``
-optional<T> opt ;
-assert ( !opt );
-*opt = some_T ;
-
-// Notice the "double-bang" idiom here.
-assert ( !!opt ) ;
-``
-
-__SPACE__
-
-[#reference_optional_is_initialized]
-
-[: `bool optional<T>::is_initialized() const ;`]
-
-* [*Returns: ] `true` if the `optional` is initialized, `false` otherwise.
-* [*Throws:] Nothing.
-* [*Example:]
-``
-optional<T> def ;
-assert ( !def.is_initialized() );
-optional<T> opt ( v ) ;
-assert ( opt.is_initialized() );
-``
-
-__SPACE__
-
-[heading Free functions]
-
-__SPACE__
-
-[#reference_make_optional_value]
-
-[: `optional<T` ['(not a ref)]`> make_optional( T const& v )`]
-
-* [*Returns: ] `optional<T>(v)` for the ['deduced] type `T` of `v`.
-* [*Example:]
-``
-template<class T> void foo ( optional<T> const& opt ) ;
-
-foo ( make_optional(1+1) ) ; // Creates an optional<int>
-``
-
-__SPACE__
-
-[#reference_make_optional_bool_value]
-
-[: `optional<T` ['(not a ref)]`> make_optional( bool condition, T const& v )`]
-
-* [*Returns: ] `optional<T>(condition,v)` for the ['deduced] type `T` of `v`.
-* [*Example:]
-``
-optional<double> calculate_foo()
-{
-  double val = compute_foo();
-  return make_optional(is_not_nan_and_finite(val),val);
-}
-
-optional<double> v = calculate_foo();
-if ( !v )
-  error("foo wasn't computed");
-``
-
-__SPACE__
-
-[#reference_operator_compare_equal_optional_optional]
-
-[: `bool operator == ( optional<T> const& x, optional<T> const& y );`]
-
-* [*Returns:] If both `x` and `y` are initialized, `(*x == *y)`. If only
-`x` or `y` is initialized, `false`. If both are uninitialized, `true`.
-* [*Throws:] Nothing.
-* [*Notes:] Pointers have shallow relational operators while `optional` has
-deep relational operators. Do not use `operator ==` directly in generic
-code which expect to be given either an `optional<T>` or a pointer; use
-__FUNCTION_EQUAL_POINTEES__ instead
-* [*Example:]
-``
-T x(12);
-T y(12);
-T z(21);
-optional<T> def0 ;
-optional<T> def1 ;
-optional<T> optX(x);
-optional<T> optY(y);
-optional<T> optZ(z);
-
-// Identity always hold
-assert ( def0 == def0 );
-assert ( optX == optX );
-
-// Both uninitialized compare equal
-assert ( def0 == def1 );
-
-// Only one initialized compare unequal.
-assert ( def0 != optX );
-
-// Both initialized compare as (*lhs == *rhs)
-assert ( optX == optY ) ;
-assert ( optX != optZ ) ;
-``
-
-__SPACE__
-
-[#reference_operator_compare_less_optional_optional]
-
-[: `bool operator < ( optional<T> const& x, optional<T> const& y );`]
-
-* [*Returns:] If `y` is not initialized, `false`. If `y` is initialized
-and `x` is not initialized, `true`. If both `x` and `y` are initialized,
-`(*x < *y)`.
-* [*Throws:] Nothing.
-* [*Notes:] Pointers have shallow relational operators while `optional` has
-deep relational operators. Do not use `operator <` directly in generic code
-which expect to be given either an `optional<T>` or a pointer; use __FUNCTION_LESS_POINTEES__ instead.
-* [*Example:]
-``
-T x(12);
-T y(34);
-optional<T> def ;
-optional<T> optX(x);
-optional<T> optY(y);
-
-// Identity always hold
-assert ( !(def < def) );
-assert ( optX == optX );
-
-// Both uninitialized compare equal
-assert ( def0 == def1 );
-
-// Only one initialized compare unequal.
-assert ( def0 != optX );
-
-// Both initialized compare as (*lhs == *rhs)
-assert ( optX == optY ) ;
-assert ( optX != optZ ) ;
-``
-
-__SPACE__
-
-[#reference_operator_compare_not_equal_optional_optional]
-
-[: `bool operator != ( optional<T> const& x, optional<T> const& y );`]
-
-* [*Returns: ] `!( x == y );`
-* [*Throws:] Nothing.
-
-__SPACE__
-
-[#reference_operator_compare_greater_optional_optional]
-
-[: `bool operator > ( optional<T> const& x, optional<T> const& y );`]
-
-* [*Returns: ] `( y < x );`
-* [*Throws:] Nothing.
-
-__SPACE__
-
-[#reference_operator_compare_less_or_equal_optional_optional]
-
-[: `bool operator <= ( optional<T> const& x, optional<T> const& y );`]
-
-* [*Returns: ] `!( y<x );`
-* [*Throws:] Nothing.
-
-__SPACE__
-
-[#reference_operator_compare_greater_or_equal_optional_optional]
-
-[: `bool operator >= ( optional<T> const& x, optional<T> const& y );`]
-
-* [*Returns: ] `!( x<y );`
-* [*Throws:] Nothing.
-
-__SPACE__
-
-[#reference_swap_optional_optional]
-
-[: `void swap ( optional<T>& x, optional<T>& y );`]
-
-* [*Effect:] If both `x` and `y` are initialized, calls `swap(*x,*y)`
-using `std::swap`. If only one is initialized, say `x`, calls:
-`y.reset(*x); x.reset();` If none is initialized, does nothing.
-* [*Postconditions:] The states of `x` and `y` interchanged.
-* [*Throws:] If both are initialized, whatever `swap(T&,T&)` throws. If only
-one is initialized, whatever `T::T ( T const& )` throws.
-* [*Notes:] If both are initialized, `swap(T&,T&)` is used unqualified but
-with `std::swap` introduced in scope.
-If only one is initialized, `T::~T()` and `T::T( T const& )` is called.
-* [*Exception Safety:] If both are initialized, this operation has the
-exception safety guarantees of `swap(T&,T&)`.
-If only one is initialized, it has the same basic guarantee as
-`optional<T>::reset( T const& )`.
-* [*Example:]
-``
-T x(12);
-T y(21);
-optional<T> def0 ;
-optional<T> def1 ;
-optional<T> optX(x);
-optional<T> optY(y);
-
-boost::swap(def0,def1); // no-op
-
-boost::swap(def0,optX);
-assert ( *def0 == x );
-assert ( !optX );
-
-boost::swap(def0,optX); // Get back to original values
-
-boost::swap(optX,optY);
-assert ( *optX == y );
-assert ( *optY == x );
-``
-
-[endsect]
@@ -1,372 +0,0 @@
-
-[section Optional references]
-
-This library allows the template parameter `T` to be of reference type:
-`T&`, and to some extent, `T const&`.
-
-However, since references are not real objects some restrictions apply and
-some operations are not available in this case:
-
-* Converting constructors
-* Converting assignment
-* InPlace construction
-* InPlace assignment
-* Value-access via pointer
-
-Also, even though `optional<T&>` treats it wrapped pseudo-object much as
-a real value, a true real reference is stored so aliasing will ocurr:
-
-* Copies of `optional<T&>` will copy the references but all these references
-will nonetheless reefer to the same object.
-* Value-access will actually provide access to the referenced object
-rather than the reference itself.
-
-[endsect]
-
-[section Rebinding semantics for assignment of optional references]
-
-If you assign to an ['uninitialized ] `optional<T&>` the effect is to bind (for
-the first time) to the object. Clearly, there is no other choice.
-
-    int x = 1 ;
-    int& rx = x ;
-    optional<int&> ora ;
-    optional<int&> orb(x) ;
-    ora = orb ; // now 'ora' is bound to 'x' through 'rx'
-    *ora = 2 ; // Changes value of 'x' through 'ora'
-    assert(x==2); 
-
-If you assign to a bare C++ reference, the assignment is forwarded to the
-referenced object; its value changes but the reference is never rebound.
-
-    int a = 1 ;
-    int& ra = a ;
-    int b = 2 ;
-    int& rb = b ;
-    ra = rb ; // Changes the value of 'a' to 'b'
-    assert(a==b);
-    b = 3 ;
-    assert(ra!=b); // 'ra' is not rebound to 'b'
-
-Now, if you assign to an ['initialized ] `optional<T&>`, the effect is to
-[*rebind] to the new object instead of assigning the referee. This is unlike
-bare C++ references.
-
-    int a = 1 ;
-    int b = 2 ;
-    int& ra = a ;
-    int& rb = b ;
-    optional<int&> ora(ra) ;
-    optional<int&> orb(rb) ;
-    ora = orb ; // 'ora' is rebound to 'b'
-    *ora = 3 ; // Changes value of 'b' (not 'a')
-    assert(a==1); 
-    assert(b==3); 
-
-[heading Rationale]
-
-Rebinding semantics for the assignment of ['initialized ] `optional` references has
-been chosen to provide [*consistency among initialization states] even at the
-expense of lack of consistency with the semantics of bare C++ references.
-It is true that `optional<U>` strives to behave as much as possible as `U`
-does whenever it is initialized; but in the case when `U` is `T&`, doing so would
-result in inconsistent behavior w.r.t to the lvalue initialization state.
-
-Imagine `optional<T&>` forwarding assignment to the referenced object (thus
-changing the referenced object value but not rebinding), and consider the
-following code:
-
-    optional<int&> a = get();
-    int x = 1 ;
-    int& rx = x ;
-    optional<int&> b(rx);
-    a = b ;
-
-What does the assignment do?
-
-If `a` is ['uninitialized], the answer is clear: it binds to `x` (we now have
-another reference to `x`).
-But what if `a` is already ['initialized]? it would change the value of the
-referenced object (whatever that is); which is inconsistent with the other
-possible case.
-
-If `optional<T&>` would assign just like `T&` does, you would never be able to
-use Optional's assignment without explicitly handling the previous
-initialization state unless your code is capable of functioning whether
-after the assignment, `a` aliases the same object as `b` or not.
-
-That is, you would have to discriminate in order to be consistent.
-
-If in your code rebinding to another object is not an option, then it is very
-likely that binding for the first time isn't either. In such case, assignment
-to an ['uninitialized ] `optional<T&>` shall be prohibited. It is quite possible
-that in such a scenario it is a precondition that the lvalue must be already
-initialized. If it isn't, then binding for the first time is OK
-while rebinding is not which is IMO very unlikely.
-In such a scenario, you can assign the value itself directly, as in:
-
-    assert(!!opt);
-    *opt=value;
-
-[endsect]
-
-[section In-Place Factories]
-
-One of the typical problems with wrappers and containers is that their
-interfaces usually provide an operation to initialize or assign the
-contained object as a copy of some other object. This not only requires the
-underlying type to be __COPY_CONSTRUCTIBLE__, but also requires the existence of
-a fully constructed object, often temporary, just to follow the copy from:
-
-    struct X
-    {
-        X ( int, std:::string ) ;
-    } ;
-
-    class W
-    {
-        X wrapped_ ;
-
-        public:
-
-        W ( X const& x ) : wrapped_(x) {}
-    } ;
-
-    void foo()
-    {
-        // Temporary object created.
-        W ( X(123,"hello") ) ;
-    }
-
-A solution to this problem is to support direct construction of the
-contained object right in the container's storage.
-In this scheme, the user only needs to supply the arguments to the
-constructor to use in the wrapped object construction.
-
-    class W
-    {
-        X wrapped_ ;
-
-        public:
-
-        W ( X const& x ) : wrapped_(x) {}
-        W ( int a0, std::string a1) : wrapped_(a0,a1) {}
-    } ;
-
-    void foo()
-    {
-        // Wrapped object constructed in-place
-        // No temporary created.
-        W (123,"hello") ;
-    }
-
-A limitation of this method is that it doesn't scale well to wrapped
-objects with multiple constructors nor to generic code were the constructor
-overloads are unknown.
-
-The solution presented in this library is the family of [*InPlaceFactories]
-and [*TypedInPlaceFactories].
-These factories are a family of classes which encapsulate an increasing
-number of arbitrary constructor parameters and supply a method to construct
-an object of a given type using those parameters at an address specified by
-the user via placement new.
-
-For example, one member of this family looks like:
-
-    template<class T,class A0, class A1>
-    class TypedInPlaceFactory2
-    {
-        A0 m_a0 ; A1 m_a1 ;
-
-        public:
-
-        TypedInPlaceFactory2( A0 const& a0, A1 const& a1 ) : m_a0(a0), m_a1(a1) {}
-
-        void construct ( void* p ) { new (p) T(m_a0,m_a1) ; }
-     } ;
-
-A wrapper class aware of this can use it as:
-
-    class W
-    {
-        X wrapped_ ;
-
-        public:
-
-        W ( X const& x ) : wrapped_(x) {}
-        W ( TypedInPlaceFactory2 const& fac ) { fac.construct(&wrapped_) ; }
-    } ;
-
-    void foo()
-    {
-        // Wrapped object constructed in-place via a TypedInPlaceFactory.
-        // No temporary created.
-        W ( TypedInPlaceFactory2<X,int,std::string>(123,"hello")) ;
-    }
-
-The factories are divided in two groups:
-
-* [_TypedInPlaceFactories]: those which take the target type as a primary
-template parameter.
-* [_InPlaceFactories]: those with a template `construct(void*)` member
-function taking the target type.
-
-Within each group, all the family members differ only in the number of
-parameters allowed.
-
-This library provides an overloaded set of helper template functions to
-construct these factories without requiring unnecessary template parameters:
-
-    template<class A0,...,class AN>
-    InPlaceFactoryN <A0,...,AN> in_place ( A0 const& a0, ..., AN const& aN) ;
-
-    template<class T,class A0,...,class AN>
-    TypedInPlaceFactoryN <T,A0,...,AN> in_place ( T const& a0, A0 const& a0, ..., AN const& aN) ;
-
-In-place factories can be used generically by the wrapper and user as follows:
-
-    class W
-    {
-        X wrapped_ ;
-
-        public:
-
-        W ( X const& x ) : wrapped_(x) {}
-
-        template< class InPlaceFactory >
-        W ( InPlaceFactory const& fac ) { fac.template <X>construct(&wrapped_) ; }
-
-    } ;
-
-    void foo()
-    {
-        // Wrapped object constructed in-place via a InPlaceFactory.
-        // No temporary created.
-        W ( in_place(123,"hello") ) ;
-    }
-
-The factories are implemented in the headers: __IN_PLACE_FACTORY_HPP__ and __TYPED_IN_PLACE_FACTORY_HPP__
-
-[endsect]
-
-[section A note about optional<bool>]
-
-`optional<bool>` should be used with special caution and consideration.
-
-First, it is functionally similar to a tristate boolean (false,maybe,true)
-—such as __BOOST_TRIBOOL__— except that in a tristate boolean, the maybe state
-[_represents a valid value], unlike the corresponding state of an uninitialized
-`optional<bool>`.
-It should be carefully considered if an `optional<bool>` instead of a `tribool`
-is really needed.
-
-Second, `optional<>` provides an implicit conversion to `bool`. This
-conversion refers to the initialization state and not to the contained value.
-Using `optional<bool>` can lead to subtle errors due to the implicit `bool`
-conversion:
-
-    void foo ( bool v ) ;
-    void bar()
-    {
-        optional<bool> v = try();
-
-        // The following intended to pass the value of 'v' to foo():
-        foo(v);
-        // But instead, the initialization state is passed
-        // due to a typo: it should have been foo(*v).
-    }
-
-The only implicit conversion is to `bool`, and it is safe in the sense that
-typical integral promotions don't apply (i.e. if `foo()` takes an `int`
-instead, it won't compile).
-
-[endsect]
-
-[section Exception Safety Guarantees]
-
-Because of the current implementation (see [link boost_optional.implementation_notes Implementation Notes]), all of the assignment methods:
-
-* `optional<T>::operator= ( optional<T> const& )`
-* `optional<T>::operator= ( T const& )`
-* `template<class U> optional<T>::operator= ( optional<U> const& )`
-* `template<class InPlaceFactory> optional<T>::operator= ( InPlaceFactory const& )`
-* `template<class TypedInPlaceFactory> optional<T>::operator= ( TypedInPlaceFactory const& ) `
-* `optional<T>:::reset ( T const&)`
-
-Can only ['guarantee] the [_basic exception safety]: The lvalue optional is
-left [_uninitialized] if an exception is thrown (any previous value is ['first]
-destroyed using `T::~T()`)
-
-On the other hand, the ['uninitializing] methods:
-
-* `optional<T>::operator= ( detail::none_t )`
-* `optional<T>::reset()`
-
-Provide the no-throw guarantee (assuming a no-throw `T::~T()`)
-
-However, since `optional<>` itself doesn't throw any exceptions, the only
-source for exceptions here are `T`'s constructor, so if you know the exception
-guarantees for `T::T ( T const& )`, you know that `optional`'s assignment and
-reset has the same guarantees.
-
-    //
-    // Case 1: Exception thrown during assignment.
-    //
-    T v0(123);
-    optional<T> opt0(v0);
-    try
-    {
-        T v1(456);
-        optional<T> opt1(v1);
-        opt0 = opt1 ;
-
-        // If no exception was thrown, assignment succeeded.
-        assert( *opt0 == v1 ) ;
-    }
-    catch(...)
-    {
-        // If any exception was thrown, 'opt0' is reset to uninitialized.
-        assert( !opt0 ) ;
-    }
-
-    //
-    // Case 2: Exception thrown during reset(v)
-    //
-    T v0(123);
-    optional<T> opt(v0);
-    try
-    {
-        T v1(456);
-        opt.reset ( v1 ) ;
-
-        // If no exception was thrown, reset succeeded.
-        assert( *opt == v1 ) ;
-    }
-    catch(...)
-    {
-        // If any exception was thrown, 'opt' is reset to uninitialized.
-        assert( !opt ) ;
-    }
-
-[heading Swap]
-
-`void swap( optional<T>&, optional<T>& )` has the same exception guarantee
-as `swap(T&,T&)` when both optionals are initialized.
-If only one of the optionals is initialized, it gives the same ['basic]
-exception guarantee as `optional<T>::reset( T const& )` (since
-`optional<T>::reset()` doesn't throw).
-If none of the optionals is initialized, it has no-throw guarantee
-since it is a no-op.
-
-[endsect]
-
-[section Type requirements]
-
-In general, `T` must be __COPY_CONSTRUCTIBLE__ and have a no-throw destructor.
-The copy-constructible requirement is not needed if [*InPlaceFactories] are used.
-
-`T` [_is not] required to be __SGI_DEFAULT_CONSTRUCTIBLE__.
-
-[endsect]
-
-
@@ -1,4 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2014, 2015 Andrzej Krzemienski.
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
@@ -12,6 +13,7 @@
 #ifndef BOOST_NONE_17SEP2003_HPP
 #define BOOST_NONE_17SEP2003_HPP

+#include "boost/config.hpp"
 #include "boost/none_t.hpp"

 // NOTE: Borland users have to include this header outside any precompiled headers
@@ -20,9 +22,38 @@

 namespace boost {

-none_t const none = (static_cast<none_t>(0)) ;
+#ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
+
+BOOST_INLINE_VARIABLE none_t BOOST_CONSTEXPR_OR_CONST none = (static_cast<none_t>(0)) ;
+
+#elif defined BOOST_OPTIONAL_USE_SINGLETON_DEFINITION_OF_NONE
+
+namespace detail { namespace optional_detail {
+
+  // the trick here is to make boost::none defined once as a global but in a header file
+  template <typename T>
+  struct none_instance
+  {
+    static const T instance;
+  };
+
+  template <typename T>
+  const T none_instance<T>::instance = T(); // global, but because 'tis a template, no cpp file required
+
+} } // namespace detail::optional_detail
+
+
+namespace {
+  // TU-local
+  const none_t& none = detail::optional_detail::none_instance<none_t>::instance;
+}
+
+#else
+
+BOOST_INLINE_CONSTEXPR none_t none ((none_t::init_tag()));
+
+#endif // older definitions

 } // namespace boost

-#endif
-
+#endif // header guard
@@ -1,4 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2014, 2024 Andrzej Krzemienski.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -12,13 +13,48 @@
 #ifndef BOOST_NONE_T_17SEP2003_HPP
 #define BOOST_NONE_T_17SEP2003_HPP

-namespace boost {
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>

-namespace detail { struct none_helper{}; }
+#if defined (BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) \
+|| defined(BOOST_NO_CXX11_LAMBDAS) || defined(BOOST_NO_CXX11_DECLTYPE_N3276)  \
+|| defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) \
+|| defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) || defined(BOOST_NO_CXX11_STATIC_ASSERT)

-typedef int detail::none_helper::*none_t ;
+#error "Boost.Optional requires some C++11 features since version 1.87. If you have an older C++ version use Boost.Optional version 1.86 or earlier."

-} // namespace boost
+#elif defined(BOOST_NO_CXX11_REF_QUALIFIERS) || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_DEFAULTED_MOVES)
+
+BOOST_PRAGMA_MESSAGE("C++03 support is deprecated in Boost.Optional 1.83 and will be removed in Boost.Optional 1.92.")

 #endif

+namespace boost {
+
+#ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
+
+namespace detail { struct none_helper{}; }
+typedef int detail::none_helper::*none_t ;
+
+#elif defined BOOST_OPTIONAL_USE_SINGLETON_DEFINITION_OF_NONE
+
+class none_t {};
+
+#else
+
+struct none_t
+{
+  struct init_tag{};
+  explicit BOOST_CONSTEXPR none_t(init_tag){} // to disable default constructor
+
+#ifndef BOOST_OPTIONAL_DISABLE_EQUALITY_FOR_NONE
+  friend BOOST_CONSTEXPR bool operator==(none_t, none_t) { return true; }
+  friend BOOST_CONSTEXPR bool operator!=(none_t, none_t) { return false; }
+#endif
+};
+
+#endif // old implementation workarounds
+
+} // namespace boost
+
+#endif // header guard
@@ -0,0 +1,41 @@
+// Copyright (C) 2014, Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+//
+#ifndef BOOST_BAD_OPTIONAL_ACCESS_22MAY2014_HPP
+#define BOOST_BAD_OPTIONAL_ACCESS_22MAY2014_HPP
+
+#include <stdexcept>
+#if __cplusplus < 201103L
+#include <string> // to make converting-ctor std::string(char const*) visible
+#endif
+
+namespace boost {
+
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+class bad_optional_access : public std::logic_error
+{
+public:
+  bad_optional_access()
+    : std::logic_error("Attempted to access the value of an uninitialized optional object.")
+    {}
+};
+
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#endif
+
+} // namespace boost
+
+#endif
@@ -0,0 +1,59 @@
+// Copyright (C) 2017 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#ifndef BOOST_OPTIONAL_DETAIL_EXPERIMENTAL_TRAITS_04NOV2017_HPP
+#define BOOST_OPTIONAL_DETAIL_EXPERIMENTAL_TRAITS_04NOV2017_HPP
+
+#include <boost/type_traits.hpp>
+
+// The condition to use POD implementation
+
+#ifdef BOOST_OPTIONAL_CONFIG_NO_POD_SPEC
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif defined BOOST_OPTIONAL_CONFIG_NO_SPEC_FOR_TRIVIAL_TYPES
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif !defined BOOST_HAS_TRIVIAL_MOVE_ASSIGN
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif !defined BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif !defined BOOST_HAS_TRIVIAL_COPY
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif !defined BOOST_HAS_TRIVIAL_ASSIGN
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif !defined BOOST_HAS_TRIVIAL_DESTRUCTOR
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#endif
+
+
+namespace boost { namespace optional_detail {
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+template <typename T>
+struct is_trivially_semiregular
+  : boost::conditional<(boost::has_trivial_copy_constructor<T>::value &&
+                        boost::has_trivial_move_constructor<T>::value &&
+                        boost::has_trivial_destructor<T>::value &&
+                        boost::has_trivial_move_assign<T>::value &&
+                        boost::has_trivial_assign<T>::value),
+                        boost::true_type, boost::false_type>::type
+{};
+#else
+template <typename T>
+struct is_trivially_semiregular
+: boost::conditional<(boost::is_scalar<T>::value && !boost::is_const<T>::value && !boost::is_volatile<T>::value),
+                     boost::true_type, boost::false_type>::type
+{};
+#endif
+
+
+}} // boost::optional_detail
+
+#endif
@@ -0,0 +1,70 @@
+// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2016 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  fernando_cacciola@hotmail.com
+//  akrzemi1@gmail.com
+
+#ifndef BOOST_OPTIONAL_OPTIONAL_DETAIL_OPTIONAL_ALIGNED_STORAGE_AJK_12FEB2016_HPP
+#define BOOST_OPTIONAL_OPTIONAL_DETAIL_OPTIONAL_ALIGNED_STORAGE_AJK_12FEB2016_HPP
+
+namespace boost {
+
+namespace optional_detail {
+// This local class is used instead of that in "aligned_storage.hpp"
+// because I've found the 'official' class to ICE BCB5.5
+// when some types are used with optional<>
+// (due to sizeof() passed down as a non-type template parameter)
+template <class T>
+class aligned_storage
+{
+    // Borland ICEs if unnamed unions are used for this!
+    // BOOST_MAY_ALIAS works around GCC warnings about breaking strict aliasing rules when casting storage address to T*
+    union BOOST_MAY_ALIAS dummy_u
+    {
+        unsigned char data[ sizeof(T) ];
+        BOOST_DEDUCED_TYPENAME type_with_alignment<
+          ::boost::alignment_of<T>::value >::type aligner_;
+    } dummy_ ;
+
+  public:
+
+#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
+    void const* address() const { return &dummy_; }
+    void      * address()       { return &dummy_; }
+#else
+    void const* address() const { return dummy_.data; }
+    void      * address()       { return dummy_.data; }
+#endif
+
+#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
+    // This workaround is supposed to silence GCC warnings about broken strict aliasing rules
+    T const* ptr_ref() const
+    {
+        union { void const* ap_pvoid; T const* as_ptype; } caster = { address() };
+        return caster.as_ptype;
+    }
+    T *      ptr_ref()
+    {
+        union { void* ap_pvoid; T* as_ptype; } caster = { address() };
+        return caster.as_ptype;
+    }
+#else
+    T const* ptr_ref() const { return static_cast<T const*>(address()); }
+    T *      ptr_ref()       { return static_cast<T *>     (address()); }
+#endif
+
+    T const& ref() const { return *boost::core::launder(ptr_ref()); }
+    T &      ref()       { return *boost::core::launder(ptr_ref()); }
+} ;
+
+} // namespace optional_detail
+} // namespace boost
+
+#endif // header guard
@@ -0,0 +1,188 @@
+// Copyright (C) 2024 Ryan Malcolm Underwood.
+// Copyright (C) 2026 Andrzej Krzemieński.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the authors at:
+//  akrzemi1@gmail.com
+//  typenametea@gmail.com
+//
+//
+// This header provides definitions required by any specialization of
+// optional<>.
+
+#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_COMMON_DEFS_01FEB2026_HPP
+#define BOOST_OPTIONAL_DETAIL_OPTIONAL_COMMON_DEFS_01FEB2026_HPP
+
+
+#include <boost/config.hpp>
+#include <boost/core/addressof.hpp>
+#include <type_traits>
+#include <boost/optional/detail/optional_factory_support.hpp>
+
+#ifndef BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
+#include <boost/type_traits/decay.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#endif
+
+// This is needed for C++11, where constexpr functions must contain a single expression.
+// We want to assert and then return.
+#if defined NDEBUG
+# define BOOST_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR)
+#else
+# define BOOST_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{BOOST_ASSERT(!(#CHECK));}(), (EXPR)))
+#endif
+
+#ifdef BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
+# define BOOST_OPTIONAL_DECAY(T) typename ::std::decay<T>::type
+# define BOOST_OPTIONAL_IS_TAGGED(TAG, U) ::std::is_base_of<TAG, BOOST_OPTIONAL_DECAY(U)>
+#else
+# define BOOST_OPTIONAL_DECAY(T) BOOST_DEDUCED_TYPENAME boost::decay<T>::type
+# define BOOST_OPTIONAL_IS_TAGGED(TAG, U) boost::is_base_of<TAG, BOOST_OPTIONAL_DECAY(U)>
+#endif
+
+namespace boost {
+
+template <typename T> class optional;
+
+
+// Boost-wide tags for recognizing "factories": a C++03 workaround
+// for perfect forwarding.
+class in_place_factory_base;
+class typed_in_place_factory_base;
+
+} // namespace boost
+
+
+// Traits for recognizing in-place factories
+namespace boost { namespace optional_detail {
+
+template <typename U>
+struct is_in_place_factory : BOOST_OPTIONAL_IS_TAGGED(boost::in_place_factory_base, U) {};
+
+template <typename U>
+struct is_typed_in_place_factory : BOOST_OPTIONAL_IS_TAGGED(boost::typed_in_place_factory_base, U) {};
+
+}}
+
+
+
+/** This is a set of declarations that repeat those from the Standard Library
+    header <utility> but without having to drag its entire content. They also
+    add missing capabilities, like constexpr, in older compiler versions.
+ */
+namespace boost { namespace optional_detail {
+
+template <typename T>
+T declval_();
+
+template <class T>
+inline constexpr T&& forward_(typename ::std::remove_reference<T>::type& t) noexcept
+{
+  return static_cast<T&&>(t);
+}
+
+template <class T>
+inline constexpr T&& forward_(typename ::std::remove_reference<T>::type&& t) noexcept
+{
+  static_assert(!::std::is_lvalue_reference<T>::value, "Can not forward an rvalue as an lvalue.");
+  return static_cast<T&&>(t);
+}
+
+template <class T>
+inline constexpr typename ::std::remove_reference<T>::type&& move_(T&& t) noexcept
+{
+  return static_cast<typename ::std::remove_reference<T>::type&&>(t);
+}
+
+}} // namespace boost::optional_detail
+
+
+/** This is a set of declarations that are not part of this library's interface.
+    They are implementation details.
+ */
+namespace boost { namespace optional_detail {
+
+/** This struct is used for tagging types that want to be recognized as
+    `optional`. If your class inherits directly or indirectly from `optional_tag`
+    the type traits and overloads will treat it as `optional<>`.
+ */
+struct optional_tag {};
+
+/** `optional_value_type`: given type `X`:
+    * if `X` is an instance of `boost::optional`, returns its value_type,
+    * otherwise we get a SFINAE-able error.
+ */
+template <typename X>
+struct optional_value_type
+{
+};
+
+template <typename U>
+struct optional_value_type< ::boost::optional<U> >
+{
+  typedef U type;
+};
+
+
+/** This is an approximation of a 1-argument C++17 std::invoke_result.
+ */
+template <typename F, typename Ref, typename Rslt = decltype(declval_<F>()(declval_<Ref>()))>
+struct result_of
+{
+  typedef Rslt type;
+};
+
+/** This type trait returns the following given the expression `f(ref)`:
+     * if the result is a specialization of `boost::optional`: its value_type,
+     * otherwise a SFINAE-able error.
+ */
+template <typename F, typename Ref, typename Rslt = typename optional_value_type<typename result_of<F, Ref>::type>::type>
+struct result_value_type
+{
+  typedef Rslt type;
+};
+
+}} // namespace boost::optional_detail
+
+
+/** The following two tags are intended to be used by library users.
+    The additional namespace is used in order to prevent the ADL from
+    dragging all functions from namespace `boost` in any unqualified name lookup
+    when these tags are involved.
+ */
+namespace boost {
+
+namespace optional_ns {
+
+/// a tag for in-place initialization of contained value
+struct in_place_init_t
+{
+  struct init_tag{};
+  BOOST_CONSTEXPR explicit in_place_init_t(init_tag){}
+};
+BOOST_INLINE_CONSTEXPR in_place_init_t in_place_init ((in_place_init_t::init_tag()));
+
+/// a tag for conditional in-place initialization of contained value
+struct in_place_init_if_t
+{
+  struct init_tag{};
+  BOOST_CONSTEXPR explicit in_place_init_if_t(init_tag){}
+};
+BOOST_INLINE_CONSTEXPR in_place_init_if_t in_place_init_if ((in_place_init_if_t::init_tag()));
+
+} // namespace optional_ns
+
+using optional_ns::in_place_init_t;
+using optional_ns::in_place_init;
+using optional_ns::in_place_init_if_t;
+using optional_ns::in_place_init_if;
+
+} // namespace boost
+
+
+#endif // BOOST_OPTIONAL_DETAIL_OPTIONAL_COMMON_DEFS_01FEB2026_HPP
@@ -0,0 +1,144 @@
+// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2015 - 2017 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_CONFIG_AJK_28JAN2015_HPP
+#define BOOST_OPTIONAL_DETAIL_OPTIONAL_CONFIG_AJK_28JAN2015_HPP
+
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+
+#if (defined BOOST_OPTIONAL_CONFIG_NO_RVALUE_REFERENCES)
+# define BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+#endif
+
+#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION,<=700)
+// AFAICT only Intel 7 correctly resolves the overload set
+// that includes the in-place factory taking functions,
+// so for the other icc versions, in-place factory support
+// is disabled
+# define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+#endif
+
+#if BOOST_WORKAROUND(BOOST_BORLANDC, <= 0x551)
+// BCB (5.5.1) cannot parse the nested template struct in an inplace factory.
+# define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+#endif
+
+#if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) \
+    && defined BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
+// BCB (up to 5.64) has the following bug:
+//   If there is a member function/operator template of the form
+//     template<class Expr> mfunc( Expr expr ) ;
+//   some calls are resolved to this even if there are other better matches.
+//   The effect of this bug is that calls to converting ctors and assignments
+//   are incorrectly sink to this general catch-all member function template as shown above.
+# define BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
+#endif
+
+#if !defined(BOOST_NO_MAY_ALIAS)
+// GCC since 3.3 and some other compilers have may_alias attribute that helps to alleviate
+// optimizer issues with regard to violation of the strict aliasing rules. The optional< T >
+// storage type is marked with this attribute in order to let the compiler know that it will
+// alias objects of type T and silence compilation warnings.
+# define BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS
+#endif
+
+#if (defined(_MSC_VER) && _MSC_VER <= 1800)
+// on MSVC 2013 and earlier an unwanted temporary is created when you assign from
+// a const lvalue of integral type. Thus we bind not to the original address but
+// to a temporary.
+# define BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT
+#endif
+
+#if (defined __GNUC__) && (!defined BOOST_INTEL_CXX_VERSION) && (!defined __clang__)
+// On some GCC versions an unwanted temporary is created when you copy-initialize
+// from a const lvalue of integral type. Thus we bind not to the original address but
+// to a temporary.
+
+# if (__GNUC__ < 4)
+#  define BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT
+# endif
+
+# if (__GNUC__ == 4 && __GNUC_MINOR__ <= 5)
+#  define BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT
+# endif
+
+# if (__GNUC__ == 5 && __GNUC_MINOR__ < 2)
+#  define BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT
+# endif
+
+# if (__GNUC__ == 5 && __GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ == 0)
+#  define BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT
+# endif
+
+#endif // defined(__GNUC__)
+
+#if (defined __GNUC__)
+// On some initial rvalue reference implementations GCC does it in a strange way,
+// preferring perfect-forwarding constructor to implicit copy constructor.
+
+# if (__GNUC__ == 4 && __GNUC_MINOR__ == 4)
+#  define BOOST_OPTIONAL_CONFIG_NO_LEGAL_CONVERT_FROM_REF
+# endif
+
+# if (__GNUC__ == 4 && __GNUC_MINOR__ == 5)
+#  define BOOST_OPTIONAL_CONFIG_NO_LEGAL_CONVERT_FROM_REF
+# endif
+
+#endif // defined(__GNUC__)
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500) && !defined(__SUNPRO_CC)
+  // this condition is a copy paste from is_constructible.hpp
+  // I also disable SUNPRO, as it seems not to support type_traits correctly
+#else
+# define BOOST_OPTIONAL_DETAIL_NO_IS_CONSTRUCTIBLE_TRAIT
+#endif
+
+#if defined __SUNPRO_CC
+# define BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS
+#elif (defined _MSC_FULL_VER) && (_MSC_FULL_VER < 190023026)
+# define BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS
+#elif defined BOOST_GCC && !defined BOOST_GCC_CXX11
+# define BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS
+#elif defined BOOST_GCC_VERSION && BOOST_GCC_VERSION < 40800
+# define BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS
+#endif
+
+
+// Detect support for defaulting move operations
+// (some older compilers implement rvalue references,
+// defaulted functions but move operations are not special members and cannot be defaulted)
+
+#ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+# define BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS
+#elif BOOST_WORKAROUND(BOOST_MSVC, < 1900)
+# define BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS
+#elif BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40600)
+# define BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS
+#endif
+
+
+#ifdef BOOST_OPTIONAL_CONFIG_NO_DIRECT_STORAGE_SPEC
+# define BOOST_OPTIONAL_DETAIL_NO_DIRECT_STORAGE_SPEC
+#endif
+
+
+#ifdef BOOST_NO_CXX11_REF_QUALIFIERS
+# define BOOST_OPTIONAL_CONST_REF_QUAL const
+# define BOOST_OPTIONAL_REF_QUAL
+#else
+# define BOOST_OPTIONAL_CONST_REF_QUAL const&
+# define BOOST_OPTIONAL_REF_QUAL &
+#endif
+
+
+#endif // header guard
@@ -0,0 +1,30 @@
+// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2016 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  fernando_cacciola@hotmail.com
+//  akrzemi1@gmail.com
+
+#ifndef BOOST_OPTIONAL_OPTIONAL_DETAIL_OPTIONAL_FACTORY_SUPPORT_AJK_12FEB2016_HPP
+#define BOOST_OPTIONAL_OPTIONAL_DETAIL_OPTIONAL_FACTORY_SUPPORT_AJK_12FEB2016_HPP
+
+// Daniel Wallin discovered that bind/apply.hpp badly interacts with the apply<>
+// member template of a factory as used in the optional<> implementation.
+// He proposed this simple fix which is to move the call to apply<> outside
+// namespace boost.
+namespace boost_optional_detail
+{
+  template <class T, class Factory>
+  inline void construct(Factory const& factory, void* address)
+  {
+    factory.BOOST_NESTED_TEMPLATE apply<T>(address);
+  }
+}
+
+#endif // header guard
@@ -0,0 +1,49 @@
+// Copyright (C) 2022 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_HASH_AJK_20MAY2022_HPP
+#define BOOST_OPTIONAL_DETAIL_OPTIONAL_HASH_AJK_20MAY2022_HPP
+
+//#include <boost/optional/optional_fwd.hpp>
+#include <boost/config.hpp>
+
+#if !defined(BOOST_OPTIONAL_CONFIG_DO_NOT_SPECIALIZE_STD_HASH) && !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
+#include <functional>
+
+namespace std
+{
+  template <typename T>
+  struct hash<boost::optional<T> >
+  {
+    typedef std::size_t result_type;
+    typedef boost::optional<T> argument_type;
+
+    BOOST_CONSTEXPR result_type operator()(const argument_type& arg) const {
+      return arg ? std::hash<T>()(*arg) : result_type();
+    }
+  };
+
+  template <typename T>
+  struct hash<boost::optional<T&> >
+  {
+    typedef std::size_t result_type;
+    typedef boost::optional<T&> argument_type;
+
+    BOOST_CONSTEXPR result_type operator()(const argument_type& arg) const {
+      return arg ? std::hash<T>()(*arg) : result_type();
+    }
+  };
+}
+
+#endif // !defined(BOOST_OPTIONAL_CONFIG_DO_NOT_SPECIALIZE_STD_HASH) && !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
+#endif // header guard
@@ -0,0 +1,117 @@
+// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2014 - 2026 Andrzej Krzemieński.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the authors at:
+//  fernando_cacciola@hotmail.com
+//  akrzemi1@gmail.com
+//
+// You can file a GitHub issue  at:
+//  https://github.com/boostorg/optional/issues
+
+
+// This header provides definitions rof nonmember functions that still constitute
+// the interface for class optional<>.
+
+#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_NONMEMBER_INTERFACE_01FEB2026_HPP
+#define BOOST_OPTIONAL_DETAIL_OPTIONAL_NONMEMBER_INTERFACE_01FEB2026_HPP
+
+namespace boost {
+
+
+template <class T>
+inline BOOST_CXX14_CONSTEXPR
+optional<BOOST_OPTIONAL_DECAY(T)> make_optional ( T && v  )
+{
+  return optional<BOOST_OPTIONAL_DECAY(T)>(optional_detail::forward_<T>(v));
+}
+
+// Returns optional<T>(cond,v)
+template <class T>
+inline BOOST_CXX14_CONSTEXPR
+optional<BOOST_OPTIONAL_DECAY(T)> make_optional ( bool cond, T && v )
+{
+  return optional<BOOST_OPTIONAL_DECAY(T)>(cond,optional_detail::forward_<T>(v));
+}
+
+
+// Returns a reference to the value if this is initialized, otherwise, the behaviour is UNDEFINED.
+// No-throw
+template <class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::reference_const_type
+get ( optional<T> const& opt )
+{
+  return opt.get() ;
+}
+
+template <class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::reference_type
+get ( optional<T>& opt )
+{
+  return opt.get() ;
+}
+
+// Returns a pointer to the value if this is initialized, otherwise, returns NULL.
+// No-throw
+template<class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::pointer_const_type
+get ( optional<T> const* opt )
+{
+  return opt->get_ptr() ;
+}
+
+template<class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::pointer_type
+get ( optional<T>* opt )
+{
+  return opt->get_ptr() ;
+}
+
+// Returns a reference to the value if this is initialized, otherwise, the behaviour is UNDEFINED.
+// No-throw
+template<class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::reference_const_type
+get_optional_value_or ( optional<T> const& opt, BOOST_DEDUCED_TYPENAME optional<T>::reference_const_type v )
+{
+  return opt.get_value_or(v) ;
+}
+
+template<class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::reference_type
+get_optional_value_or ( optional<T>& opt, BOOST_DEDUCED_TYPENAME optional<T>::reference_type v )
+{
+  return opt.get_value_or(v) ;
+}
+
+// Returns a pointer to the value if this is initialized, otherwise, returns NULL.
+// No-throw
+template<class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::pointer_const_type
+get_pointer ( optional<T> const& opt )
+{
+  return opt.get_ptr() ;
+}
+
+template<class T>
+inline BOOST_CXX14_CONSTEXPR
+BOOST_DEDUCED_TYPENAME optional<T>::pointer_type
+get_pointer ( optional<T>& opt )
+{
+  return opt.get_ptr() ;
+}
+
+} // namespace boost
+
+#endif // BOOST_OPTIONAL_DETAIL_OPTIONAL_NONMEMBER_INTERFACE_01FEB2026_HPP
@@ -0,0 +1,305 @@
+// Copyright (C) 2015-2024 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_REFERENCE_SPEC_AJK_03OCT2015_HPP
+#define BOOST_OPTIONAL_DETAIL_OPTIONAL_REFERENCE_SPEC_AJK_03OCT2015_HPP
+
+#ifdef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT
+#ifndef BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_const.hpp>
+#endif
+#endif
+
+#ifdef BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
+# define BOOST_OPTIONAL_TT_PREFIX ::std
+#else
+# define BOOST_OPTIONAL_TT_PREFIX boost
+# define BOOST_OPTIONAL_REQUIRES(...) BOOST_DEDUCED_TYPENAME boost::enable_if_c<__VA_ARGS__::value, bool>::type = false
+#endif
+
+# define BOOST_OPTIONAL_TT_TYPE(...) BOOST_DEDUCED_TYPENAME BOOST_OPTIONAL_TT_PREFIX::__VA_ARGS__::type
+# define BOOST_OPTIONAL_TT_PRED(...) BOOST_OPTIONAL_TT_PREFIX::__VA_ARGS__::value
+
+# if 1
+
+namespace boost {
+
+namespace detail {
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+
+template <class From>
+void prevent_binding_rvalue()
+{
+#ifndef BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES
+    static_assert(BOOST_OPTIONAL_TT_PRED(is_lvalue_reference<From>),
+                  "binding rvalue references to optional lvalue references is disallowed");
+#endif
+}
+
+template <class T>
+BOOST_OPTIONAL_TT_TYPE(remove_reference<T>)& forward_reference(T&& r)
+{
+    static_assert(BOOST_OPTIONAL_TT_PRED(is_lvalue_reference<T>),
+                  "binding rvalue references to optional lvalue references is disallowed");
+    return optional_detail::forward_<T>(r);
+}
+
+#endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+
+
+template <class T>
+struct is_const_integral
+{
+  static const bool value = BOOST_OPTIONAL_TT_PRED(is_const<T>) && BOOST_OPTIONAL_TT_PRED(is_integral<T>);
+};
+
+template <class T>
+struct is_const_integral_bad_for_conversion
+{
+#if (!defined BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES) && (defined BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT)
+  static const bool value = is_const_integral<T>::value;
+#else
+  static const bool value = false;
+#endif
+};
+
+template <class From>
+void prevent_assignment_from_false_const_integral()
+{
+#ifndef BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES
+#ifdef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT
+    // MSVC compiler without rvalue references: we need to disable the assignment from
+    // const integral lvalue reference, as it may be an invalid temporary
+    static_assert(!is_const_integral<From>::value,
+                  "binding const lvalue references to integral types is disabled in this compiler");
+#endif
+#endif
+}
+
+
+template <class T>
+struct is_optional_
+{
+  static const bool value = false;
+};
+
+template <class U>
+struct is_optional_< ::boost::optional<U> >
+{
+  static const bool value = true;
+};
+
+template <class T>
+struct is_no_optional
+{
+  static const bool value = !is_optional_<BOOST_OPTIONAL_DECAY(T)>::value;
+};
+
+
+template <class T, class U>
+  struct is_same_decayed
+  {
+    static const bool value = BOOST_OPTIONAL_TT_PRED(is_same<T, BOOST_OPTIONAL_TT_TYPE(remove_reference<U>)>)
+                           || BOOST_OPTIONAL_TT_PRED(is_same<T, const BOOST_OPTIONAL_TT_TYPE(remove_reference<U>)>);
+  };
+
+template <class T, class U>
+struct no_unboxing_cond
+{
+  static const bool value = is_no_optional<U>::value && !is_same_decayed<T, U>::value;
+};
+
+
+} // namespace detail
+
+template <class T>
+class optional<T&> : public optional_detail::optional_tag
+{
+    T* ptr_;
+
+public:
+    typedef T& value_type;
+    typedef T& reference_type;
+    typedef T& reference_const_type;
+    typedef T& rval_reference_type;
+    typedef T* pointer_type;
+    typedef T* pointer_const_type;
+
+    BOOST_CONSTEXPR optional() BOOST_NOEXCEPT : ptr_() {}
+    BOOST_CONSTEXPR optional(none_t) BOOST_NOEXCEPT : ptr_() {}
+
+    template <class U>
+    BOOST_CONSTEXPR explicit optional(const optional<U&>& rhs) BOOST_NOEXCEPT : ptr_(rhs.get_ptr()) {}
+    BOOST_CONSTEXPR optional(const optional& rhs) BOOST_NOEXCEPT : ptr_(rhs.get_ptr()) {}
+
+    // the following two implement a 'conditionally explicit' constructor: condition is a hack for buggy compilers with screwed conversion construction from const int
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_same_decayed<T, U>),
+              BOOST_OPTIONAL_REQUIRES(detail::is_const_integral_bad_for_conversion<U>)>
+    BOOST_CONSTEXPR explicit
+    optional(U& rhs) BOOST_NOEXCEPT
+    : ptr_(boost::addressof(rhs)) {}
+
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_same_decayed<T, U>),
+              BOOST_OPTIONAL_REQUIRES(!detail::is_const_integral_bad_for_conversion<U>)>
+    BOOST_CONSTEXPR
+    optional(U& rhs) BOOST_NOEXCEPT
+    : ptr_(boost::addressof(rhs)) {}
+
+    BOOST_CXX14_CONSTEXPR optional& operator=(const optional& rhs) BOOST_NOEXCEPT { ptr_ = rhs.get_ptr(); return *this; }
+    template <class U>
+        BOOST_CXX14_CONSTEXPR optional& operator=(const optional<U&>& rhs) BOOST_NOEXCEPT { ptr_ = rhs.get_ptr(); return *this; }
+    BOOST_CXX14_CONSTEXPR optional& operator=(none_t) BOOST_NOEXCEPT { ptr_ = 0; return *this; }
+
+
+    BOOST_CXX14_CONSTEXPR void swap(optional& rhs) BOOST_NOEXCEPT { ::std::swap(ptr_, rhs.ptr_); }
+    constexpr T& get() const { return BOOST_OPTIONAL_ASSERTED_EXPRESSION(ptr_, *ptr_); }
+
+    constexpr T* get_ptr() const BOOST_NOEXCEPT { return ptr_; }
+    constexpr T* operator->() const { return BOOST_OPTIONAL_ASSERTED_EXPRESSION(ptr_, ptr_); }
+    constexpr T& operator*() const { return BOOST_OPTIONAL_ASSERTED_EXPRESSION(ptr_, *ptr_); }
+
+    constexpr T& value() const
+    {
+      return this->is_initialized() ?
+             this->get() :
+             (boost::throw_exception(boost::bad_optional_access()), this->get());
+    }
+
+    constexpr explicit operator bool() const BOOST_NOEXCEPT { return ptr_ != 0; }
+
+    BOOST_CXX14_CONSTEXPR void reset() BOOST_NOEXCEPT { ptr_ = 0; }
+
+    constexpr bool is_initialized() const BOOST_NOEXCEPT { return ptr_ != 0; }
+    constexpr bool has_value() const BOOST_NOEXCEPT { return ptr_ != 0; }
+
+    template <typename F>
+    constexpr optional<typename optional_detail::result_of<F, reference_const_type>::type>
+    map(F f) const
+    {
+      return this->has_value() ?
+             f(get()) :
+             optional<typename optional_detail::result_of<F, reference_const_type>::type>();
+    }
+
+    template <typename F>
+    constexpr optional<typename optional_detail::result_value_type<F, reference_const_type>::type>
+    flat_map(F f) const
+      {
+        return this->has_value() ?
+               f(get()) :
+               optional<typename optional_detail::result_value_type<F, reference_const_type>::type>();
+      }
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+
+    optional(T&& /* rhs */) BOOST_NOEXCEPT { detail::prevent_binding_rvalue<T&&>(); }
+
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::no_unboxing_cond<T, R>)>
+        BOOST_CXX14_CONSTEXPR optional(R&& r) BOOST_NOEXCEPT
+        : ptr_(boost::addressof(r)) { detail::prevent_binding_rvalue<R>(); }
+
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<R>)>
+        BOOST_CXX14_CONSTEXPR optional(bool cond, R&& r) BOOST_NOEXCEPT
+        : ptr_(cond ? boost::addressof(r) : 0) { detail::prevent_binding_rvalue<R>(); }
+
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<R>)>
+        BOOST_CXX14_CONSTEXPR optional<T&>&
+        operator=(R&& r) BOOST_NOEXCEPT { detail::prevent_binding_rvalue<R>(); ptr_ = boost::addressof(r); return *this; }
+
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<R>)>
+        BOOST_CXX14_CONSTEXPR void emplace(R&& r) BOOST_NOEXCEPT
+        { detail::prevent_binding_rvalue<R>(); ptr_ = boost::addressof(r); }
+
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<R>)>
+      BOOST_CXX14_CONSTEXPR T& get_value_or(R&& r) const BOOST_NOEXCEPT
+      { detail::prevent_binding_rvalue<R>(); return ptr_ ? *ptr_ : r; }
+
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<R>)>
+        BOOST_CXX14_CONSTEXPR T& value_or(R&& r) const BOOST_NOEXCEPT
+        { detail::prevent_binding_rvalue<R>(); return ptr_ ? *ptr_ : r; }
+
+    template <class R, BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<R>)>
+      BOOST_CXX14_CONSTEXPR void reset(R&& r) BOOST_NOEXCEPT
+      { detail::prevent_binding_rvalue<R>(); ptr_ = boost::addressof(r); }
+
+    template <class F>
+        BOOST_CXX14_CONSTEXPR T& value_or_eval(F f) const { return ptr_ ? *ptr_ : detail::forward_reference(f()); }
+
+#else  // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+
+
+    // the following two implement a 'conditionally explicit' constructor
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::no_unboxing_cond<T, U>),
+              BOOST_OPTIONAL_REQUIRES(detail::is_const_integral_bad_for_conversion<U>)>
+      BOOST_CXX14_CONSTEXPR explicit optional(U& v) BOOST_NOEXCEPT
+      : ptr_(boost::addressof(v)) { }
+
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::no_unboxing_cond<T, U>),
+              BOOST_OPTIONAL_REQUIRES(!detail::is_const_integral_bad_for_conversion<U>)>
+      BOOST_CXX14_CONSTEXPR optional(U& v) BOOST_NOEXCEPT
+      : ptr_(boost::addressof(v)) { }
+
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<U>)>
+      BOOST_CXX14_CONSTEXPR optional(bool cond, U& v) BOOST_NOEXCEPT : ptr_(cond ? boost::addressof(v) : 0) {}
+
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<U>)>
+      BOOST_CXX14_CONSTEXPR
+      optional<T&>& operator=(U& v) BOOST_NOEXCEPT
+      {
+        detail::prevent_assignment_from_false_const_integral<U>();
+        ptr_ = boost::addressof(v); return *this;
+      }
+
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<U>)>
+        BOOST_CXX14_CONSTEXPR void emplace(U& v) BOOST_NOEXCEPT
+        { ptr_ = boost::addressof(v); }
+
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<U>)>
+      BOOST_CXX14_CONSTEXPR T& get_value_or(U& v) const BOOST_NOEXCEPT
+      { return ptr_ ? *ptr_ : v; }
+
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<U>)>
+      BOOST_CXX14_CONSTEXPR T& value_or(U& v) const BOOST_NOEXCEPT
+      { return ptr_ ? *ptr_ : v; }
+
+    template <class U,
+              BOOST_OPTIONAL_REQUIRES(detail::is_no_optional<U>)>
+      BOOST_CXX14_CONSTEXPR void reset(U& v) BOOST_NOEXCEPT
+      { ptr_ = boost::addressof(v); }
+
+    template <class F>
+      BOOST_CXX14_CONSTEXPR T& value_or_eval(F f) const { return ptr_ ? *ptr_ : f(); }
+
+#endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+};
+
+template <class T>
+  BOOST_CXX14_CONSTEXPR void swap ( optional<T&>& x, optional<T&>& y) BOOST_NOEXCEPT
+{
+  x.swap(y);
+}
+
+} // namespace boost
+
+#endif // 1/0
+
+#endif // header guard
@@ -0,0 +1,196 @@
+// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2015, 2024, 2026 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_RELOPS_AJK_03OCT2015_HPP
+#define BOOST_OPTIONAL_DETAIL_OPTIONAL_RELOPS_AJK_03OCT2015_HPP
+
+namespace boost {
+
+// optional's relational operators ( ==, !=, <, >, <=, >= ) have deep-semantics (compare values).
+// WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointees() in generic code instead,
+// to obtain the same semantic for pointers.
+
+
+//
+// optional<T> vs optional<T> cases
+//
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator == ( optional<T> const& x, optional<T> const& y )
+{ return bool(x) && bool(y) ? *x == *y : bool(x) == bool(y); }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator < ( optional<T> const& x, optional<T> const& y )
+{ return !y ? false : (!x ? true : (*x) < (*y)); }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator != ( optional<T> const& x, optional<T> const& y )
+{ return !( x == y ) ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator > ( optional<T> const& x, optional<T> const& y )
+{ return y < x ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator <= ( optional<T> const& x, optional<T> const& y )
+{ return !( y < x ) ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator >= ( optional<T> const& x, optional<T> const& y )
+{ return !( x < y ) ; }
+
+
+//
+// optional<T> vs T cases
+//
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator == ( optional<T> const& x, T const& y )
+{ return x && (*x == y); }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator < ( optional<T> const& x, T const& y )
+{ return (!x) || (*x < y); }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator != ( optional<T> const& x, T const& y )
+{ return !( x == y ) ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator > ( optional<T> const& x, T const& y )
+{ return y < x ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator <= ( optional<T> const& x, T const& y )
+{ return !( y < x ) ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator >= ( optional<T> const& x, T const& y )
+{ return !( x < y ) ; }
+
+//
+// T vs optional<T> cases
+//
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator == ( T const& x, optional<T> const& y )
+{ return y && (x == *y); }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator < ( T const& x, optional<T> const& y )
+{ return y && (x < *y); }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator != ( T const& x, optional<T> const& y )
+{ return !( x == y ) ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator > ( T const& x, optional<T> const& y )
+{ return y < x ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator <= ( T const& x, optional<T> const& y )
+{ return !( y < x ) ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator >= ( T const& x, optional<T> const& y )
+{ return !( x < y ) ; }
+
+
+//
+// optional<T> vs none cases
+//
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator == ( optional<T> const& x, none_t ) BOOST_NOEXCEPT
+{ return !x; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator < ( optional<T> const&, none_t ) BOOST_NOEXCEPT
+{ return false; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator != ( optional<T> const& x, none_t ) BOOST_NOEXCEPT
+{ return bool(x); }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator > ( optional<T> const& x, none_t y ) BOOST_NOEXCEPT
+{ return y < x ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator <= ( optional<T> const& x, none_t y ) BOOST_NOEXCEPT
+{ return !( y < x ) ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator >= ( optional<T> const& x, none_t y ) BOOST_NOEXCEPT
+{ return !( x < y ) ; }
+
+//
+// none vs optional<T> cases
+//
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator == ( none_t , optional<T> const& y ) BOOST_NOEXCEPT
+{ return !y; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator < ( none_t , optional<T> const& y ) BOOST_NOEXCEPT
+{ return bool(y); }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator != ( none_t, optional<T> const& y ) BOOST_NOEXCEPT
+{ return bool(y); }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator > ( none_t x, optional<T> const& y ) BOOST_NOEXCEPT
+{ return y < x ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator <= ( none_t x, optional<T> const& y ) BOOST_NOEXCEPT
+{ return !( y < x ) ; }
+
+template<class T>
+inline BOOST_CONSTEXPR
+bool operator >= ( none_t x, optional<T> const& y ) BOOST_NOEXCEPT
+{ return !( x < y ) ; }
+
+} // namespace boost
+
+#endif // header guard
@@ -0,0 +1,36 @@
+// Copyright (C) 2026 Andrzej Krzemieński.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+//
+//
+// This header provides definitions required by any specialization of
+// optional<>.
+
+#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_SELECT_IMPLEMENTATION_01FEB2026_HPP
+#define BOOST_OPTIONAL_DETAIL_OPTIONAL_SELECT_IMPLEMENTATION_01FEB2026_HPP
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX11_CONSTEXPR) &&             \
+    !defined(BOOST_NO_CXX11_REF_QUALIFIERS) &&        \
+    !defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES) && \
+    !defined(BOOST_NO_CXX11_UNRESTRICTED_UNION) &&    \
+    !defined(BOOST_NO_CXX11_NOEXCEPT) &&              \
+    !defined(BOOST_NO_CXX11_DEFAULTED_MOVES)
+# define BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
+#endif
+
+
+// In C++20 we have `std::construct_at()` which is a constexpr equivalent of
+// placement-new. We can then make more functions constexpr.
+// TBD: This additional constexpr-ication is left for the future.
+# define BOOST_OPTIONAL_CXX20_CONSTEXPR
+
+#endif //BOOST_OPTIONAL_DETAIL_OPTIONAL_SELECT_IMPLEMENTATION_01FEB2026_HPP
@@ -0,0 +1,117 @@
+// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2015 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#ifndef BOOST_OPTIONAL_DETAIL_OPTIONAL_SWAP_AJK_28JAN2015_HPP
+#define BOOST_OPTIONAL_DETAIL_OPTIONAL_SWAP_AJK_28JAN2015_HPP
+
+#include <boost/core/invoke_swap.hpp>
+#include <boost/optional/optional_fwd.hpp>
+
+namespace boost {
+
+namespace optional_detail {
+
+template <bool use_default_constructor> struct swap_selector;
+
+template <>
+struct swap_selector<true>
+{
+    template <class T>
+    static void optional_swap ( optional<T>& x, optional<T>& y )
+    {
+        const bool hasX = !!x;
+        const bool hasY = !!y;
+
+        if ( !hasX && !hasY )
+            return;
+
+        if( !hasX )
+            x.emplace();
+        else if ( !hasY )
+            y.emplace();
+
+        // Boost.Core.Swap will take care of ADL and workarounds for broken compilers
+        boost::core::invoke_swap(x.get(), y.get());
+
+        if( !hasX )
+            y = boost::none ;
+        else if( !hasY )
+            x = boost::none ;
+    }
+};
+
+#ifdef BOOST_OPTIONAL_DETAIL_MOVE
+# undef BOOST_OPTIONAL_DETAIL_MOVE
+#endif
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+# define BOOST_OPTIONAL_DETAIL_MOVE(EXPR_) optional_detail::move_(EXPR_)
+#else
+# define BOOST_OPTIONAL_DETAIL_MOVE(EXPR_) EXPR_
+#endif
+
+template <>
+struct swap_selector<false>
+{
+    template <class T>
+    static void optional_swap ( optional<T>& x, optional<T>& y )
+    //BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && BOOST_NOEXCEPT_EXPR(boost::core::invoke_swap(*x, *y)))
+    {
+        if (x)
+        {
+            if (y)
+            {
+                boost::core::invoke_swap(*x, *y);
+            }
+            else
+            {
+                y = BOOST_OPTIONAL_DETAIL_MOVE(*x);
+                x = boost::none;
+            }
+        }
+        else
+        {
+            if (y)
+            {
+                x = BOOST_OPTIONAL_DETAIL_MOVE(*y);
+                y = boost::none;
+            }
+        }
+    }
+};
+
+} // namespace optional_detail
+
+#if (!defined BOOST_CONFIG_RESTORE_OBSOLETE_SWAP_IMPLEMENTATION)
+
+template<class T>
+struct optional_swap_should_use_default_constructor : boost::false_type {} ;
+
+#else
+
+template<class T>
+struct optional_swap_should_use_default_constructor : has_nothrow_default_constructor<T> {} ;
+
+#endif
+
+template <class T>
+inline void swap ( optional<T>& x, optional<T>& y )
+//BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && BOOST_NOEXCEPT_EXPR(boost::core::invoke_swap(*x, *y)))
+{
+    optional_detail::swap_selector<optional_swap_should_use_default_constructor<T>::value>::optional_swap(x, y);
+}
+
+} // namespace boost
+
+#undef BOOST_OPTIONAL_DETAIL_MOVE
+
+#endif // header guard
@@ -0,0 +1,270 @@
+// Copyright (C) 2017 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+// trivially-copyable version of the storage
+
+template<class T>
+class tc_optional_base : public optional_tag
+{
+  private :
+
+    typedef tc_optional_base<T> this_type ;
+
+  protected :
+
+    typedef T value_type ;
+
+  protected:
+    typedef T &       reference_type ;
+    typedef T const&  reference_const_type ;
+    typedef T &&  rval_reference_type ;
+    typedef T &&  reference_type_of_temporary_wrapper ;
+    typedef T *         pointer_type ;
+    typedef T const*    pointer_const_type ;
+    typedef T const&    argument_type ;
+
+    tc_optional_base()
+      :
+      m_initialized(false), m_storage() {}
+
+    tc_optional_base ( none_t )
+      :
+      m_initialized(false), m_storage() {}
+
+    tc_optional_base ( init_value_tag, argument_type val )
+      :
+      m_initialized(true), m_storage(val) {}
+
+    tc_optional_base ( bool cond, argument_type val )
+      :
+      m_initialized(cond), m_storage(val) {}
+
+    // tc_optional_base ( tc_optional_base const& ) = default;
+
+    template<class Expr, class PtrExpr>
+    explicit tc_optional_base ( Expr&& expr, PtrExpr const* tag )
+      :
+      m_initialized(false)
+    {
+      construct(optional_detail::forward_<Expr>(expr),tag);
+    }
+
+    // tc_optional_base& operator= ( tc_optional_base const& ) = default;
+    // ~tc_optional_base() = default;
+
+    // Assigns from another optional<T> (deep-copies the rhs value)
+    void assign ( tc_optional_base const& rhs )
+    {
+      *this = rhs;
+    }
+
+    // Assigns from another _convertible_ optional<U> (deep-copies the rhs value)
+    template<class U>
+    void assign ( optional<U> const& rhs )
+    {
+      if ( rhs.is_initialized() )
+#ifndef BOOST_OPTIONAL_CONFIG_RESTORE_ASSIGNMENT_OF_NONCONVERTIBLE_TYPES
+        m_storage = rhs.get();
+#else
+        m_storage = static_cast<value_type>(rhs.get());
+#endif
+
+      m_initialized = rhs.is_initialized();
+    }
+
+    // move-assigns from another _convertible_ optional<U> (deep-moves from the rhs value)
+    template<class U>
+    void assign ( optional<U>&& rhs )
+    {
+      typedef BOOST_DEDUCED_TYPENAME optional<U>::rval_reference_type ref_type;
+      if ( rhs.is_initialized() )
+        m_storage = static_cast<ref_type>(rhs.get());
+      m_initialized = rhs.is_initialized();
+    }
+
+    void assign ( argument_type val )
+    {
+      construct(val);
+    }
+
+    void assign ( none_t ) { destroy(); }
+
+#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+
+    template<class Expr, class ExprPtr>
+    void assign_expr ( Expr&& expr, ExprPtr const* tag )
+    {
+       construct(optional_detail::forward_<Expr>(expr),tag);
+    }
+
+#endif
+
+  public :
+
+    // Destroys the current value, if any, leaving this UNINITIALIZED
+    // No-throw (assuming T::~T() doesn't)
+    void reset() BOOST_NOEXCEPT { destroy(); }
+
+    // **DEPRECATED** Replaces the current value -if any- with 'val'
+    void reset ( argument_type val ) BOOST_NOEXCEPT { assign(val); }
+
+    // Returns a pointer to the value if this is initialized, otherwise,
+    // returns NULL.
+    // No-throw
+    pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; }
+    pointer_type       get_ptr()       { return m_initialized ? get_ptr_impl() : 0 ; }
+
+    bool is_initialized() const { return m_initialized ; }
+
+  protected :
+
+    void construct ( argument_type val )
+     {
+       m_storage = val ;
+       m_initialized = true ;
+     }
+
+
+    // Constructs in-place
+    // upon exception *this is always uninitialized
+    template<class... Args>
+    void construct ( in_place_init_t, Args&&... args )
+    {
+      m_storage = value_type( optional_detail::forward_<Args>(args)... ) ;
+      m_initialized = true ;
+    }
+
+    template<class... Args>
+    void emplace_assign ( Args&&... args )
+    {
+      construct(in_place_init, optional_detail::forward_<Args>(args)...);
+    }
+
+    template<class... Args>
+    explicit tc_optional_base ( in_place_init_t, Args&&... args )
+      :
+      m_initialized(false)
+    {
+      construct(in_place_init, optional_detail::forward_<Args>(args)...);
+    }
+
+    template<class... Args>
+    explicit tc_optional_base ( in_place_init_if_t, bool cond, Args&&... args )
+      :
+      m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init, optional_detail::forward_<Args>(args)...);
+    }
+
+#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+
+    // Constructs in-place using the given factory
+    template<class Expr>
+    void construct ( Expr&& factory, in_place_factory_base const* )
+     {
+       boost_optional_detail::construct<value_type>(factory, boost::addressof(m_storage));
+       m_initialized = true ;
+     }
+
+    // Constructs in-place using the given typed factory
+    template<class Expr>
+    void construct ( Expr&& factory, typed_in_place_factory_base const* )
+     {
+       factory.apply(boost::addressof(m_storage)) ;
+       m_initialized = true ;
+     }
+
+    template<class Expr>
+    void assign_expr_to_initialized ( Expr&& factory, in_place_factory_base const* tag )
+     {
+       destroy();
+       construct(factory,tag);
+     }
+
+    // Constructs in-place using the given typed factory
+    template<class Expr>
+    void assign_expr_to_initialized ( Expr&& factory, typed_in_place_factory_base const* tag )
+     {
+       destroy();
+       construct(factory,tag);
+     }
+
+#endif
+
+    // Constructs using any expression implicitly convertible to the single argument
+    // of a one-argument T constructor.
+    // Converting constructions of optional<T> from optional<U> uses this function with
+    // 'Expr' being of type 'U' and relying on a converting constructor of T from U.
+    template<class Expr>
+    void construct ( Expr&& expr, void const* )
+    {
+      m_storage = value_type(optional_detail::forward_<Expr>(expr)) ;
+      m_initialized = true ;
+    }
+
+    // Assigns using a form any expression implicitly convertible to the single argument
+    // of a T's assignment operator.
+    // Converting assignments of optional<T> from optional<U> uses this function with
+    // 'Expr' being of type 'U' and relying on a converting assignment of T from U.
+    template<class Expr>
+    void assign_expr_to_initialized ( Expr&& expr, void const* )
+    {
+      assign_value( optional_detail::forward_<Expr>(expr) );
+    }
+
+#ifdef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
+    // BCB5.64 (and probably lower versions) workaround.
+    //   The in-place factories are supported by means of catch-all constructors
+    //   and assignment operators (the functions are parameterized in terms of
+    //   an arbitrary 'Expr' type)
+    //   This compiler incorrectly resolves the overload set and sinks optional<T> and optional<U>
+    //   to the 'Expr'-taking functions even though explicit overloads are present for them.
+    //   Thus, the following overload is needed to properly handle the case when the 'lhs'
+    //   is another optional.
+    //
+    // For VC<=70 compilers this workaround doesn't work because the compiler issues and error
+    // instead of choosing the wrong overload
+    //
+
+    // Notice that 'Expr' will be optional<T> or optional<U> (but not tc_optional_base<..>)
+    template<class Expr>
+    void construct ( Expr&& expr, optional_tag const* )
+     {
+       if ( expr.is_initialized() )
+       {
+         // An exception can be thrown here.
+         // It it happens, THIS will be left uninitialized.
+         m_storage = value_type(optional_detail::move(expr.get())) ;
+         m_initialized = true ;
+       }
+     }
+#endif // defined BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
+
+    void assign_value ( argument_type val ) { m_storage = val; }
+    void assign_value ( rval_reference_type val ) { m_storage = static_cast<rval_reference_type>(val); }
+
+    void destroy()
+    {
+      m_initialized = false;
+    }
+
+    reference_const_type get_impl() const { return m_storage ; }
+    reference_type       get_impl()       { return m_storage ; }
+
+    pointer_const_type get_ptr_impl() const { return boost::addressof(m_storage); }
+    pointer_type       get_ptr_impl()       { return boost::addressof(m_storage); }
+
+  private :
+
+    bool m_initialized ;
+    T    m_storage ;
+} ;
@@ -0,0 +1,722 @@
+// Copyright (C) 2026 Andrzej Krzemieński.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+//
+//
+// This header provides definitions required by any specialization of
+// optional<>.
+
+#ifndef BOOST_OPTIONAL_DETAIL_UNION_OPTIONAL_01FEB2026_HPP
+#define BOOST_OPTIONAL_DETAIL_UNION_OPTIONAL_01FEB2026_HPP
+
+//#include <initializer_list>
+#include <boost/assert.hpp>
+#include <boost/core/invoke_swap.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/optional/bad_optional_access.hpp>
+
+
+
+// This macro shall be put in the position of a template parameter.
+// It emulates the requires clause.
+# define BOOST_OPTIONAL_REQUIRES(...) typename ::std::enable_if<__VA_ARGS__::value, bool>::type = false
+
+
+# ifdef __cpp_guaranteed_copy_elision
+#   if __cpp_guaranteed_copy_elision
+#     define BOOST_OPTIONAL_CONSTEXPR_COPY
+#   endif
+# endif
+
+
+template <typename T, typename U>
+struct fail_hard_on_nonconvertible
+{
+  static_assert(::std::is_convertible<U&&, T>::value, "The argument must be convertible to T");
+  using type = bool;
+};
+
+// Missing C++17 type traits
+namespace boost { namespace optional_detail {
+
+template <class...>
+struct conjunction : ::std::true_type {};
+
+template <class B1>
+struct conjunction<B1> : B1 {};
+
+template <class B1, class... Bn>
+struct conjunction<B1, Bn...>
+    : ::std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
+
+}}
+
+namespace boost { namespace optional_detail {
+
+// Tag to indicate a special-purpose constructor
+BOOST_INLINE_VARIABLE constexpr struct trivial_init_t{} trivial_init{};
+
+
+template <class T>
+union constexpr_union_storage_t
+{
+    static_assert(::std::is_trivially_destructible<T>::value, "!!");
+
+    unsigned char dummy_;
+    T value_;
+
+    constexpr constexpr_union_storage_t( trivial_init_t ) noexcept : dummy_() {};
+
+#if defined(BOOST_GCC) && (__GNUC__ >= 7)
+// false positive, see https://github.com/boostorg/variant2/issues/55,
+//   https://github.com/boostorg/url/issues/979
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
+    template <class... Args>
+    constexpr constexpr_union_storage_t( Args&&... args ) : value_(forward_<Args>(args)...) {}
+
+#if defined(BOOST_GCC) && (__GNUC__ >= 7)
+# pragma GCC diagnostic pop
+#endif
+
+    //~constexpr_union_storage_t() = default; // No need to destroy a trivially-destructible type
+};
+
+template <class T>
+union fallback_union_storage_t
+{
+  unsigned char dummy_;
+  T value_;
+
+  constexpr fallback_union_storage_t( trivial_init_t ) noexcept : dummy_() {};
+
+#if defined(BOOST_GCC) && (__GNUC__ >= 7)
+// false positive, see https://github.com/boostorg/variant2/issues/55,
+//   https://github.com/boostorg/url/issues/979
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
+  template <class... Args>
+  constexpr fallback_union_storage_t( Args&&... args ) : value_(forward_<Args>(args)...) {}
+
+#if defined(BOOST_GCC) && (__GNUC__ >= 7)
+# pragma GCC diagnostic pop
+#endif
+
+  ~fallback_union_storage_t(){} // My owner will destroy the `T` if needed.
+                                // Cannot default in a union with nontrivial `T`.
+};
+
+
+// `guarded_storage` is a union + a flag indicating if a `T` has been initialized.
+// this way the destructor knows if it should destroy the `T`.
+template <class T>
+struct constexpr_guarded_storage
+{
+    static_assert(::std::is_trivially_destructible<T>::value, "!!");
+
+    bool init_;
+    constexpr_union_storage_t<T> storage_;
+
+    constexpr constexpr_guarded_storage() noexcept : init_(false), storage_(trivial_init) {};
+
+    explicit constexpr constexpr_guarded_storage(const T& v) : init_(true), storage_(v) {}
+
+    explicit constexpr constexpr_guarded_storage(T&& v) : init_(true), storage_(move_(v)) {}
+
+    template <class... Args> explicit constexpr constexpr_guarded_storage(optional_ns::in_place_init_t, Args&&... args)
+      : init_(true), storage_(forward_<Args>(args)...) {}
+
+    // template <class U, class... Args, BOOST_OPTIONAL_REQUIRES(::std::is_constructible<T, ::std::initializer_list<U>>)>
+    // constexpr explicit constexpr_guarded_storage(optional_ns::in_place_init_t, ::std::initializer_list<U> il, Args&&... args)
+    //   : init_(true), storage_(il, forward_<Args>(args)...) {}
+
+    BOOST_CXX14_CONSTEXPR void reset () noexcept { init_ = false; }
+
+    //~constexpr_guarded_storage() = default;
+
+#if (defined(_MSC_VER) && 1910 <= _MSC_VER && _MSC_VER <= 1916)
+  // Workaround for MSVC 14.1x bug where it eagerly tries to define the copy/move operations
+  // these are declared but never defined
+    constexpr_guarded_storage(const constexpr_guarded_storage&);
+    constexpr_guarded_storage(constexpr_guarded_storage&&);
+    constexpr_guarded_storage& operator=(const constexpr_guarded_storage&);
+    constexpr_guarded_storage& operator=(constexpr_guarded_storage&&);
+#endif
+};
+
+
+template <class T>
+struct fallback_guarded_storage
+{
+    bool init_;
+    fallback_union_storage_t<T> storage_;
+
+    constexpr fallback_guarded_storage() noexcept : init_(false), storage_(trivial_init) {};
+
+    explicit constexpr fallback_guarded_storage(const T& v) : init_(true), storage_(v) {}
+
+    explicit constexpr fallback_guarded_storage(T&& v) : init_(true), storage_(move_(v)) {}
+
+    template <class... Args> explicit constexpr fallback_guarded_storage(optional_ns::in_place_init_t, Args&&... args)
+        : init_(true), storage_(forward_<Args>(args)...) {}
+
+    // template <class U, class... Args, BOOST_OPTIONAL_REQUIRES(::std::is_constructible<T, ::std::initializer_list<U>>)>
+    // explicit fallback_guarded_storage(optional_ns::in_place_init_t, ::std::initializer_list<U> il, Args&&... args)
+    //     : init_(true), storage_(il, forward_<Args>(args)...) {}
+
+    void reset() noexcept
+    {
+      if (init_)
+      {
+        storage_.value_.T::~T();
+        init_ = false;
+      }
+
+    }
+
+    ~fallback_guarded_storage() { if (init_) storage_.value_.T::~T(); }
+
+#if (defined(_MSC_VER) && 1910 <= _MSC_VER && _MSC_VER <= 1916)
+// Workaround for MSVC 14.1x bug where it eagerly tries to define the copy/move operations
+// These are declared but never defined
+  fallback_guarded_storage(const fallback_guarded_storage&);
+  fallback_guarded_storage(fallback_guarded_storage&&);
+  fallback_guarded_storage& operator=(const fallback_guarded_storage&);
+  fallback_guarded_storage& operator=(fallback_guarded_storage&&);
+#endif
+};
+
+
+template <class T>
+using guarded_storage = typename ::std::conditional<
+    ::std::is_trivially_destructible<T>::value,                       // if possible
+    constexpr_guarded_storage<typename ::std::remove_const<T>::type>, // use storage with trivial destructor
+    fallback_guarded_storage<typename ::std::remove_const<T>::type>
+>::type;
+
+
+}}
+
+
+namespace boost {
+
+  template <class T>
+  class optional : public optional_detail::optional_tag
+  {
+    using storage_t = optional_detail::guarded_storage<T>;
+    storage_t storage;
+    static_assert( !::std::is_same<typename std::decay<T>::type, none_t>::value, "optional<none_t> is illegal" );
+    static_assert( !::std::is_same<typename std::decay<T>::type, in_place_init_t>::value, "optional<in_place_init_t> is illegal" );
+    static_assert( !::std::is_same<typename std::decay<T>::type, in_place_init_if_t>::value, "optional<in_place_init_if_t> is illegal" );
+
+    BOOST_CXX14_CONSTEXPR typename ::std::remove_const<T>::type* dataptr() { return ::boost::addressof(storage.storage_.value_); }
+    constexpr const T* dataptr() const { return ::boost::addressof(storage.storage_.value_); }
+
+    constexpr const T& contained_val() const& { return storage.storage_.value_; }
+    BOOST_CXX14_CONSTEXPR T&& contained_val() && { return optional_detail::move_(storage.storage_.value_); }
+    BOOST_CXX14_CONSTEXPR T& contained_val() & { return storage.storage_.value_; }
+
+    template <typename... Args>
+    BOOST_OPTIONAL_CXX20_CONSTEXPR void initialize(Args&&... args)
+    {
+      BOOST_ASSERT(!storage.init_);
+      ::new (static_cast<void*>(dataptr())) T(optional_detail::forward_<Args>(args)...);
+      storage.init_ = true;
+    }
+
+  #ifdef BOOST_OPTIONAL_CONSTEXPR_COPY
+    // The conditional initialization of storage needs to employ a factory
+    // function, so that we can utilize the guaranteed copy elision on the
+    // return type.
+    // an alternative -- using a conditional operator in the initializer --
+    // does not work in MSVC 14.2 and 14.3.
+    template <typename... U>
+    static constexpr storage_t conditional_storage_from_values(bool cond, U&&... v)
+    {
+      if (cond)
+        return storage_t(in_place_init, optional_detail::forward_<U>(v)...);
+      else
+        return storage_t();
+    }
+
+    template <typename OU>
+    static constexpr storage_t conditional_storage_from_optional(OU&& ou)
+    {
+      if (ou.has_value())
+        return storage_t(in_place_init, *optional_detail::forward_<OU>(ou));
+      else
+        return storage_t();
+    }
+  #endif
+
+  public:
+    using value_type = T;
+    using unqualified_value_type = typename ::std::remove_const<T>::type;
+
+    using reference_type = T&;
+    using reference_const_type = T const&;
+    using argument_type = T const&;
+    using rval_reference_type = T&&;
+    using reference_type_of_temporary_wrapper = T&&;
+    using pointer_type = T*;
+    using pointer_const_type = T const*;
+
+
+    constexpr bool is_initialized() const noexcept { return storage.init_; }
+
+    constexpr optional() noexcept : storage()  {};
+    constexpr optional(none_t) noexcept : storage() {};
+
+    constexpr optional(const T& v) : storage(v) {}
+    constexpr optional(T&& v) : storage(optional_detail::move_(v)) {}
+
+#ifdef BOOST_OPTIONAL_CONSTEXPR_COPY
+    constexpr optional(bool cond, const T& v)
+    : storage(conditional_storage_from_values(cond, v))
+    {}
+
+    constexpr optional(bool cond, T&& v)
+    : storage(conditional_storage_from_values(cond, optional_detail::move_(v)))
+    {}
+
+    constexpr optional(const optional& rhs)
+    : storage(conditional_storage_from_optional(rhs))
+    {}
+
+    constexpr optional(optional&& rhs)
+      noexcept(::std::is_nothrow_move_constructible<T>::value)
+    : storage(conditional_storage_from_optional(optional_detail::move_(rhs)))
+    {}
+
+    template <typename U, BOOST_OPTIONAL_REQUIRES(::std::is_constructible<T, U const&>)>
+    constexpr explicit optional(optional<U> const& rhs)
+    : storage(conditional_storage_from_optional(rhs))
+    {}
+
+    template <typename U, BOOST_OPTIONAL_REQUIRES(::std::is_constructible<T, U&&>)>
+    constexpr explicit optional(optional<U> && rhs)
+    : storage(conditional_storage_from_optional(optional_detail::move_(rhs)))
+    {}
+
+    template <typename... Args>
+    constexpr explicit optional( in_place_init_if_t, bool cond, Args&&... args )
+    : storage(conditional_storage_from_values(cond, optional_detail::forward_<Args>(args)...))
+    {}
+#else
+    optional(bool cond, const T& v)
+    : storage()
+    {
+      if (cond)
+        initialize(v);
+    }
+
+    optional(bool cond, T&& v)
+    : storage()
+    {
+      if (cond)
+        initialize(optional_detail::move_(v));
+    }
+
+    optional(const optional& rhs)
+    : storage()
+    {
+      if (rhs.is_initialized())
+        initialize(*rhs);
+    }
+
+    optional(optional&& rhs)
+      noexcept(::std::is_nothrow_move_constructible<T>::value)
+    : storage()
+    {
+      if (rhs.is_initialized())
+        initialize(*optional_detail::move_(rhs));
+    }
+
+    template <typename U, BOOST_OPTIONAL_REQUIRES(::std::is_constructible<T, U const&>)>
+    explicit optional(optional<U> const& rhs)
+    : storage()
+    {
+      if (rhs.is_initialized())
+        initialize(*rhs);
+    }
+
+    template <typename U, BOOST_OPTIONAL_REQUIRES(::std::is_constructible<T, U&&>)>
+    explicit optional(optional<U> && rhs)
+    : storage()
+    {
+      if (rhs.is_initialized())
+        initialize(*optional_detail::move_(rhs));
+    }
+
+    template <typename... Args>
+    explicit optional( in_place_init_if_t, bool cond, Args&&... args )
+    : storage()
+    {
+      if (cond)
+        initialize(optional_detail::forward_<Args>(args)...);
+    }
+#endif // BOOST_OPTIONAL_CONSTEXPR_COPY
+
+    template <typename FT,
+              BOOST_OPTIONAL_REQUIRES(optional_detail::is_typed_in_place_factory<FT>)>
+    /*non-constexpr (deprecated)*/
+    explicit optional (FT&& factory)
+    : storage()
+    {
+      factory.apply(this->dataptr());
+      storage.init_ = true ;
+    }
+
+    template <typename FT,
+              BOOST_OPTIONAL_REQUIRES(optional_detail::is_in_place_factory<FT>)>
+    /*non-constexpr (deprecated)*/
+    explicit optional (FT&& factory)
+    : storage()
+    {
+      boost_optional_detail::construct<value_type>(factory, this->dataptr());
+      storage.init_ = true;
+    }
+
+    template <typename U,
+              BOOST_OPTIONAL_REQUIRES(::std::is_constructible<T, U&&>),
+              BOOST_OPTIONAL_REQUIRES(!optional_detail::is_typed_in_place_factory<U>),
+              BOOST_OPTIONAL_REQUIRES(!optional_detail::is_in_place_factory<U>)>
+    constexpr explicit optional(U&& v)
+    : storage(optional_ns::in_place_init, optional_detail::forward_<U>(v))
+    {}
+
+    template <typename... Args>
+    constexpr explicit optional( in_place_init_t, Args&&... args )
+    : storage(in_place_init, optional_detail::forward_<Args>(args)...)
+    {}
+
+    BOOST_CXX14_CONSTEXPR operator optional<T&>() & noexcept
+    {
+      return this->has_value() ? optional<T&>(**this) : optional<T&>();
+    }
+
+    BOOST_CONSTEXPR operator optional<const T&>() const& noexcept
+    {
+      return this->has_value() ? optional<const T&>(**this) : optional<const T&>();
+    }
+
+    BOOST_CXX14_CONSTEXPR operator optional<T&>() && noexcept = delete;
+    BOOST_CONSTEXPR operator optional<const T&>() const&& noexcept = delete;
+
+
+    BOOST_CXX14_CONSTEXPR void reset() noexcept
+    {
+      storage.reset();
+    }
+
+    BOOST_OPTIONAL_CXX20_CONSTEXPR void reset(const T& v)
+    {
+      *this = v;
+    }
+
+    template <typename... Args>
+    BOOST_OPTIONAL_CXX20_CONSTEXPR void emplace(Args&&... args)
+    {
+      reset();
+      // <-- now we are not containing a value
+      initialize(optional_detail::forward_<Args>(args)...);
+    }
+
+
+    BOOST_CXX14_CONSTEXPR optional& operator=(none_t) noexcept
+    {
+      reset();
+      return *this;
+    }
+
+    BOOST_OPTIONAL_CXX20_CONSTEXPR optional& operator=(const optional& rhs)
+    {
+      if (has_value())
+      {
+        if (rhs.has_value())
+          **this = *rhs;
+        else
+          reset();
+      }
+      else
+      {
+        if (rhs.has_value())
+          initialize(*rhs);
+      }
+
+      return *this;
+    }
+
+    BOOST_OPTIONAL_CXX20_CONSTEXPR optional& operator=(optional&& rhs)
+      noexcept(::std::is_nothrow_move_assignable<T>::value && ::std::is_nothrow_move_constructible<T>::value)
+    {
+      if (has_value())
+      {
+        if (rhs.has_value())
+          **this = *optional_detail::move_(rhs);
+        else
+          reset();
+      }
+      else
+      {
+        if (rhs.has_value())
+          initialize(*optional_detail::move_(rhs) );
+      }
+
+      return *this;
+    }
+
+    template <typename U>
+    BOOST_OPTIONAL_CXX20_CONSTEXPR optional& operator=(const optional<U>& rhs)
+    {
+      if (has_value())
+      {
+        if (rhs.has_value())
+          **this = *rhs;
+        else
+          reset();
+      }
+      else
+      {
+        if (rhs.has_value())
+          initialize(*rhs);
+      }
+
+      return *this;
+    }
+
+    template <typename U>
+    BOOST_OPTIONAL_CXX20_CONSTEXPR optional& operator=(optional<U>&& rhs)
+    {
+      if (has_value())
+      {
+        if (rhs.has_value())
+          **this = *optional_detail::move_(rhs);
+        else
+          reset();
+      }
+      else
+      {
+        if (rhs.has_value())
+          initialize(*optional_detail::move_(rhs));
+      }
+
+      return *this;
+    }
+
+    template <class U = typename ::std::remove_cv<T>::type,
+              BOOST_OPTIONAL_REQUIRES(!::std::is_same<typename ::std::decay<U>::type, optional>),
+              BOOST_OPTIONAL_REQUIRES(!optional_detail::conjunction<::std::is_scalar<T>, ::std::is_same<T, BOOST_OPTIONAL_DECAY(U)>>),
+              BOOST_OPTIONAL_REQUIRES(::std::is_constructible<T, U>),
+              BOOST_OPTIONAL_REQUIRES(::std::is_assignable<T&, U>),
+              BOOST_OPTIONAL_REQUIRES(!optional_detail::is_typed_in_place_factory<U>),
+              BOOST_OPTIONAL_REQUIRES(!optional_detail::is_in_place_factory<U>)
+             >
+    BOOST_OPTIONAL_CXX20_CONSTEXPR optional& operator=(U&& v)
+    {
+      if (is_initialized())
+        contained_val() = optional_detail::forward_<U>(v);
+      else
+        initialize(optional_detail::forward_<U>(v));
+      return *this;
+    }
+
+    template <class F, BOOST_OPTIONAL_REQUIRES(optional_detail::is_in_place_factory<F>)>
+    /*non-constexpr (deprecated)*/
+    optional& operator=(F&& factory)
+    {
+      reset();
+      boost_optional_detail::construct<value_type>(factory, this->dataptr());
+      storage.init_ = true;
+      return *this;
+    }
+
+    template <class F, BOOST_OPTIONAL_REQUIRES(optional_detail::is_typed_in_place_factory<F>)>
+    /*non-constexpr (deprecated)*/
+    optional& operator=(F&& factory)
+    {
+      reset();
+      factory.apply(this->dataptr());
+      storage.init_ = true;
+      return *this;
+    }
+
+    BOOST_OPTIONAL_CXX20_CONSTEXPR
+    void swap(optional& rhs)
+      noexcept(::std::is_nothrow_move_constructible<T>::value && noexcept(boost::core::invoke_swap(*rhs, *rhs)))
+    {
+      if (is_initialized())
+      {
+        if (rhs.is_initialized())
+          boost::core::invoke_swap(contained_val(), rhs.contained_val());
+        else
+          { rhs.initialize(optional_detail::move_(*this).contained_val()); reset(); }
+      }
+      else
+      {
+        if (rhs.is_initialized())
+          { initialize(optional_detail::move_(rhs).contained_val()); rhs.reset(); }
+      }
+    }
+
+    ~optional() = default; // The destructor in `storage`, based on the specialization
+                           // will be trivial or not.
+
+    constexpr bool has_value() const noexcept { return this->is_initialized(); }
+    constexpr explicit operator bool() const noexcept { return this->is_initialized(); }
+
+    constexpr             reference_const_type get() const { return BOOST_OPTIONAL_ASSERTED_EXPRESSION(this->is_initialized(), this->contained_val()); }
+    BOOST_CXX14_CONSTEXPR reference_type       get()       { BOOST_ASSERT(this->is_initialized()) ; return this->contained_val(); }
+
+    //BOOST_DEPRECATED("use `value_or(v)` instead")
+    reference_const_type get_value_or (reference_const_type v) const { return this->is_initialized() ? this->contained_val() : v; }
+
+    //BOOST_DEPRECATED("use `value_or(v)` instead")
+    reference_type       get_value_or (reference_type       v)       { return this->is_initialized() ? this->contained_val() : v; }
+
+    pointer_const_type get_ptr() const { return is_initialized() ? dataptr() : nullptr; }
+    pointer_type       get_ptr()       { return is_initialized() ? dataptr() : nullptr; }
+
+    constexpr             reference_const_type operator*() const& { return this->get(); }
+    BOOST_CXX14_CONSTEXPR reference_type       operator*() &      { return this->get(); }
+    BOOST_CXX14_CONSTEXPR reference_type_of_temporary_wrapper operator*() && { return optional_detail::move_(this->get()); }
+
+    constexpr             pointer_const_type operator->() const { return BOOST_OPTIONAL_ASSERTED_EXPRESSION(this->is_initialized(), this->dataptr()); }
+    BOOST_CXX14_CONSTEXPR pointer_type       operator->()       { BOOST_ASSERT(this->is_initialized()) ; return this->dataptr(); }
+
+    constexpr reference_const_type value() const&
+    {
+      return this->is_initialized() ? this->get() : (boost::throw_exception(boost::bad_optional_access()), this->get());
+    }
+
+    BOOST_CXX14_CONSTEXPR reference_type value() &
+    {
+      if (this->is_initialized())
+        return this->get();
+      else
+        boost::throw_exception(boost::bad_optional_access());
+    }
+
+    BOOST_CXX14_CONSTEXPR reference_type_of_temporary_wrapper value() &&
+    {
+      if (this->is_initialized())
+        return optional_detail::move_(this->get());
+      else
+        boost::throw_exception(boost::bad_optional_access());
+    }
+
+    template <class U = typename ::std::remove_cv<T>::type,
+              typename fail_hard_on_nonconvertible<T, U>::type = true>
+    constexpr value_type value_or(U&& v) const&
+    {
+      return this->is_initialized() ? get() : T(optional_detail::forward_<U>(v));
+    }
+
+    template <class U = typename ::std::remove_cv<T>::type>
+    BOOST_CXX14_CONSTEXPR value_type value_or(U&& v) &&
+    {
+      if (this->is_initialized())
+        return optional_detail::move_(get());
+      else
+        return optional_detail::forward_<U>(v);
+    }
+
+    template <typename F,
+              typename fail_hard_on_nonconvertible<T, decltype(optional_detail::declval_<F>()())>::type = true>
+    constexpr value_type value_or_eval(F f) const&
+    {
+      return this->is_initialized() ? get() : value_type(f());
+    }
+
+    template <typename F>
+    BOOST_CXX14_CONSTEXPR value_type value_or_eval ( F f ) &&
+    {
+      if (this->is_initialized())
+        return optional_detail::move_(get());
+      else
+        return f();
+    }
+
+    template <typename F>
+    BOOST_CXX14_CONSTEXPR optional<typename optional_detail::result_of<F, reference_type>::type>
+    map(F f) &
+    {
+      if (this->has_value())
+        return f(get());
+      else
+        return none;
+    }
+
+    template <typename F>
+    constexpr optional<typename optional_detail::result_of<F, reference_const_type>::type>
+    map(F f) const&
+    {
+      return this->has_value() ?
+             f(get()) :
+             optional<typename optional_detail::result_of<F, reference_const_type>::type>();
+    }
+
+    template <typename F>
+    BOOST_CXX14_CONSTEXPR optional<typename optional_detail::result_of<F, reference_type_of_temporary_wrapper>::type>
+    map(F f) &&
+    {
+      if (this->has_value())
+        return f(optional_detail::move_(this->get()));
+      else
+        return none;
+    }
+
+    template <typename F>
+    BOOST_CXX14_CONSTEXPR optional<typename optional_detail::result_value_type<F, reference_type>::type>
+    flat_map(F f) &
+    {
+      if (this->has_value())
+        return f(get());
+      else
+        return none;
+    }
+
+    template <typename F>
+    constexpr optional<typename optional_detail::result_value_type<F, reference_const_type>::type>
+    flat_map(F f) const&
+    {
+      return this->has_value() ?
+             f(get()) :
+             optional<typename optional_detail::result_value_type<F, reference_const_type>::type>();
+    }
+
+    template <typename F>
+    BOOST_CXX14_CONSTEXPR optional<typename optional_detail::result_value_type<F, reference_type_of_temporary_wrapper>::type>
+    flat_map(F f) &&
+    {
+      if (this->has_value())
+        return f(optional_detail::move_(get()));
+      else
+        return none;
+    }
+
+  };
+
+  template <typename T>
+  BOOST_OPTIONAL_CXX20_CONSTEXPR
+  void swap(optional<T>& lhs, optional<T>& rhs)
+    noexcept(::std::is_nothrow_move_constructible<T>::value && noexcept(boost::core::invoke_swap(*lhs, *rhs)))
+  {
+    lhs.swap(rhs);
+  }
+
+}
+
+
+#endif // BOOST_OPTIONAL_DETAIL_UNION_OPTIONAL_01FEB2026_HPP
@@ -1,4 +1,5 @@
 // Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2016 Andrzej Krzemienski
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -11,19 +12,40 @@
 //
 // Revisions:
 // 10 May 2008 (added swap related forward declaration) Niels Dekker
-// 
+//
 #ifndef BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP
 #define BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP

+#include <boost/config.hpp>
+#include <boost/core/invoke_swap.hpp>
+#include <boost/optional/detail/optional_select_implementation.hpp>
+#include <type_traits>
+
+
 namespace boost {

 template<class T> class optional ;

-template<class T> void swap ( optional<T>& , optional<T>& ) ;
+// This forward is needed to refer to namespace scope swap from the member swap
+#ifdef BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
+  template<class T> BOOST_OPTIONAL_CXX20_CONSTEXPR void swap ( optional<T>& lhs, optional<T>& rhs )
+    noexcept(::std::is_nothrow_move_constructible<T>::value && noexcept(boost::core::invoke_swap(*lhs, *rhs)));
+#else
+  template<class T> void swap ( optional<T>& , optional<T>& ) ;
+#endif // BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
+

 template<class T> struct optional_swap_should_use_default_constructor ;

+
+#ifndef BOOST_OPTIONAL_CONFIG_DONT_SPECIALIZE_OPTIONAL_REFS
+
+  template<class T> class optional<T&> ;
+
+  template<class T> BOOST_CXX14_CONSTEXPR void swap ( optional<T&>& , optional<T&>& ) BOOST_NOEXCEPT;
+
+#endif
+
 } // namespace boost

 #endif
-
@@ -12,40 +12,38 @@
 #ifndef BOOST_OPTIONAL_OPTIONAL_IO_FLC_19NOV2002_HPP
 #define BOOST_OPTIONAL_OPTIONAL_IO_FLC_19NOV2002_HPP

-#if defined __GNUC__
-#  if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97)
-#    define BOOST_OPTIONAL_NO_TEMPLATED_STREAMS
-#  endif
-#endif // __GNUC__
+#ifndef BOOST_NO_IOSTREAM
+#include <istream>
+#include <ostream>

-#if defined BOOST_OPTIONAL_NO_TEMPLATED_STREAMS
-#  include <iostream>
-#else
-#  include <istream>
-#  include <ostream>
-#endif
-
-#include <boost/none.hpp>
-#include <boost/assert.hpp>
+#include "boost/none.hpp"
 #include "boost/optional/optional.hpp"
-#include "boost/utility/value_init.hpp"
+

 namespace boost
 {

-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-template<class T>
-inline std::ostream& operator<<(std::ostream& out, optional<T> const& v)
-#else
+template<class CharType, class CharTrait>
+inline
+std::basic_ostream<CharType, CharTrait>&
+operator<<(std::basic_ostream<CharType, CharTrait>& out, none_t)
+{
+  if (out.good())
+  {
+    out << "--";
+  }
+
+  return out;
+}
+
 template<class CharType, class CharTrait, class T>
 inline
 std::basic_ostream<CharType, CharTrait>&
 operator<<(std::basic_ostream<CharType, CharTrait>& out, optional<T> const& v)
-#endif
 {
-  if ( out.good() )
+  if (out.good())
  {
-    if ( !v )
+    if (!v)
         out << "--" ;
    else out << ' ' << *v ;
  }
@@ -53,15 +51,10 @@ operator<<(std::basic_ostream<CharType, CharTrait>& out, optional<T> const& v)
  return out;
 }

-#if defined (BOOST_NO_TEMPLATED_STREAMS)
-template<class T>
-inline std::istream& operator>>(std::istream& in, optional<T>& v)
-#else
 template<class CharType, class CharTrait, class T>
 inline
 std::basic_istream<CharType, CharTrait>&
 operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v)
-#endif
 {
  if (in.good())
  {
@@ -70,7 +63,7 @@ operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v)
    {
      T x;
      in >> x;
-      v = x;
+      v = optional_detail::move_(x);
    }
    else
    {
@@ -94,5 +87,5 @@ operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v)

 } // namespace boost

+#endif // BOOST_NO_IOSTREAM
 #endif
-
@@ -0,0 +1,17 @@
+{
+    "key": "optional",
+    "boost-version": "1.30.0",
+    "name": "Optional",
+    "authors": [
+        "Fernando Cacciola"
+    ],
+    "description": "A value-semantic, type-safe wrapper for representing 'optional' (or 'nullable') objects of a given type. An optional object may or may not contain a value of the underlying type.",
+    "category": [
+        "Data"
+    ],
+    "maintainers": [
+        "Fernando Cacciola <fernando_cacciola -at- ciudad.com.ar>",
+        "Andrzej Krzemienski <akrzemi1 -at- gmail.com>"
+    ],
+    "cxxstd": "11"
+}
@@ -0,0 +1,11 @@
+# Copyright 2018, 2019 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
+
+if(HAVE_BOOST_TEST)
+
+boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::optional Boost::core Boost::bind Boost::tuple Boost::utility)
+
+endif()
@@ -1,33 +1,109 @@
-#  Boost.Optional Library test Jamfile
+# Boost.Optional Library test Jamfile
 #
-#  Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+# Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+# Copyright (C) 2014 - 2017 Andrzej Krzemienski
+# Copyright (C) 2024 Alexander Grund
 #
-#  This material is provided "as is", with absolutely no warranty expressed
-#  or implied. Any use is at your own risk.
+# Use, modification, and distribution is subject to 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)
 #
-#  Permission to use or copy this software for any purpose is hereby granted
-#  without fee, provided the above notices are retained on all copies.
-#  Permission to modify the code and to distribute modified code is granted,
-#  provided the above notices are retained, and a notice that the code was
-#  modified is included with the above copyright notice.
+# See http://www.boost.org/libs/optional for documentation.
+#
+# You are welcome to contact the author at:
+#  akrzemi1@gmail.com
 #

+import config : requires ;
 import testing ;

-{
-  test-suite optional :
-    [ run optional_test.cpp ]
-    [ run optional_test_tie.cpp ]
-    [ run optional_test_ref.cpp ]
-    [ run optional_test_inplace.cpp ]
-    [ run optional_test_io.cpp ]
-    [ compile-fail optional_test_fail1.cpp ]
-    [ compile-fail optional_test_fail3a.cpp ]
-    [ compile-fail optional_test_fail3b.cpp ]
-    [ compile-fail optional_test_ref_fail1.cpp ]
-    [ compile-fail optional_test_ref_fail3.cpp ]
-    [ compile-fail optional_test_ref_fail4.cpp ]
-    [ compile-fail optional_test_inplace_fail.cpp ]
-    [ compile-fail optional_test_inplace_fail2.cpp ]
-  ;
-}
+project
+    : requirements
+        <library>/boost/optional//boost_optional
+        [ requires
+            cxx11_decltype
+            cxx11_defaulted_functions
+            cxx11_defaulted_moves
+            cxx11_deleted_functions
+            cxx11_explicit_conversion_operators
+#            cxx11_noexcept
+            cxx11_rvalue_references
+            cxx11_variadic_templates
+        ]
+    ;
+
+
+run optional_test.cpp : : : <library>/boost/bind//boost_bind ;
+run optional_test_assign.cpp ;
+run optional_test_swap.cpp ;
+compile optional_test_constexpr.cpp ;
+compile optional_test_wuninitialized.cpp ;
+compile optional_test_fwd_header.cpp ;
+run optional_test_conversions_from_U.cpp ;
+run optional_test_convert_from_T.cpp ;
+run optional_test_convert_assign.cpp ;
+run optional_test_empty_braces.cpp ;
+run optional_test_make_optional.cpp ;
+run optional_test_flat_map.cpp ;
+run optional_test_hash.cpp ;
+run optional_test_map.cpp ;
+run optional_test_tie.cpp : : : <library>/boost/tuple//boost_tuple ;
+run optional_test_ranges_find.cpp ;
+run optional_test_ref_assign_portable_minimum.cpp ;
+run optional_test_ref_assign_mutable_int.cpp ;
+run optional_test_ref_assign_const_int.cpp ;
+run optional_test_ref_converting_ctor.cpp ;
+run optional_test_ref_convert_assign_non_int.cpp ;
+run optional_test_ref_convert_assign_mutable_int.cpp ;
+run optional_test_ref_convert_assign_const_int.cpp ;
+run optional_test_ref_portable_minimum.cpp ;
+run optional_test_ref_move.cpp ;
+run optional_test_ref_to_val.cpp ;
+run optional_test_inplace_factory.cpp ;
+run optional_test_io.cpp ;
+run optional_test_move.cpp ;
+run optional_test_noexcept_move.cpp ;
+run optional_test_cmp_none.cpp ;
+run optional_test_value_access.cpp ;
+run optional_test_emplace.cpp ;
+run optional_test_minimum_requirements.cpp ;
+run optional_test_msvc_bug_workaround.cpp ;
+run optional_test_member_T.cpp ;
+run optional_test_tc_base.cpp ;
+compile optional_test_sfinae_friendly_ctor.cpp ;
+compile optional_test_path_assignment.cpp ;
+compile-fail optional_test_fail_const_swap.cpp ;
+compile-fail optional_test_ref_convert_assign_const_int_prevented.cpp ;
+compile-fail optional_test_fail1.cpp ;
+compile-fail optional_test_fail3a.cpp ;
+compile-fail optional_test_fail3b.cpp ;
+compile-fail optional_test_ref_fail1.cpp ;
+compile-fail optional_test_ref_fail3.cpp ;
+compile-fail optional_test_ref_fail4.cpp ;
+compile-fail optional_test_ref_fail_convert_from_temporary_optional_T.cpp ;
+compile-fail optional_test_inplace_fail.cpp ;
+compile-fail optional_test_inplace_fail2.cpp ;
+compile-fail optional_test_fail_implicit_bool_convert.cpp ;
+compile-fail optional_test_fail_copying_a_moveable_type.cpp ;
+compile-fail optional_test_fail_optional_rvalue_ref.cpp ;
+compile-fail optional_test_ref_fail_init_from_Trefref.cpp ;
+compile-fail optional_test_ref_fail_init_from_Urefref.cpp ;
+compile-fail optional_test_ref_fail_assign_from_Trefref.cpp ;
+compile-fail optional_test_ref_fail_assign_from_Urefref.cpp ;
+compile-fail optional_test_fail_convert_from_null.cpp ;
+compile-fail optional_test_fail_explicit_convert_in_value_or.cpp ;
+compile-fail optional_test_fail_explicit_convert_in_value_or_call.cpp ;
+compile-fail optional_test_fail_io_without_io.cpp ;
+compile-fail optional_test_fail_none_io_without_io.cpp ;
+compile-fail optional_test_fail_convert_assign_of_enums.cpp ;
+run optional_test_static_properties.cpp ;
+compile optional_test_maybe_uninitialized_warning.cpp ;
+compile optional_test_deleted_default_ctor.cpp ;
+compile optional_test_constructible_from_other.cpp ;
+#run optional_xconfig_HACK_TO_LIST_PREDEFINED_MACROS.cpp ;
+run optional_xconfig_NO_PROPER_ASSIGN_FROM_CONST_INT_pass.cpp ;
+run-fail optional_xconfig_NO_PROPER_ASSIGN_FROM_CONST_INT_fail.cpp ;
+run optional_xconfig_NO_PROPER_CONVERT_FROM_CONST_INT_pass.cpp ;
+run-fail optional_xconfig_NO_PROPER_CONVERT_FROM_CONST_INT_fail.cpp ;
+run optional_xconfig_NO_LEGAL_CONVERT_FROM_REF_pass.cpp ;
+compile-fail optional_xconfig_NO_LEGAL_CONVERT_FROM_REF_fail.cpp ;
@@ -0,0 +1,17 @@
+# Copyright 2018, 2019 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(cmake_subdir_test LANGUAGES CXX)
+
+find_package(boost_optional REQUIRED)
+
+add_executable(main main.cpp)
+target_link_libraries(main Boost::optional)
+
+enable_testing()
+add_test(main main)
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
@@ -0,0 +1,13 @@
+// Copyright 2024 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/optional/optional.hpp>
+
+int main()
+{
+    boost::optional<int> o1;
+    boost::optional<int> o2( 0 );
+    o1 = o2;
+    return *o1;
+}
@@ -0,0 +1,18 @@
+# Copyright 2018, 2019 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(cmake_subdir_test LANGUAGES CXX)
+
+set(BOOST_INCLUDE_LIBRARIES optional)
+add_subdirectory(../../../.. boostorg/boost)
+
+add_executable(main main.cpp)
+target_link_libraries(main Boost::optional)
+
+enable_testing()
+add_test(main main)
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
@@ -0,0 +1,13 @@
+// Copyright 2024 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/optional/optional.hpp>
+
+int main()
+{
+    boost::optional<int> o1;
+    boost::optional<int> o2( 0 );
+    o1 = o2;
+    return *o1;
+}
@@ -0,0 +1,181 @@
+// Copyright (C) 2014 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/lib/optional for documentation.
+//
+// You are welcome to contact the author at: akrzemi1@gmail.com
+
+#ifndef BOOST_OPTIONAL_TEST_OPTIONAL_REF_ASSIGN_TEST_DEFS_AK_07JAN2015_HPP
+#define BOOST_OPTIONAL_TEST_OPTIONAL_REF_ASSIGN_TEST_DEFS_AK_07JAN2015_HPP
+
+#include "boost/optional/optional.hpp"
+
+#ifdef BOOST_BORLANDC
+#pragma hdrstop
+#endif
+
+#include "boost/core/addressof.hpp"
+#include "testable_classes.hpp"
+
+using boost::optional;
+using boost::none;
+using boost::addressof;
+
+template <typename T>
+void test_copy_assignment_for_const()
+{
+  const typename concrete_type_of<T>::type v(2);
+  optional<const T&> o;
+  o = optional<const T&>(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(o != none);
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST(val(*o) == val(v));
+  BOOST_TEST(val(*o) == 2);
+}
+
+template <typename T>
+void test_copy_assignment_for_noconst_const()
+{
+  typename concrete_type_of<T>::type v(2);
+  optional<const T&> o;
+  o = optional<const T&>(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(o != none);
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST(val(*o) == val(v));
+  BOOST_TEST(val(*o) == 2);
+  
+  val(v) = 9;
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 9);
+  BOOST_TEST_EQ(val(v), 9);
+}
+
+template <typename T>
+void test_copy_assignment_for()
+{
+  typename concrete_type_of<T>::type v(2);
+  optional<T&> o;
+  o = optional<T&>(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(o != none);
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST(val(*o) == val(v));
+  BOOST_TEST(val(*o) == 2);
+  
+  val(v) = 9;
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 9);
+  BOOST_TEST_EQ(val(v), 9);
+  
+  val(*o) = 7;
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 7);
+  BOOST_TEST_EQ(val(v), 7);
+}
+
+template <typename T>
+void test_rebinding_assignment_semantics_const()
+{
+  const typename concrete_type_of<T>::type v(2), w(7);
+  optional<const T&> o(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 2);
+  
+  o = optional<const T&>(w);
+  BOOST_TEST_EQ(val(v), 2);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(addressof(*o) != addressof(v));
+  BOOST_TEST_NE(val(*o), val(v));
+  BOOST_TEST_NE(val(*o), 2);
+  
+  BOOST_TEST(addressof(*o) == addressof(w));
+  BOOST_TEST_EQ(val(*o), val(w));
+  BOOST_TEST_EQ(val(*o), 7);
+}
+
+template <typename T>
+void test_rebinding_assignment_semantics_noconst_const()
+{
+  typename concrete_type_of<T>::type v(2), w(7);
+  optional<const T&> o(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 2);
+  
+  o = optional<const T&>(w);
+  BOOST_TEST_EQ(val(v), 2);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(addressof(*o) != addressof(v));
+  BOOST_TEST_NE(val(*o), val(v));
+  BOOST_TEST_NE(val(*o), 2);
+  
+  BOOST_TEST(addressof(*o) == addressof(w));
+  BOOST_TEST_EQ(val(*o), val(w));
+  BOOST_TEST_EQ(val(*o), 7);
+}
+
+template <typename T>
+void test_rebinding_assignment_semantics()
+{
+  typename concrete_type_of<T>::type v(2), w(7);
+  optional<T&> o(v);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(addressof(*o) == addressof(v));
+  BOOST_TEST_EQ(val(*o), val(v));
+  BOOST_TEST_EQ(val(*o), 2);
+  
+  o = optional<T&>(w);
+  BOOST_TEST_EQ(val(v), 2);
+  
+  BOOST_TEST(o);
+  BOOST_TEST(addressof(*o) != addressof(v));
+  BOOST_TEST_NE(val(*o), val(v));
+  BOOST_TEST_NE(val(*o), 2);
+  
+  BOOST_TEST(addressof(*o) == addressof(w));
+  BOOST_TEST_EQ(val(*o), val(w));
+  BOOST_TEST_EQ(val(*o), 7);
+  
+  val(*o) = 8;
+  BOOST_TEST(addressof(*o) == addressof(w));
+  BOOST_TEST_EQ(val(*o), val(w));
+  BOOST_TEST_EQ(val(*o), 8);
+  BOOST_TEST_EQ(val(w), 8);
+  BOOST_TEST_EQ(val(v), 2);
+}
+
+template <typename T, typename U>
+void test_converting_assignment()
+{
+  typename concrete_type_of<T>::type v1(1), v2(2), v3(3);
+  optional<U&> oA(v1), oB(none);
+  
+  oA = v2;
+  BOOST_TEST(oA);
+  BOOST_TEST(addressof(*oA) == addressof(v2));
+  
+  oB = v3;
+  BOOST_TEST(oB);
+  BOOST_TEST(addressof(*oB) == addressof(v3));
+}
+
+#endif //BOOST_OPTIONAL_TEST_OPTIONAL_REF_ASSIGN_TEST_DEFS_AK_07JAN2015_HPP
@@ -12,27 +12,30 @@
 // Revisions:
 // 12 May 2008 (added more swap tests)
 //
+#ifndef BOOST_NO_IOSTREAM
 #include<iostream>
+#endif // BOOST_NO_IOSTREAM
 #include<stdexcept>
 #include<string>

 #define BOOST_ENABLE_ASSERT_HANDLER

+#include "boost/config.hpp"
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 #include "boost/bind/apply.hpp" // Included just to test proper interaction with boost::apply<> as reported by Daniel Wallin
-#include "boost/mpl/bool.hpp"
-#include "boost/mpl/bool_fwd.hpp"  // For mpl::true_ and mpl::false_
+#endif

 #include "boost/optional/optional.hpp"

-#ifdef __BORLANDC__
+#ifdef BOOST_BORLANDC
 #pragma hdrstop
 #endif

 #include "boost/none.hpp"

-#include "boost/test/minimal.hpp"
+#include "boost/core/lightweight_test.hpp"

-#include "optional_test_common.cpp"
+#include "optional_test_common.hpp"

 void test_implicit_construction ( optional<double> opt, double v, double z )
 {
@@ -46,12 +49,12 @@ void test_implicit_construction ( optional<X> opt, X const& v, X const& z )

 void test_default_implicit_construction ( double, optional<double> opt )
 {
-  BOOST_CHECK(!opt);
+  BOOST_TEST(!opt);
 }

 void test_default_implicit_construction ( X const&, optional<X> opt )
 {
-  BOOST_CHECK(!opt);
+  BOOST_TEST(!opt);
 }

 //
@@ -75,7 +78,7 @@ void test_basics( T const* )
  check_uninitialized(def);

  // Implicit construction
-  // The first parameter is implicitely converted to optional<T>(a);
+  // The first parameter is implicitly converted to optional<T>(a);
  test_implicit_construction(a,a,z);

  // Direct initialization.
@@ -162,7 +165,7 @@ void test_basics( T const* )
 }

 template<class T>
-void test_conditional_ctor_and_get_valur_or ( T const* )
+void test_conditional_ctor_and_get_value_or ( T const* )
 {
  TRACE( std::endl << BOOST_CURRENT_FUNCTION  );

@@ -188,65 +191,65 @@ void test_conditional_ctor_and_get_valur_or ( T const* )
  check_value(o1,a,z);

  T b = def0.get_value_or(z);
-  BOOST_CHECK( b == z ) ;
+  BOOST_TEST( b == z ) ;

  b = get_optional_value_or(def0,z);
-  BOOST_CHECK( b == z ) ;
+  BOOST_TEST( b == z ) ;

  b = o0.get_value_or(z);
-  BOOST_CHECK( b == a ) ;
+  BOOST_TEST( b == a ) ;

  b = get_optional_value_or(o0,z);
-  BOOST_CHECK( b == a ) ;
+  BOOST_TEST( b == a ) ;


  T const& crz = z ;
  T&        rz = z ;

  T const& crzz = def0.get_value_or(crz);
-  BOOST_CHECK( crzz == crz ) ;
+  BOOST_TEST( crzz == crz ) ;

  T& rzz = def0.get_value_or(rz);
-  BOOST_CHECK( rzz == rz ) ;
+  BOOST_TEST( rzz == rz ) ;

  T const& crzzz = get_optional_value_or(cdef0,crz);
-  BOOST_CHECK( crzzz == crz ) ;
+  BOOST_TEST( crzzz == crz ) ;

  T& rzzz = get_optional_value_or(def0,rz);
-  BOOST_CHECK( rzzz == rz ) ;
+  BOOST_TEST( rzzz == rz ) ;

  T const& crb = o0.get_value_or(crz);
-  BOOST_CHECK( crb == a ) ;
+  BOOST_TEST( crb == a ) ;

  T& rb = o0.get_value_or(rz);
-  BOOST_CHECK( rb == b ) ;
+  BOOST_TEST( rb == b ) ;

  T const& crbb = get_optional_value_or(co0,crz);
-  BOOST_CHECK( crbb == b ) ;
+  BOOST_TEST( crbb == b ) ;

  T const& crbbb = get_optional_value_or(o0,crz);
-  BOOST_CHECK( crbbb == b ) ;
+  BOOST_TEST( crbbb == b ) ;

  T& rbb = get_optional_value_or(o0,rz);
-  BOOST_CHECK( rbb == b ) ;
+  BOOST_TEST( rbb == b ) ;

  T& ra = a ;

  optional<T&> defref(false,ra);
-  BOOST_CHECK(!defref);
+  BOOST_TEST(!defref);

  optional<T&> ref(true,ra);
-  BOOST_CHECK(!!ref);
+  BOOST_TEST(!!ref);

  a = T(432);

-  BOOST_CHECK( *ref == a ) ;
+  BOOST_TEST( *ref == a ) ;

  T& r1 = defref.get_value_or(z);
-  BOOST_CHECK( r1 == z ) ;
+  BOOST_TEST( r1 == z ) ;

  T& r2 = ref.get_value_or(z);
-  BOOST_CHECK( r2 == a ) ;
+  BOOST_TEST( r2 == a ) ;
 }

 //
@@ -262,18 +265,18 @@ void test_direct_value_manip( T const* )
  optional<T> const c_opt0(x) ;
  optional<T>         opt0(x);

-  BOOST_CHECK( c_opt0.get().V() == x.V() ) ;
-  BOOST_CHECK(   opt0.get().V() == x.V() ) ;
+  BOOST_TEST( c_opt0.get().V() == x.V() ) ;
+  BOOST_TEST(   opt0.get().V() == x.V() ) ;

-  BOOST_CHECK( c_opt0->V() == x.V() ) ;
-  BOOST_CHECK(   opt0->V() == x.V() ) ;
+  BOOST_TEST( c_opt0->V() == x.V() ) ;
+  BOOST_TEST(   opt0->V() == x.V() ) ;

-  BOOST_CHECK( (*c_opt0).V() == x.V() ) ;
-  BOOST_CHECK( (*  opt0).V() == x.V() ) ;
+  BOOST_TEST( (*c_opt0).V() == x.V() ) ;
+  BOOST_TEST( (*  opt0).V() == x.V() ) ;

  T y(4);
  opt0 = y ;
-  BOOST_CHECK( get(opt0).V() == y.V() ) ;
+  BOOST_TEST( get(opt0).V() == y.V() ) ;
 }

 //
@@ -291,45 +294,45 @@ void test_uninitialized_access( T const* )
  {
    // This should throw because 'def' is uninitialized
    T const& n = def.get() ;
-    unused_variable(n);
+    boost::ignore_unused(n);
    passed = true ;
  }
  catch (...) {}
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);

  passed = false ;
  try
  {
    // This should throw because 'def' is uninitialized
    T const& n = *def ;
-    unused_variable(n);
+    boost::ignore_unused(n);
    passed = true ;
  }
  catch (...) {}
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);

  passed = false ;
  try
  {
    T v(5) ;
-    unused_variable(v);
+    boost::ignore_unused(v);
    // This should throw because 'def' is uninitialized
    *def = v ;
    passed = true ;
  }
  catch (...) {}
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);

  passed = false ;
  try
  {
    // This should throw because 'def' is uninitialized
    T v = *(def.operator->()) ;
-    unused_variable(v);
+    boost::ignore_unused(v);
    passed = true ;
  }
  catch (...) {}
-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
 }

 #if BOOST_WORKAROUND( BOOST_INTEL_CXX_VERSION, <= 700) // Intel C++ 7.0
@@ -374,7 +377,7 @@ void test_throwing_direct_init( T const* )
  }
  catch ( ... ){}

-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);
  check_is_not_pending_copy( ARG(T) );
  check_instance_count(count, ARG(T) );

@@ -410,7 +413,7 @@ void test_throwing_val_assign_on_uninitialized( T const* )
  }
  catch ( ... ) {}

-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);

  check_is_not_pending_copy( ARG(T) );
  check_instance_count(count, ARG(T) );
@@ -448,15 +451,15 @@ void test_throwing_val_assign_on_initialized( T const* )
  {
    // This should:
    //   Attempt to assign 'a' and throw.
-    //   opt is kept initialized but its value not neccesarily fully assigned
-    //   (in this test, incompletely assigned is flaged with the value -1 being set)
+    //   opt is kept initialized but its value not necessarily fully assigned
+    //   (in this test, incompletely assigned is flagged with the value -1 being set)
    set_pending_assign( ARG(T) ) ;
    opt.reset ( a ) ;
    passed = true ;
  }
  catch ( ... ) {}

-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);

  check_is_not_pending_assign( ARG(T) );
  check_instance_count(count, ARG(T) );
@@ -495,7 +498,7 @@ void test_throwing_copy_initialization( T const* )
  }
  catch ( ... ) {}

-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);

  check_is_not_pending_copy( ARG(T) );
  check_instance_count(count, ARG(T) );
@@ -538,7 +541,7 @@ void test_throwing_assign_to_uninitialized( T const* )
  }
  catch ( ... ) {}

-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);

  check_is_not_pending_copy( ARG(T) );
  check_instance_count(count, ARG(T) );
@@ -573,15 +576,15 @@ void test_throwing_assign_to_initialized( T const* )
  {
    // This should:
    //   Attempt to copy construct 'opt1.value()' into opt0 and throw.
-    //   opt0 is kept initialized but its value not neccesarily fully assigned
-    //   (in this test, incompletely assigned is flaged with the value -1 being set)
+    //   opt0 is kept initialized but its value not necessarily fully assigned
+    //   (in this test, incompletely assigned is flagged with the value -1 being set)
    set_pending_assign( ARG(T) ) ;
    opt0 = opt1 ;
    passed = true ;
  }
  catch ( ... ) {}

-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);

  // opt0 was left uninitialized
  check_is_not_pending_assign( ARG(T) );
@@ -661,7 +664,7 @@ void test_throwing_swap( T const* )
  }
  catch ( ... ) {}

-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);

  // optional's swap doesn't affect the initialized states of the arguments. Therefore,
  // the following must hold:
@@ -685,14 +688,14 @@ void test_throwing_swap( T const* )
  try
  {
    // This should attempt to swap optionals and fail at opt0.reset(*opt1)
-    // Both opt0 and op1 are left unchanged (unswaped)
+    // Both opt0 and op1 are left unchanged (unswapped)
    swap(opt0,opt1);

    passed = true ;
  }
  catch ( ... ) {}

-  BOOST_CHECK(!passed);
+  BOOST_TEST(!passed);

  check_uninitialized(opt0);
  check_initialized(opt1);
@@ -720,69 +723,69 @@ void test_relops( T const* )
  optional<T> opt2(v2);

  // Check identity
-  BOOST_CHECK ( def0 == def0 ) ;
-  BOOST_CHECK ( opt0 == opt0 ) ;
-  BOOST_CHECK ( !(def0 != def0) ) ;
-  BOOST_CHECK ( !(opt0 != opt0) ) ;
+  BOOST_TEST ( def0 == def0 ) ;
+  BOOST_TEST ( opt0 == opt0 ) ;
+  BOOST_TEST ( !(def0 != def0) ) ;
+  BOOST_TEST ( !(opt0 != opt0) ) ;

-  // Check when both are uininitalized.
-  BOOST_CHECK (   def0 == def1  ) ; // both uninitialized compare equal
-  BOOST_CHECK ( !(def0 <  def1) ) ; // uninitialized is never less    than uninitialized
-  BOOST_CHECK ( !(def0 >  def1) ) ; // uninitialized is never greater than uninitialized
-  BOOST_CHECK ( !(def0 != def1) ) ;
-  BOOST_CHECK (   def0 <= def1  ) ;
-  BOOST_CHECK (   def0 >= def1  ) ;
+  // Check when both are uninitialized.
+  BOOST_TEST (   def0 == def1  ) ; // both uninitialized compare equal
+  BOOST_TEST ( !(def0 <  def1) ) ; // uninitialized is never less    than uninitialized
+  BOOST_TEST ( !(def0 >  def1) ) ; // uninitialized is never greater than uninitialized
+  BOOST_TEST ( !(def0 != def1) ) ;
+  BOOST_TEST (   def0 <= def1  ) ;
+  BOOST_TEST (   def0 >= def1  ) ;

  // Check when only lhs is uninitialized.
-  BOOST_CHECK (   def0 != opt0  ) ; // uninitialized is never equal to initialized
-  BOOST_CHECK ( !(def0 == opt0) ) ;
-  BOOST_CHECK (   def0 <  opt0  ) ; // uninitialized is always less than initialized
-  BOOST_CHECK ( !(def0 >  opt0) ) ;
-  BOOST_CHECK (   def0 <= opt0  ) ;
-  BOOST_CHECK ( !(def0 >= opt0) ) ;
+  BOOST_TEST (   def0 != opt0  ) ; // uninitialized is never equal to initialized
+  BOOST_TEST ( !(def0 == opt0) ) ;
+  BOOST_TEST (   def0 <  opt0  ) ; // uninitialized is always less than initialized
+  BOOST_TEST ( !(def0 >  opt0) ) ;
+  BOOST_TEST (   def0 <= opt0  ) ;
+  BOOST_TEST ( !(def0 >= opt0) ) ;

  // Check when only rhs is uninitialized.
-  BOOST_CHECK (   opt0 != def0  ) ; // initialized is never equal to uninitialized
-  BOOST_CHECK ( !(opt0 == def0) ) ;
-  BOOST_CHECK ( !(opt0 <  def0) ) ; // initialized is never less than uninitialized
-  BOOST_CHECK (   opt0 >  def0  ) ;
-  BOOST_CHECK ( !(opt0 <= def0) ) ;
-  BOOST_CHECK (   opt0 >= opt0  ) ;
+  BOOST_TEST (   opt0 != def0  ) ; // initialized is never equal to uninitialized
+  BOOST_TEST ( !(opt0 == def0) ) ;
+  BOOST_TEST ( !(opt0 <  def0) ) ; // initialized is never less than uninitialized
+  BOOST_TEST (   opt0 >  def0  ) ;
+  BOOST_TEST ( !(opt0 <= def0) ) ;
+  BOOST_TEST (   opt0 >= opt0  ) ;

  // If both are initialized, values are compared
-  BOOST_CHECK ( opt0 != opt1 ) ;
-  BOOST_CHECK ( opt1 == opt2 ) ;
-  BOOST_CHECK ( opt0 <  opt1 ) ;
-  BOOST_CHECK ( opt1 >  opt0 ) ;
-  BOOST_CHECK ( opt1 <= opt2 ) ;
-  BOOST_CHECK ( opt1 >= opt0 ) ;
+  BOOST_TEST ( opt0 != opt1 ) ;
+  BOOST_TEST ( opt1 == opt2 ) ;
+  BOOST_TEST ( opt0 <  opt1 ) ;
+  BOOST_TEST ( opt1 >  opt0 ) ;
+  BOOST_TEST ( opt1 <= opt2 ) ;
+  BOOST_TEST ( opt1 >= opt0 ) ;

  // Compare against a value directly
-  BOOST_CHECK ( opt0 == v0 ) ;
-  BOOST_CHECK ( opt0 != v1 ) ;
-  BOOST_CHECK ( opt1 == v2 ) ;
-  BOOST_CHECK ( opt0 <  v1 ) ;
-  BOOST_CHECK ( opt1 >  v0 ) ;
-  BOOST_CHECK ( opt1 <= v2 ) ;
-  BOOST_CHECK ( opt1 >= v0 ) ;
-  BOOST_CHECK ( v0 != opt1 ) ;
-  BOOST_CHECK ( v1 == opt2 ) ;
-  BOOST_CHECK ( v0 <  opt1 ) ;
-  BOOST_CHECK ( v1 >  opt0 ) ;
-  BOOST_CHECK ( v1 <= opt2 ) ;
-  BOOST_CHECK ( v1 >= opt0 ) ;
-  BOOST_CHECK (   def0 != v0  ) ;
-  BOOST_CHECK ( !(def0 == v0) ) ;
-  BOOST_CHECK (   def0 <  v0  ) ;
-  BOOST_CHECK ( !(def0 >  v0) ) ;
-  BOOST_CHECK (   def0 <= v0  ) ;
-  BOOST_CHECK ( !(def0 >= v0) ) ;
-  BOOST_CHECK (   v0 != def0  ) ;
-  BOOST_CHECK ( !(v0 == def0) ) ;
-  BOOST_CHECK ( !(v0 <  def0) ) ;
-  BOOST_CHECK (   v0 >  def0  ) ;
-  BOOST_CHECK ( !(v0 <= def0) ) ;
-  BOOST_CHECK (   v0 >= opt0  ) ;
+  BOOST_TEST ( opt0 == v0 ) ;
+  BOOST_TEST ( opt0 != v1 ) ;
+  BOOST_TEST ( opt1 == v2 ) ;
+  BOOST_TEST ( opt0 <  v1 ) ;
+  BOOST_TEST ( opt1 >  v0 ) ;
+  BOOST_TEST ( opt1 <= v2 ) ;
+  BOOST_TEST ( opt1 >= v0 ) ;
+  BOOST_TEST ( v0 != opt1 ) ;
+  BOOST_TEST ( v1 == opt2 ) ;
+  BOOST_TEST ( v0 <  opt1 ) ;
+  BOOST_TEST ( v1 >  opt0 ) ;
+  BOOST_TEST ( v1 <= opt2 ) ;
+  BOOST_TEST ( v1 >= opt0 ) ;
+  BOOST_TEST (   def0 != v0  ) ;
+  BOOST_TEST ( !(def0 == v0) ) ;
+  BOOST_TEST (   def0 <  v0  ) ;
+  BOOST_TEST ( !(def0 >  v0) ) ;
+  BOOST_TEST (   def0 <= v0  ) ;
+  BOOST_TEST ( !(def0 >= v0) ) ;
+  BOOST_TEST (   v0 != def0  ) ;
+  BOOST_TEST ( !(v0 == def0) ) ;
+  BOOST_TEST ( !(v0 <  def0) ) ;
+  BOOST_TEST (   v0 >  def0  ) ;
+  BOOST_TEST ( !(v0 <= def0) ) ;
+  BOOST_TEST (   v0 >= opt0  ) ;
 }

 template<class T>
@@ -796,16 +799,16 @@ void test_none( T const* )
  optional<T> def1(none) ;
  optional<T> non_def( T(1234) ) ;

-  BOOST_CHECK ( def0    == none ) ;
-  BOOST_CHECK ( non_def != none ) ;
-  BOOST_CHECK ( !def1           ) ;
-  BOOST_CHECK ( !(non_def <  none) ) ;
-  BOOST_CHECK (   non_def >  none  ) ;
-  BOOST_CHECK ( !(non_def <= none) ) ;
-  BOOST_CHECK (   non_def >= none  ) ;
+  BOOST_TEST ( def0    == none ) ;
+  BOOST_TEST ( non_def != none ) ;
+  BOOST_TEST ( !def1           ) ;
+  BOOST_TEST ( !(non_def <  none) ) ;
+  BOOST_TEST (   non_def >  none  ) ;
+  BOOST_TEST ( !(non_def <= none) ) ;
+  BOOST_TEST (   non_def >= none  ) ;

  non_def = none ;
-  BOOST_CHECK ( !non_def ) ;
+  BOOST_TEST ( !non_def ) ;

  test_default_implicit_construction(T(1),none);
 }
@@ -820,12 +823,12 @@ void test_arrow( T const* )
  optional<T>        oa(a) ;
  optional<T> const coa(a) ;

-  BOOST_CHECK ( coa->V() == 1234 ) ;
+  BOOST_TEST ( coa->V() == 1234 ) ;

  oa->V() = 4321 ;

-  BOOST_CHECK (     a.V() = 1234 ) ;
-  BOOST_CHECK ( (*oa).V() = 4321 ) ;
+  BOOST_TEST (     a.V() = 1234 ) ;
+  BOOST_TEST ( (*oa).V() = 4321 ) ;
 }

 void test_with_builtin_types()
@@ -833,19 +836,31 @@ void test_with_builtin_types()
  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );

  test_basics( ARG(double) );
-  test_conditional_ctor_and_get_valur_or( ARG(double) );
+  test_conditional_ctor_and_get_value_or( ARG(double) );
  test_uninitialized_access( ARG(double) );
  test_no_throwing_swap( ARG(double) );
  test_relops( ARG(double) ) ;
  test_none( ARG(double) ) ;
 }

+// MSVC < 11.0 doesn't destroy X when we call ptr->VBase::VBase.
+// Make sure that we work around this bug.
+struct VBase : virtual X
+{
+    VBase(int v) : X(v) {}
+    // MSVC 8.0 doesn't generate this correctly...
+    VBase(const VBase& other) : X(static_cast<const X&>(other)) {}
+
+    VBase& operator=(VBase const& rhs) { X::operator=(rhs); return *this; }
+};
+
 void test_with_class_type()
 {
  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );

  test_basics( ARG(X) );
-  test_conditional_ctor_and_get_valur_or( ARG(X) );
+  test_basics( ARG(VBase) );
+  test_conditional_ctor_and_get_value_or( ARG(X) );
  test_direct_value_manip( ARG(X) );
  test_uninitialized_access( ARG(X) );
  test_throwing_direct_init( ARG(X) );
@@ -859,7 +874,7 @@ void test_with_class_type()
  test_relops( ARG(X) ) ;
  test_none( ARG(X) ) ;
  test_arrow( ARG(X) ) ;
-  BOOST_CHECK ( X::count == 0 ) ;
+  BOOST_TEST ( X::count == 0 ) ;
 }

 int eat ( bool ) { return 1 ; }
@@ -878,7 +893,7 @@ void test_no_implicit_conversions_impl( T const& )
  TRACE( std::endl << BOOST_CURRENT_FUNCTION   );

  optional<T> def ;
-  BOOST_CHECK ( eat(def) == 0 ) ;
+  BOOST_TEST ( eat(def) == 0 ) ;
 }

 void test_no_implicit_conversions()
@@ -896,372 +911,6 @@ void test_no_implicit_conversions()
  test_no_implicit_conversions_impl(p);
 }

-struct A {} ;
-void test_conversions1()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION );
-
-#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
-  char c = 20 ;
-  optional<char> opt0(c);
-  optional<int> opt1(opt0);
-  BOOST_CHECK(*opt1 == static_cast<int>(c));
-#endif
-
-#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
-  float f = 21.22f ;
-  double d = f ;
-  optional<float> opt2(f) ;
-  optional<double> opt3 ;
-  opt3 = opt2 ;
-  BOOST_CHECK(*opt3 == d);
-#endif
-}
-
-void test_conversions2()
-{
-  TRACE( std::endl << BOOST_CURRENT_FUNCTION );
-
-  char c = 20 ;
-  optional<int> opt(c);
-  BOOST_CHECK( get(opt) == static_cast<int>(c));
-
-  float f = 21.22f ;
-  optional<double> opt1;
-  opt1 = f ;
-  BOOST_CHECK(*get(&opt1) == static_cast<double>(f));
-}
-
-
-namespace optional_swap_test
-{
-  class default_ctor_exception : public std::exception {} ;
-  class copy_ctor_exception : public std::exception {} ;
-  class assignment_exception : public std::exception {} ;
-
-  //
-  // Base class for swap test classes.  Its assignment should not be called, when swapping
-  // optional<T> objects.  (The default std::swap would do so.)
-  //
-  class base_class_with_forbidden_assignment
-  {
-  public:
-    base_class_with_forbidden_assignment & operator=(const base_class_with_forbidden_assignment &)
-    {
-      BOOST_CHECK(!"The assignment should not be used while swapping!");
-      throw assignment_exception();
-    }
-
-    virtual ~base_class_with_forbidden_assignment() {}
-  };
-
-  //
-  // Class without default constructor
-  //
-  class class_without_default_ctor : public base_class_with_forbidden_assignment
-  {
-  public:
-    char data;
-    explicit class_without_default_ctor(char arg) : data(arg) {}
-  };
-
-  //
-  // Class whose default constructor should not be used by optional::swap!
-  //
-  class class_whose_default_ctor_should_not_be_used : public base_class_with_forbidden_assignment
-  {
-  public:
-    char data;
-    explicit class_whose_default_ctor_should_not_be_used(char arg) : data(arg) {}
-
-    class_whose_default_ctor_should_not_be_used()
-    {
-      BOOST_CHECK(!"This default constructor should not be used while swapping!");
-      throw default_ctor_exception();
-    }
-  };
-
-  //
-  // Class whose default constructor should be used by optional::swap.
-  // Its copy constructor should be avoided!
-  //
-  class class_whose_default_ctor_should_be_used : public base_class_with_forbidden_assignment
-  {
-  public:
-    char data;
-    explicit class_whose_default_ctor_should_be_used(char arg) : data(arg) { }
-
-    class_whose_default_ctor_should_be_used() : data('\0') { }
-
-    class_whose_default_ctor_should_be_used(const class_whose_default_ctor_should_be_used &)
-    {
-      BOOST_CHECK(!"This copy constructor should not be used while swapping!");
-      throw copy_ctor_exception();
-    }
-  };
-
-  //
-  // Class template whose default constructor should be used by optional::swap.
-  // Its copy constructor should be avoided!
-  //
-  template <class T>
-  class template_whose_default_ctor_should_be_used : public base_class_with_forbidden_assignment
-  {
-  public:
-    T data;
-    explicit template_whose_default_ctor_should_be_used(T arg) : data(arg) { }
-
-    template_whose_default_ctor_should_be_used() : data('\0') { }
-
-    template_whose_default_ctor_should_be_used(const template_whose_default_ctor_should_be_used &)
-    {
-      BOOST_CHECK(!"This copy constructor should not be used while swapping!");
-      throw copy_ctor_exception();
-    }
-  };
-
-  //
-  // Class whose explicit constructor should be used by optional::swap.
-  // Its other constructors should be avoided!
-  //
-  class class_whose_explicit_ctor_should_be_used : public base_class_with_forbidden_assignment
-  {
-  public:
-    char data;
-    explicit class_whose_explicit_ctor_should_be_used(char arg) : data(arg) { }
-
-    class_whose_explicit_ctor_should_be_used()
-    {
-      BOOST_CHECK(!"This default constructor should not be used while swapping!");
-      throw default_ctor_exception();
-    }
-
-    class_whose_explicit_ctor_should_be_used(const class_whose_explicit_ctor_should_be_used &)
-    {
-      BOOST_CHECK(!"This copy constructor should not be used while swapping!");
-      throw copy_ctor_exception();
-    }
-  };
-
-  void swap(class_whose_default_ctor_should_not_be_used & lhs, class_whose_default_ctor_should_not_be_used & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  void swap(class_whose_default_ctor_should_be_used & lhs, class_whose_default_ctor_should_be_used & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  void swap(class_without_default_ctor & lhs, class_without_default_ctor & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  void swap(class_whose_explicit_ctor_should_be_used & lhs, class_whose_explicit_ctor_should_be_used & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  template <class T>
-  void swap(template_whose_default_ctor_should_be_used<T> & lhs, template_whose_default_ctor_should_be_used<T> & rhs)
-  {
-    std::swap(lhs.data, rhs.data);
-  }
-
-  //
-  // optional<T>::swap should be customized when neither the copy constructor
-  // nor the default constructor of T are supposed to be used when swapping, e.g.,
-  // for the following type T = class_whose_explicit_ctor_should_be_used.
-  //
-  void swap(boost::optional<class_whose_explicit_ctor_should_be_used> & x, boost::optional<class_whose_explicit_ctor_should_be_used> & y)
-  {
-    bool hasX = x;
-    bool hasY = y;
-
-    if ( !hasX && !hasY )
-     return;
-
-    if( !hasX )
-       x = boost::in_place('\0');
-    else if ( !hasY )
-       y = boost::in_place('\0');
-
-    optional_swap_test::swap(*x,*y);
-
-     if( !hasX )
-         y = boost::none ;
-     else if( !hasY )
-         x = boost::none ;
-  }
-
-
-} // End of namespace optional_swap_test.
-
-
-namespace boost {
-
-//
-// Compile time tweaking on whether or not swap should use the default constructor:
-//
-
-template <> struct optional_swap_should_use_default_constructor<
-  optional_swap_test::class_whose_default_ctor_should_be_used> : mpl::true_ {} ;
-
-template <> struct optional_swap_should_use_default_constructor<
-  optional_swap_test::class_whose_default_ctor_should_not_be_used> : mpl::false_ {} ;
-
-template <class T> struct optional_swap_should_use_default_constructor<
-  optional_swap_test::template_whose_default_ctor_should_be_used<T> > : mpl::true_ {} ;
-
-
-//
-// Specialization of boost::swap:
-//
-template <>
-void swap(optional<optional_swap_test::class_whose_explicit_ctor_should_be_used> & x, optional<optional_swap_test::class_whose_explicit_ctor_should_be_used> & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-} // namespace boost
-
-
-namespace std {
-
-//
-// Specializations of std::swap:
-//
-
-template <>
-void swap(optional_swap_test::class_whose_default_ctor_should_be_used & x, optional_swap_test::class_whose_default_ctor_should_be_used & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-template <>
-void swap(optional_swap_test::class_whose_default_ctor_should_not_be_used & x, optional_swap_test::class_whose_default_ctor_should_not_be_used & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-template <>
-void swap(optional_swap_test::class_without_default_ctor & x, optional_swap_test::class_without_default_ctor & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-template <>
-void swap(optional_swap_test::class_whose_explicit_ctor_should_be_used & x, optional_swap_test::class_whose_explicit_ctor_should_be_used & y)
-{
-  optional_swap_test::swap(x, y);
-}
-
-} // namespace std
-
-
-//
-// Tests whether the swap function works properly for optional<T>.
-// Assumes that T has one data member, of type char.
-// Returns true iff the test is passed.
-//
-template <class T>
-bool test_swap_function( T const* )
-{
-  const boost::unit_test::counter_t counter_before_test = boost::minimal_test::errors_counter();
-  try
-  {
-    optional<T> obj1;
-    optional<T> obj2('a');
-
-    // Self-swap should not have any effect.
-    swap(obj1, obj1);
-    swap(obj2, obj2);
-    BOOST_CHECK(!obj1);
-    BOOST_CHECK(!!obj2 && obj2->data == 'a');
-
-    // Call non-member swap.
-    swap(obj1, obj2);
-
-    // Test if obj1 and obj2 are really swapped.
-    BOOST_CHECK(!!obj1 && obj1->data == 'a');
-    BOOST_CHECK(!obj2);
-
-    // Call non-member swap one more time.
-    swap(obj1, obj2);
-
-    // Test if obj1 and obj2 are swapped back.
-    BOOST_CHECK(!obj1);
-    BOOST_CHECK(!!obj2 && obj2->data == 'a');
-  }
-  catch(const std::exception &)
-  {
-    // The swap function should not throw, for our test cases.
-    return false ;
-  }
-  return boost::minimal_test::errors_counter() == counter_before_test ;
-}
-
-//
-// Tests whether the optional<T>::swap member function works properly.
-// Assumes that T has one data member, of type char.
-// Returns true iff the test is passed.
-//
-template <class T>
-bool test_swap_member_function( T const* )
-{
-  const boost::unit_test::counter_t counter_before_test = boost::minimal_test::errors_counter();
-  try
-  {
-    optional<T> obj1;
-    optional<T> obj2('a');
-
-    // Self-swap should not have any effect.
-    obj1.swap(obj1);
-    obj2.swap(obj2);
-    BOOST_CHECK(!obj1);
-    BOOST_CHECK(!!obj2 && obj2->data == 'a');
-
-    // Call member swap.
-    obj1.swap(obj2);
-
-    // Test if obj1 and obj2 are really swapped.
-    BOOST_CHECK(!!obj1 && obj1->data == 'a');
-    BOOST_CHECK(!obj2);
-
-    // Call member swap one more time.
-    obj1.swap(obj2);
-
-    // Test if obj1 and obj2 are swapped back.
-    BOOST_CHECK(!obj1);
-    BOOST_CHECK(!!obj2 && obj2->data == 'a');
-  }
-  catch(const std::exception &)
-  {
-    // The optional<T>::swap member function should not throw, for our test cases.
-    return false ;
-  }
-  return boost::minimal_test::errors_counter() == counter_before_test ;
-}
-
-
-//
-// Tests compile time tweaking of swap, by means of
-// optional_swap_should_use_default_constructor.
-//
-void test_swap_tweaking()
-{
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::class_without_default_ctor) ) );
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::class_whose_default_ctor_should_be_used) ) );
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::class_whose_default_ctor_should_not_be_used) ) );
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::class_whose_explicit_ctor_should_be_used) ) );
-  BOOST_CHECK( test_swap_function( ARG(optional_swap_test::template_whose_default_ctor_should_be_used<char>) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::class_without_default_ctor) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::class_whose_default_ctor_should_be_used) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::class_whose_default_ctor_should_not_be_used) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::class_whose_explicit_ctor_should_be_used) ) );
-  BOOST_CHECK( test_swap_member_function( ARG(optional_swap_test::template_whose_default_ctor_should_be_used<char>) ) );
-}

 // Test for support for classes with overridden operator&
 class CustomAddressOfClass
@@ -1271,6 +920,7 @@ class CustomAddressOfClass
 public:
    CustomAddressOfClass() : n(0) {}
    CustomAddressOfClass(CustomAddressOfClass const& that) : n(that.n) {}
+    CustomAddressOfClass& operator=(CustomAddressOfClass const& rhs) { n = rhs.n; return *this; }
    explicit CustomAddressOfClass(int m) : n(m) {}
    int* operator& () { return &n; }
    bool operator== (CustomAddressOfClass const& that) const { return n == that.n; }
@@ -1279,27 +929,24 @@ public:
 void test_custom_addressof_operator()
 {
    boost::optional< CustomAddressOfClass > o1(CustomAddressOfClass(10));
-    BOOST_CHECK(!!o1);
-    BOOST_CHECK(o1.get() == CustomAddressOfClass(10));
+    BOOST_TEST(!!o1);
+    BOOST_TEST(o1.get() == CustomAddressOfClass(10));

    o1 = CustomAddressOfClass(20);
-    BOOST_CHECK(!!o1);
-    BOOST_CHECK(o1.get() == CustomAddressOfClass(20));
+    BOOST_TEST(!!o1);
+    BOOST_TEST(o1.get() == CustomAddressOfClass(20));

    o1 = boost::none;
-    BOOST_CHECK(!o1);
+    BOOST_TEST(!o1);
 }

-int test_main( int, char* [] )
+int main()
 {
  try
  {
    test_with_class_type();
    test_with_builtin_types();
    test_no_implicit_conversions();
-    test_conversions1();
-    test_conversions2();
-    test_swap_tweaking();
    test_custom_addressof_operator();
  }
  catch ( ... )
@@ -1307,7 +954,5 @@ int test_main( int, char* [] )
    BOOST_ERROR("Unexpected Exception caught!");
  }

-  return 0;
+  return boost::report_errors();
 }
-
-
@@ -0,0 +1,32 @@
+// Copyright (C) 2021 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/lib/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+template <typename U>
+struct wrapper {};
+
+template <typename /*Tag*/, typename U>
+int get(wrapper<U> const&) { return 0; }
+
+#include "boost/optional/optional.hpp"
+
+namespace boost
+{
+  struct any_type_in_boost_namespace {};
+}
+
+class tag; // user-defined tag
+
+int main()
+{
+  // the following tests if boost::get for optional<> does
+  // not interfere with the global get
+  return get<tag>(wrapper<boost::any_type_in_boost_namespace>());
+}
@@ -0,0 +1,30 @@
+// Copyright (C) 2018 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/lib/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#include "boost/core/lightweight_test.hpp"
+#include "boost/optional/optional.hpp"
+
+void test_assignment_to_empty()
+{
+  // this test used to fail on GCC 8.1.0/8.2.0/9.0.0 with -std=c++98
+  boost::optional<int> oa, ob(1);
+  BOOST_TEST(!oa);
+  BOOST_TEST(ob);
+
+  oa = ob;
+  BOOST_TEST(oa);
+}
+
+int main()
+{
+  test_assignment_to_empty();
+  return boost::report_errors();
+}
@@ -0,0 +1,83 @@
+// Copyright (C) 2014 Andrzej Krzemienski.
+// Copyright (C) 2024 Alexander Grund
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/lib/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#include "boost/optional/optional.hpp"
+
+#ifdef BOOST_BORLANDC
+#pragma hdrstop
+#endif
+
+#include "boost/core/lightweight_test.hpp"
+#include "boost/none.hpp"
+
+
+struct SemiRegular // no operator==
+{ 
+private: void operator==(SemiRegular const&) const {}
+private: void operator!=(SemiRegular const&) const {}
+};
+
+void test_equal_to_none_of_noncomparable_T()
+{
+  boost::optional<SemiRegular> i = SemiRegular();
+  boost::optional<SemiRegular> o;
+  
+  BOOST_TEST(i != boost::none);
+  BOOST_TEST(boost::none != i);
+  BOOST_TEST(o == boost::none);
+  BOOST_TEST(boost::none == o);
+}
+
+void test_comparison_to_none()
+{
+    using boost::none;
+    boost::optional<SemiRegular> i = SemiRegular();
+    // the default ordering of optional<size_t> is{ boost::none, 0, 1, 2, ... }
+    // Hence boost::none < i for any engaged i
+    // and all others operators ( ==, !=, <, <=, >, >= ) follow
+
+    BOOST_TEST(!(i == none));
+    BOOST_TEST(i != none);
+    BOOST_TEST(!(i < none));
+    BOOST_TEST(!(i <= none));
+    BOOST_TEST(i > none);
+    BOOST_TEST(i >= none);
+    // Comparison is symmetric
+    BOOST_TEST(!(none == i));
+    BOOST_TEST(none != i);
+    BOOST_TEST(none < i);
+    BOOST_TEST(none <= i);
+    BOOST_TEST(!(none > i));
+    BOOST_TEST(!(none >= i));
+
+    // An un-engaged optional is always equal to none
+    boost::optional<SemiRegular> o;
+    BOOST_TEST(o == none);
+    BOOST_TEST(!(o != none));
+    BOOST_TEST(!(o < none));
+    BOOST_TEST(o <= none);
+    BOOST_TEST(!(o > none));
+    BOOST_TEST(o >= none);
+    // Comparison is symmetric
+    BOOST_TEST(none == o);
+    BOOST_TEST(!(none != o));
+    BOOST_TEST(!(none < o));
+    BOOST_TEST(none <= o);
+    BOOST_TEST(!(none > o));
+    BOOST_TEST(none >= o);
+}
+
+int main()
+{
+  test_equal_to_none_of_noncomparable_T();
+  return boost::report_errors();
+}
@@ -1,4 +1,5 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2014, Andrzej Krzemienski.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -9,6 +10,8 @@
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
+#include <boost/core/ignore_unused.hpp>
+
 #ifdef ENABLE_TRACE
 #define TRACE(msg) std::cout << msg << std::endl ;
 #else
@@ -37,7 +40,6 @@ void assertion_failed (char const * expr, char const * func, char const * file,

 using boost::optional ;

-template<class T> inline void unused_variable ( T ) {}

 #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 using boost::swap ;
@@ -49,12 +51,14 @@ using boost::get_pointer ;
 // via the safe_bool operator.
 #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1300) ) // 1300 == VC++ 7.1
 #define BOOST_OPTIONAL_NO_NULL_COMPARE
+#else
+#define BOOST_OPTIONAL_NO_NULL_COMPARE  // Andrzej: I also disable 0 comparison everywhere
 #endif

 #define ARG(T) (static_cast< T const* >(0))

 //
-// Helper class used to verify the lifetime managment of the values held by optional
+// Helper class used to verify the lifetime management of the values held by optional
 //
 class X
 {
@@ -148,21 +152,21 @@ bool X::pending_assign  = false ;
 bool X::throw_on_copy   = false ;
 bool X::throw_on_assign = false ;

-inline void set_pending_copy           ( X const* x ) { X::pending_copy  = true  ; }
-inline void set_pending_dtor           ( X const* x ) { X::pending_dtor  = true  ; }
-inline void set_pending_assign         ( X const* x ) { X::pending_assign = true  ; }
-inline void set_throw_on_copy          ( X const* x ) { X::throw_on_copy = true  ; }
-inline void set_throw_on_assign        ( X const* x ) { X::throw_on_assign = true  ; }
-inline void reset_throw_on_copy        ( X const* x ) { X::throw_on_copy = false ; }
-inline void reset_throw_on_assign      ( X const* x ) { X::throw_on_assign = false ; }
-inline void check_is_pending_copy      ( X const* x ) { BOOST_CHECK( X::pending_copy ) ; }
-inline void check_is_pending_dtor      ( X const* x ) { BOOST_CHECK( X::pending_dtor ) ; }
-inline void check_is_pending_assign    ( X const* x ) { BOOST_CHECK( X::pending_assign ) ; }
-inline void check_is_not_pending_copy  ( X const* x ) { BOOST_CHECK( !X::pending_copy ) ; }
-inline void check_is_not_pending_dtor  ( X const* x ) { BOOST_CHECK( !X::pending_dtor ) ; }
-inline void check_is_not_pending_assign( X const* x ) { BOOST_CHECK( !X::pending_assign ) ; }
-inline void check_instance_count       ( int c, X const* x ) { BOOST_CHECK( X::count == c ) ; }
-inline int  get_instance_count         ( X const* x ) { return X::count ; }
+inline void set_pending_copy           ( X const* ) { X::pending_copy  = true  ; }
+inline void set_pending_dtor           ( X const* ) { X::pending_dtor  = true  ; }
+inline void set_pending_assign         ( X const* ) { X::pending_assign = true  ; }
+inline void set_throw_on_copy          ( X const* ) { X::throw_on_copy = true  ; }
+inline void set_throw_on_assign        ( X const* ) { X::throw_on_assign = true  ; }
+inline void reset_throw_on_copy        ( X const* ) { X::throw_on_copy = false ; }
+inline void reset_throw_on_assign      ( X const* ) { X::throw_on_assign = false ; }
+inline void check_is_pending_copy      ( X const* ) { BOOST_TEST( X::pending_copy ) ; }
+inline void check_is_pending_dtor      ( X const* ) { BOOST_TEST( X::pending_dtor ) ; }
+inline void check_is_pending_assign    ( X const* ) { BOOST_TEST( X::pending_assign ) ; }
+inline void check_is_not_pending_copy  ( X const* ) { BOOST_TEST( !X::pending_copy ) ; }
+inline void check_is_not_pending_dtor  ( X const* ) { BOOST_TEST( !X::pending_dtor ) ; }
+inline void check_is_not_pending_assign( X const* ) { BOOST_TEST( !X::pending_assign ) ; }
+inline void check_instance_count       ( int c, X const* ) { BOOST_TEST( X::count == c ) ; }
+inline int  get_instance_count         ( X const* ) { return X::count ; }

 inline void set_pending_copy           (...) {}
 inline void set_pending_dtor           (...) {}
@@ -185,21 +189,27 @@ template<class T>
 inline void check_uninitialized_const ( optional<T> const& opt )
 {
 #ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt == 0 ) ;
+  BOOST_TEST( opt == 0 ) ;
 #endif
-  BOOST_CHECK( !opt ) ;
-  BOOST_CHECK( !get_pointer(opt) ) ;
-  BOOST_CHECK( !opt.get_ptr() ) ;
+  BOOST_TEST( !opt ) ;
+  BOOST_TEST( !get_pointer(opt) ) ;
+  BOOST_TEST( !opt.get_ptr() ) ;
+  BOOST_TEST( !opt.has_value() ) ;
+  BOOST_TEST( !opt.is_initialized() ) ;
+  BOOST_TEST( opt == boost::none ) ;
 }
 template<class T>
 inline void check_uninitialized ( optional<T>& opt )
 {
 #ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt == 0 ) ;
+  BOOST_TEST( opt == 0 ) ;
 #endif
-  BOOST_CHECK( !opt ) ;
-  BOOST_CHECK( !get_pointer(opt) ) ;
-  BOOST_CHECK( !opt.get_ptr() ) ;
+  BOOST_TEST( !opt ) ;
+  BOOST_TEST( !get_pointer(opt) ) ;
+  BOOST_TEST( !opt.get_ptr() ) ;
+  BOOST_TEST( !opt.has_value() ) ;
+  BOOST_TEST( !opt.is_initialized() ) ;
+  BOOST_TEST( opt == boost::none ) ;

  check_uninitialized_const(opt);
 }
@@ -207,29 +217,35 @@ inline void check_uninitialized ( optional<T>& opt )
 template<class T>
 inline void check_initialized_const ( optional<T> const& opt )
 {
-  BOOST_CHECK( opt ) ;
+  BOOST_TEST( opt ) ;

 #ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt != 0 ) ;
+  BOOST_TEST( opt != 0 ) ;
 #endif

-  BOOST_CHECK ( !!opt ) ;
-  BOOST_CHECK ( get_pointer(opt) ) ;
-  BOOST_CHECK ( opt.get_ptr() ) ;
+  BOOST_TEST ( !!opt ) ;
+  BOOST_TEST ( get_pointer(opt) ) ;
+  BOOST_TEST ( opt.get_ptr() ) ;
+  BOOST_TEST ( opt.has_value() ) ;
+  BOOST_TEST ( opt.is_initialized() ) ;
+  BOOST_TEST ( opt != boost::none ) ;
 }

 template<class T>
 inline void check_initialized ( optional<T>& opt )
 {
-  BOOST_CHECK( opt ) ;
+  BOOST_TEST( opt ) ;

 #ifndef BOOST_OPTIONAL_NO_NULL_COMPARE
-  BOOST_CHECK( opt != 0 ) ;
+  BOOST_TEST( opt != 0 ) ;
 #endif

-  BOOST_CHECK ( !!opt ) ;
-  BOOST_CHECK ( get_pointer(opt) ) ;
-  BOOST_CHECK ( opt.get_ptr() ) ;
+  BOOST_TEST ( !!opt ) ;
+  BOOST_TEST ( get_pointer(opt) ) ;
+  BOOST_TEST ( opt.get_ptr() ) ;
+  BOOST_TEST ( opt.has_value() ) ;
+  BOOST_TEST ( opt.is_initialized() ) ;
+  BOOST_TEST ( opt != boost::none ) ;

  check_initialized_const(opt);
 }
@@ -237,12 +253,12 @@ inline void check_initialized ( optional<T>& opt )
 template<class T>
 inline void check_value_const ( optional<T> const& opt, T const& v, T const& z )
 {
-  BOOST_CHECK( *opt == v ) ;
-  BOOST_CHECK( *opt != z ) ;
-  BOOST_CHECK( opt.get() == v ) ;
-  BOOST_CHECK( opt.get() != z ) ;
-  BOOST_CHECK( (*(opt.operator->()) == v) ) ;
-  BOOST_CHECK( *get_pointer(opt) == v ) ;
+  BOOST_TEST( *opt == v ) ;
+  BOOST_TEST( *opt != z ) ;
+  BOOST_TEST( opt.get() == v ) ;
+  BOOST_TEST( opt.get() != z ) ;
+  BOOST_TEST( (*(opt.operator->()) == v) ) ;
+  BOOST_TEST( *get_pointer(opt) == v ) ;
 }

 template<class T>
@@ -254,12 +270,12 @@ inline void check_value ( optional<T>& opt, T const& v, T const& z )
  reset_throw_on_copy( ARG(T) ) ;
 #endif

-  BOOST_CHECK( *opt == v ) ;
-  BOOST_CHECK( *opt != z ) ;
-  BOOST_CHECK( opt.get() == v ) ;
-  BOOST_CHECK( opt.get() != z ) ;
-  BOOST_CHECK( (*(opt.operator->()) == v) ) ;
-  BOOST_CHECK( *get_pointer(opt) == v ) ;
+  BOOST_TEST( *opt == v ) ;
+  BOOST_TEST( *opt != z ) ;
+  BOOST_TEST( opt.get() == v ) ;
+  BOOST_TEST( opt.get() != z ) ;
+  BOOST_TEST( (*(opt.operator->()) == v) ) ;
+  BOOST_TEST( *get_pointer(opt) == v ) ;

  check_value_const(opt,v,z);
 }
@@ -0,0 +1,132 @@
+// Copyright (C) 2026, Andrzej Krzemieński.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/lib/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#include "boost/optional.hpp"
+
+#ifdef BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
+
+struct Record
+{
+  int i;
+  constexpr explicit Record(int i) : i(i) {}
+  constexpr int operator()() const { return i; }
+};
+
+struct Guard
+{
+  int i;
+  constexpr explicit Guard(int i) : i(i) {}
+  Guard(Guard&&) = delete;
+};
+
+static_assert(boost::none == boost::none, "");
+static_assert(!(boost::none != boost::none), "");
+
+namespace test_int
+{
+  constexpr boost::optional<int> oN;
+  static_assert(!oN, "");
+  static_assert(oN == boost::none, "");
+  static_assert(oN <= boost::none, "");
+  static_assert(!(oN != boost::none), "");
+  static_assert(oN == oN, "");
+  static_assert(!oN.has_value(), "");
+  static_assert(oN.value_or({}) == 0, "");
+  static_assert(oN.value_or(0) == 0, "");
+  static_assert(oN.value_or_eval(Record(9)) == 9, "");
+
+  constexpr boost::optional<int> o1 (1);
+  constexpr boost::optional<int> o2 {2};
+
+  static_assert(o1, "");
+  static_assert(o1.has_value(), "");
+  static_assert(o1 != boost::none, "");
+  static_assert(o1 != oN, "");
+  static_assert(o1 > oN, "");
+  static_assert(o1 >= oN, "");
+  static_assert(*o1 == 1, "");
+  static_assert(o1.value() == 1, "");
+  static_assert(o1.value_or(0) == 1, "");
+  static_assert(o1.value_or({}) == 1, "");
+  static_assert(o1.value_or_eval(Record(9)) == 1, "");
+  static_assert(o1 == 1, "");
+  static_assert(o2, "");
+  static_assert(o2 != o1, "");
+  static_assert(o2 > o1, "");
+
+#ifdef BOOST_OPTIONAL_CONSTEXPR_COPY
+  constexpr boost::optional<int> oNc = oN;
+  constexpr boost::optional<int> oNd = boost::none;
+  constexpr boost::optional<int> oNe = {};
+  static_assert(oNc == oN, "");
+  static_assert(oNd == oN, "");
+  static_assert(oNe == oN, "");
+
+  constexpr bool test_reset() {
+    boost::optional<int> o = 1;
+    assert(o);
+    o = boost::none;
+    assert(!o);
+    return o == boost::none;
+  }
+
+  static_assert(test_reset(), "");
+#endif
+}
+
+namespace test_record
+{
+  constexpr boost::optional<Record> rN (boost::none);
+  constexpr boost::optional<Record> r1 (Record(1));
+  constexpr boost::optional<Record> r2 (boost::in_place_init, 2);
+
+  static_assert(!rN, "");
+  static_assert(rN == boost::none, "");
+  static_assert(r1, "");
+  static_assert(r1 != boost::none, "");
+  static_assert(r2, "");
+  static_assert(rN.value_or(Record(9)).i == 9, "");
+  static_assert(r1->i == 1, "");
+  static_assert(r2.value().i == 2, "");
+}
+
+namespace test_guard
+{
+  constexpr boost::optional<Guard> g1 {boost::in_place_init, 1};
+  constexpr boost::optional<Guard> gNa {boost::none};
+  constexpr boost::optional<Guard> gNb;
+
+  static_assert(g1, "");
+  static_assert(!!g1, "");
+  static_assert(g1 != boost::none, "");
+  static_assert(!(g1 == boost::none), "");
+  static_assert(g1.has_value(), "");
+
+  static_assert(!gNa, "");
+  static_assert(!gNa.has_value(), "");
+  static_assert(gNa == boost::none, "");
+  static_assert(!(gNa != boost::none), "");
+
+  static_assert(!gNb, "");
+  static_assert(!gNb.has_value(), "");
+  static_assert(gNb == boost::none, "");
+  static_assert(!(gNb != boost::none), "");
+}
+
+namespace test_optional_ref
+{
+  constexpr int gi = 9;
+  constexpr boost::optional<const int&> iref = gi;
+  static_assert(iref, "");
+  static_assert(*iref == 9, "");
+}
+
+#endif // BOOST_OPTIONAL_USES_UNION_IMPLEMENTATION
@@ -0,0 +1,60 @@
+// Copyright (c) 2018 Andrey Semashev
+//
+// Use, modification, and distribution is subject to 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)
+
+// The test verifies that Boost.Optional copy constructors do not attempt to invoke
+// the element type initializing constructors from templated arguments
+
+#include <boost/optional/optional.hpp>
+#include <boost/core/enable_if.hpp>
+
+struct no_type
+{
+    char data;
+};
+
+struct yes_type
+{
+    char data[2];
+};
+
+template< unsigned int Size >
+struct size_tag {};
+
+template< typename T, typename U >
+struct is_constructible
+{
+    static U& get();
+
+    template< typename T1 >
+    static yes_type check_helper(size_tag< sizeof(static_cast< T1 >(get())) >*);
+    template< typename T1 >
+    static no_type check_helper(...);
+
+    static const bool value = sizeof(check_helper< T >(0)) == sizeof(yes_type);
+};
+
+template< typename T >
+class wrapper
+{
+public:
+    wrapper() {}
+    wrapper(wrapper const&) {}
+    template< typename U >
+    wrapper(U const&, typename boost::enable_if_c< is_constructible< T, U >::value, int >::type = 0) {}
+};
+
+inline boost::optional< wrapper< int > > foo()
+{
+    return boost::optional< wrapper< int > >();
+}
+
+int main()
+{
+    // Invokes boost::optional copy constructor. Should not invoke wrapper constructor from U.
+    boost::optional< wrapper< int > > res = foo();
+    (void)res;
+    return 0;
+}
@@ -0,0 +1,111 @@
+// Copyright (C) 2014 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/lib/optional for documentation.
+//
+// You are welcome to contact the author at: akrzemi1@gmail.com
+
+
+#include "boost/optional/optional.hpp"
+
+#ifdef BOOST_BORLANDC
+#pragma hdrstop
+#endif
+
+#include "boost/core/lightweight_test.hpp"
+
+using boost::optional;
+
+
+// testing types:
+// X is convertible to Y
+// ADeriv is convertible to ABase
+struct X
+{
+  int val;
+  explicit X(int v) : val(v) {}
+};
+
+struct Y
+{
+  int yval;
+  Y(X const& x) : yval(x.val) {}
+  friend bool operator==(Y const& l, Y const& r) { return l.yval == r.yval; }
+};
+
+struct ABase
+{
+  int val;
+  explicit ABase(int v) : val(v) {}
+  friend bool operator==(ABase const& l, ABase const& r) { return l.val == r.val; }
+};
+
+struct ADeriv : ABase
+{
+    explicit ADeriv(int v) : ABase(v) {}
+};
+
+
+template <typename T, typename U>
+void test_convert_optional_U_to_optional_T_for()
+{
+#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
+  {
+    optional<U> ou(U(8));
+    optional<T> ot1(ou);
+    BOOST_TEST(ot1);
+    BOOST_TEST(*ot1 == T(*ou));
+  }
+#endif
+
+#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
+  {
+    optional<U> ou(U(8));
+    optional<T> ot2;
+    ot2 = ou;
+    BOOST_TEST(ot2);
+    BOOST_TEST(*ot2 == T(*ou));
+  }
+#endif
+}
+
+void test_convert_optional_U_to_optional_T()
+{
+  test_convert_optional_U_to_optional_T_for<Y, X>();
+  test_convert_optional_U_to_optional_T_for<ABase, ADeriv>();
+  test_convert_optional_U_to_optional_T_for<long, short>();
+  test_convert_optional_U_to_optional_T_for<double, float>();
+}
+
+template <typename T, typename U>
+void test_convert_U_to_optional_T_for()
+{
+  U u(8);
+  optional<T> ot1(u);
+  BOOST_TEST(ot1);
+  BOOST_TEST(*ot1 == T(u));
+  
+  optional<T> ot2;
+  ot2 = u;
+  BOOST_TEST(ot2);
+  BOOST_TEST(*ot2 == T(u));
+}
+
+void test_convert_U_to_optional_T()
+{
+  test_convert_U_to_optional_T_for<Y, X>();
+  test_convert_U_to_optional_T_for<ABase, ADeriv>();
+  test_convert_U_to_optional_T_for<long, short>();
+  test_convert_U_to_optional_T_for<double, float>();
+}
+
+int main()
+{
+  test_convert_optional_U_to_optional_T();
+  test_convert_U_to_optional_T();
+  
+  return boost::report_errors();
+}
@@ -0,0 +1,57 @@
+// Copyright (C) 2021 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/lib/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#include "boost/optional/optional.hpp"
+
+#include "boost/core/lightweight_test.hpp"
+#include "boost/none.hpp"
+#include "boost/type_traits/is_assignable.hpp"
+
+//#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
+
+using boost::optional;
+
+struct implicit_bool_conv
+{
+  operator bool() const { return false; }
+};
+
+struct explicit_bool_conv
+{
+  explicit operator bool() const BOOST_NOEXCEPT { return true; }
+};
+
+template <typename To, typename From>
+void test_convert_assign()
+{
+  optional<To> oi;
+  oi = From();
+  BOOST_TEST(oi);
+}
+
+void test_no_bad_assignment()
+{
+#if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800)
+  // this means that type trait `boost::is_assignable` works.
+  static_assert((boost::is_assignable<optional<bool>&, bool>::value), "ERROR");
+  static_assert((boost::is_assignable<optional<bool>&, implicit_bool_conv>::value), "ERROR");
+  static_assert((! boost::is_assignable<optional<bool>&, explicit_bool_conv>::value), "ERROR");
+#endif
+}
+
+int main()
+{
+  test_convert_assign<int, short>();
+  test_convert_assign<bool, implicit_bool_conv>();
+  test_no_bad_assignment();
+
+  return boost::report_errors();
+}
@@ -0,0 +1,72 @@
+// Copyright (C) 2014 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/lib/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#include "boost/optional/optional.hpp"
+
+#ifdef BOOST_BORLANDC
+#pragma hdrstop
+#endif
+
+#include "boost/core/lightweight_test.hpp"
+#include "boost/none.hpp"
+
+//#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
+
+using boost::optional;
+using boost::none;
+
+template <typename U>
+struct superconv
+{
+  #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+  template <typename T>
+    superconv(T&&) { static_assert(sizeof(T) == 0, "ERROR"); }
+  #else
+  template <typename T>
+    superconv(const T&) { static_assert(sizeof(T) == 0, "ERROR"); }
+  template <typename T>
+    superconv(      T&) { static_assert(sizeof(T) == 0, "ERROR"); }
+  #endif
+
+  superconv() {}
+};
+
+void test_optional_of_superconverting_T() // compile-time test
+{
+#ifndef BOOST_OPTIONAL_DETAIL_NO_IS_CONSTRUCTIBLE_TRAIT
+  superconv<optional<int> > s;
+   superconv<optional<int> > & rs = s;
+  optional<superconv<optional<int> > > os = rs;
+  (void)s;
+  (void)os;
+#endif
+}
+
+void test_optional_optional_T()
+{
+  optional<int> oi1 (1), oiN;
+  optional< optional<int> > ooi1 (oi1), ooiN(oiN);
+
+  BOOST_TEST(ooi1);
+  BOOST_TEST(*ooi1);
+  BOOST_TEST_EQ(**ooi1, 1);
+
+  BOOST_TEST(ooiN);
+  BOOST_TEST(!*ooiN);
+}
+
+int main()
+{
+    test_optional_optional_T();
+    test_optional_of_superconverting_T();
+
+    return boost::report_errors();
+}
@@ -0,0 +1,66 @@
+// Copyright 2017 Peter Dimov
+// Copyright 2017 Vinnie Falco
+// Copyright 2018 Andrzej Krzemienski
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+
+int main()
+{
+}
+
+#else
+
+#include <boost/optional.hpp>
+#include <utility>
+
+class basic_multi_buffer;
+
+class const_buffers_type // a similar declaration in boost.beast had problem
+{                        // with boost optional
+    basic_multi_buffer const* b_;
+
+    friend class basic_multi_buffer;
+
+    explicit
+    const_buffers_type(basic_multi_buffer const& b);
+
+public:
+    const_buffers_type() = delete;
+    const_buffers_type(const_buffers_type const&) = default;
+    const_buffers_type& operator=(const_buffers_type const&) = default;
+};
+
+void test_beast_example()
+{
+  // test if it even compiles
+  boost::optional< std::pair<const_buffers_type, int> > opt, opt2;
+  opt = opt2;
+  (void)opt;
+}
+
+struct NotDefaultConstructible // minimal class exposing the problem
+{
+  NotDefaultConstructible() = delete;
+};
+
+void test_assign_for_non_default_constructible()
+{
+  // test if it even compiles
+  boost::optional<NotDefaultConstructible> opt, opt2;
+  opt = opt2;
+  (void)opt;
+}
+
+int main()
+{
+  test_beast_example();
+  test_assign_for_non_default_constructible();
+}
+
+#endif
@@ -0,0 +1,390 @@
+// Copyright (C) 2014 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/lib/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#include "boost/optional/optional.hpp"
+
+#ifdef BOOST_BORLANDC
+#pragma hdrstop
+#endif
+
+#include <string>
+#include "boost/core/lightweight_test.hpp"
+#include "boost/none.hpp"
+
+//#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
+//#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
+
+using boost::optional;
+using boost::none;
+using boost::in_place_init;
+using boost::in_place_init_if;
+
+#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+class Guard
+{
+public:
+    int which_ctor;
+    Guard () : which_ctor(0) { }
+    Guard (int&, double&&) : which_ctor(1) { }
+    Guard (int&&, double&) : which_ctor(2) { }
+    Guard (int&&, double&&) : which_ctor(3) { }
+    Guard (int&, double&) : which_ctor(4) { }
+    Guard (std::string const&) : which_ctor(5) { }
+    Guard (std::string &) : which_ctor(6) { }
+    Guard (std::string &&) : which_ctor(7) { }
+private:
+    Guard(Guard&&);
+    Guard(Guard const&);
+    void operator=(Guard &&);
+    void operator=(Guard const&);
+};
+
+
+void test_emplace()
+{
+    int i = 0;
+    double d = 0.0;
+    const std::string cs;
+    std::string ms;
+    optional<Guard> o;
+    
+    o.emplace();
+    BOOST_TEST(o);
+    BOOST_TEST(0 == o->which_ctor);
+    
+    o.emplace(i, 2.0);
+    BOOST_TEST(o);
+    BOOST_TEST(1 == o->which_ctor);
+    
+    o.emplace(1, d);
+    BOOST_TEST(o);
+    BOOST_TEST(2 == o->which_ctor);
+    
+    o.emplace(1, 2.0);
+    BOOST_TEST(o);
+    BOOST_TEST(3 == o->which_ctor);
+    
+    o.emplace(i, d);
+    BOOST_TEST(o);
+    BOOST_TEST(4 == o->which_ctor);
+    
+    o.emplace(cs);
+    BOOST_TEST(o);
+    BOOST_TEST(5 == o->which_ctor);
+    
+    o.emplace(ms);
+    BOOST_TEST(o);
+    BOOST_TEST(6 == o->which_ctor);
+    
+    o.emplace(std::string());
+    BOOST_TEST(o);
+    BOOST_TEST(7 == o->which_ctor);
+}
+
+void test_in_place_ctor()
+{
+    int i = 0;
+    double d = 0.0;
+    const std::string cs;
+    std::string ms;
+        
+  {
+    optional<Guard> o (in_place_init);
+    BOOST_TEST(o);
+    BOOST_TEST(0 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init, i, 2.0);
+    BOOST_TEST(o);
+    BOOST_TEST(1 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init, 1, d);
+    BOOST_TEST(o);
+    BOOST_TEST(2 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init, 1, 2.0);
+    BOOST_TEST(o);
+    BOOST_TEST(3 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init, i, d);
+    BOOST_TEST(o);
+    BOOST_TEST(4 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init, cs);
+    BOOST_TEST(o);
+    BOOST_TEST(5 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init, ms);
+    BOOST_TEST(o);
+    BOOST_TEST(6 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init, std::string());
+    BOOST_TEST(o);
+    BOOST_TEST(7 == o->which_ctor);
+  }
+}
+
+void test_in_place_if_ctor()
+{
+    int i = 0;
+    double d = 0.0;
+    const std::string cs;
+    std::string ms;
+        
+  {
+    optional<Guard> o (in_place_init_if, true);
+    BOOST_TEST(o);
+    BOOST_TEST(0 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init_if, true, i, 2.0);
+    BOOST_TEST(o);
+    BOOST_TEST(1 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init_if, true, 1, d);
+    BOOST_TEST(o);
+    BOOST_TEST(2 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init_if, true, 1, 2.0);
+    BOOST_TEST(o);
+    BOOST_TEST(3 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init_if, true, i, d);
+    BOOST_TEST(o);
+    BOOST_TEST(4 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init_if, true, cs);
+    BOOST_TEST(o);
+    BOOST_TEST(5 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init_if, true, ms);
+    BOOST_TEST(o);
+    BOOST_TEST(6 == o->which_ctor);
+  }
+  {  
+    optional<Guard> o (in_place_init_if, true, std::string());
+    BOOST_TEST(o);
+    BOOST_TEST(7 == o->which_ctor);
+  }
+  
+  {
+    optional<Guard> o (in_place_init_if, false, 1, 2.0);
+    BOOST_TEST(!o);
+  }
+}
+
+
+#endif
+
+#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
+
+
+struct ThrowOnMove
+{
+    ThrowOnMove(ThrowOnMove&&) { throw int(); }
+    ThrowOnMove(ThrowOnMove const&) { throw int(); }
+    ThrowOnMove(int){}
+};
+
+
+void test_no_moves_on_emplacement()
+{
+    try {
+        optional<ThrowOnMove> o;
+        o.emplace(1);
+        BOOST_TEST(o);
+    } 
+    catch (...) {
+        BOOST_TEST(false);
+    }
+}
+
+void test_no_moves_on_in_place_ctor()
+{
+    try {
+        optional<ThrowOnMove> o (in_place_init, 1);
+        BOOST_TEST(o);
+        
+        optional<ThrowOnMove> p (in_place_init_if, true, 1);
+        BOOST_TEST(p);
+        
+        optional<ThrowOnMove> q (in_place_init_if, false, 1);
+        BOOST_TEST(!q);
+    } 
+    catch (...) {
+        BOOST_TEST(false);
+    }
+}
+
+#endif
+
+struct Thrower
+{
+    Thrower(bool throw_) { if (throw_) throw int(); }
+    
+private:
+    Thrower(Thrower const&);
+#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
+    Thrower(Thrower&&);
+#endif
+};
+
+void test_clear_on_throw()
+{
+    optional<Thrower> ot;
+    try {
+        ot.emplace(false);
+        BOOST_TEST(ot);
+    } catch(...) {
+        BOOST_TEST(false);
+    }
+    
+    try {
+        ot.emplace(true);
+        BOOST_TEST(false);
+    } catch(...) {
+        BOOST_TEST(!ot);
+    }
+}
+
+void test_no_assignment_on_emplacement()
+{
+    optional<const std::string> os, ot;
+    BOOST_TEST(!os);
+    os.emplace("wow");
+    BOOST_TEST(os);
+    BOOST_TEST_EQ(*os, "wow");
+    
+    BOOST_TEST(!ot);
+    ot.emplace();
+    BOOST_TEST(ot);
+    BOOST_TEST_EQ(*ot, "");
+}
+
+namespace no_rvalue_refs {
+
+class Guard
+{
+public:
+    int which_ctor;
+    Guard () : which_ctor(0) { }
+    Guard (std::string const&) : which_ctor(5) { }
+    Guard (std::string &) : which_ctor(6) { }
+private:
+    Guard(Guard const&);
+    void operator=(Guard const&);
+};
+
+void test_emplace()
+{
+    const std::string cs;
+    std::string ms;
+    optional<Guard> o;
+    
+    o.emplace();
+    BOOST_TEST(o);
+    BOOST_TEST(0 == o->which_ctor);
+    
+    o.emplace(cs);
+    BOOST_TEST(o);
+    BOOST_TEST(5 == o->which_ctor);
+    
+    o.emplace(ms);
+    BOOST_TEST(o);
+    BOOST_TEST(6 == o->which_ctor);
+}
+
+void test_in_place_ctor()
+{
+  const std::string cs;
+  std::string ms;
+  
+  {
+    optional<Guard> o (in_place_init);
+    BOOST_TEST(o);
+    BOOST_TEST(0 == o->which_ctor);
+  }
+  {
+    optional<Guard> o (in_place_init, cs);
+    BOOST_TEST(o);
+    BOOST_TEST(5 == o->which_ctor);
+  }
+  {
+    optional<Guard> o (in_place_init, ms);
+    BOOST_TEST(o);
+    BOOST_TEST(6 == o->which_ctor);
+  }
+}
+
+void test_in_place_if_ctor()
+{
+  const std::string cs;
+  std::string ms;
+  
+  {
+    optional<Guard> n (in_place_init_if, false);
+    BOOST_TEST(!n);
+    
+    optional<Guard> o (in_place_init_if, true);
+    BOOST_TEST(o);
+    BOOST_TEST(0 == o->which_ctor);
+  }
+  {
+    optional<Guard> n (in_place_init_if, false, cs);
+    BOOST_TEST(!n);
+    
+    optional<Guard> o (in_place_init_if, true, cs);
+    BOOST_TEST(o);
+    BOOST_TEST(5 == o->which_ctor);
+  }
+  {
+    optional<Guard> n (in_place_init_if, false, ms);
+    BOOST_TEST(!n);
+    
+    optional<Guard> o (in_place_init_if, true, ms);
+    BOOST_TEST(o);
+    BOOST_TEST(6 == o->which_ctor);
+  }
+}
+
+} // namespace no_rvalue_ref
+
+int main()
+{
+#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    test_emplace();
+    test_in_place_ctor();
+    test_in_place_if_ctor();
+#endif
+#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
+    test_no_moves_on_emplacement();
+    test_no_moves_on_in_place_ctor();
+#endif
+    test_clear_on_throw();
+    test_no_assignment_on_emplacement();
+    no_rvalue_refs::test_emplace();
+    no_rvalue_refs::test_in_place_ctor();
+    no_rvalue_refs::test_in_place_if_ctor();
+  
+    return boost::report_errors();
+}
@@ -0,0 +1,57 @@
+// Copyright (C) 2016 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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)
+//
+// See http://www.boost.org/lib/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#include "boost/optional/optional.hpp"
+
+#ifdef BOOST_BORLANDC
+#pragma hdrstop
+#endif
+
+#include "boost/core/lightweight_test.hpp"
+
+//#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
+//#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
+
+using boost::optional;
+
+struct Value
+{
+  explicit Value(int) {}
+};
+
+#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+template <typename T>
+void test_brace_init()
+{
+  optional<T> o = {};
+  BOOST_TEST(!o);
+}
+
+template <typename T>
+void test_brace_assign()
+{
+  optional<T> o;
+  o = {};
+  BOOST_TEST(!o);
+} 
+#endif
+
+int main()
+{
+#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+  test_brace_init<int>();
+  test_brace_init<Value>();
+  test_brace_assign<int>();
+  test_brace_assign<Value>();
+#endif
+
+  return boost::report_errors();
+}
--- a/Show More
+++ b/Show More