Merge branch 'develop'

[SVN r85883]

.github/dependabot.yml

@@ -1,11 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
-
-version: 2
-updates:
-  - package-ecosystem: "github-actions" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-        interval: "weekly"

.github/workflows/ci.yml

@@ -1,168 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-      - develop
-      - feature/**
-
-env:
-  UBSAN_OPTIONS: print_stacktrace=1
-
-jobs:
-  posix:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - toolset: gcc-12
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-22.04
-            cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined"
-            linkflags: "linkflags=--coverage -lasan -lubsan"
-            gcov_tool: "gcov-12"
-            launcher: "testing.launcher=LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libasan.so.8"
-          - toolset: gcc-11
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-22.04
-            cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined"
-            linkflags: "linkflags=--coverage -lasan -lubsan"
-            gcov_tool: "gcov-11"
-            launcher: "testing.launcher=LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libasan.so.7"
-          - toolset: clang
-            compiler: clang++
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-24.04
-            cxxflags: "cxxflags=-fsanitize=address,undefined,integer -fno-sanitize-recover=undefined"
-            linkflags: "linkflags=-fsanitize=address,undefined,integer"
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Install packages
-        if: matrix.install
-        run: sudo apt 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 10 https://github.com/boostorg/boost.git boost-root
-          cd boost-root
-          git submodule update --init --depth 10 --jobs 2 tools/boostdep tools/inspect libs/filesystem
-          python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 3" filesystem
-          rm -rf libs/$LIBRARY/*
-          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
-          python tools/boostdep/depinst/depinst.py --include benchmark --include example --include examples --include tools --git_args "--depth 10 --jobs 3" $LIBRARY
-          ./bootstrap.sh
-          ./b2 -d0 headers
-          ./b2 -j4 variant=debug tools/inspect
-
-      - name: Run tests
-        run: |
-          cd ../boost-root
-          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release "${{matrix.cxxflags}}" "${{matrix.linkflags}}" "${{matrix.launcher}}"
-          dist/bin/inspect libs/$LIBRARY
-
-      - name: Prepare coverage data
-        if: matrix.gcov_tool
-        run: |
-          mkdir -p $GITHUB_WORKSPACE/coveralls
-
-          echo -e "#!/bin/bash\nexec ${{matrix.gcov_tool}} \"\$@\"" > $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh
-          chmod +x $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh
-          wget https://github.com/linux-test-project/lcov/archive/v1.16.zip
-          unzip v1.16.zip
-          LCOV="`pwd`/lcov-1.16/bin/lcov --gcov-tool $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh"
-
-          echo "$LCOV --directory ../boost-root/bin.v2/libs/$LIBRARY/ --base-directory `pwd`/libs/$LIBRARY/test --capture --output-file $GITHUB_WORKSPACE/coveralls/coverage.info"
-          $LCOV --directory ../boost-root/bin.v2/libs/$LIBRARY/ --base-directory ../boost-root/ --capture --output-file $GITHUB_WORKSPACE/coveralls/coverage.info
-          $LCOV --remove $GITHUB_WORKSPACE/coveralls/coverage.info "/usr*" "*/$LIBRARY/test/*" ${{matrix.ignore_coverage}} "*/$LIBRARY/tests/*" "*/$LIBRARY/examples/*" "*/$LIBRARY/example/*" -o $GITHUB_WORKSPACE/coveralls/coverage.info
-
-          cd ../boost-root
-          OTHER_LIBS=`grep "submodule .*" .gitmodules | sed 's/\[submodule\ "\(.*\)"\]/"\*\/boost\/\1\.hpp" "\*\/boost\/\1\/\*"/g'| sed "/\"\*\/boost\/$LIBRARY\/\*\"/d" | sed ':a;N;$!ba;s/\n/ /g'`
-          echo $OTHER_LIBS
-          eval "$LCOV --remove $GITHUB_WORKSPACE/coveralls/coverage.info $OTHER_LIBS -o $GITHUB_WORKSPACE/coveralls/coverage.info"
-
-      - name: Coveralls
-        uses: coverallsapp/github-action@master
-        if: matrix.gcov_tool
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          path-to-lcov: ./coveralls/coverage.info
-          parallel: true
-
-  windows:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - toolset: msvc
-            cxxstd: "14,17,latest"
-            addrmd: 32,64
-            os: windows-2022
-          - toolset: msvc
-            cxxstd: "14,17,latest"
-            addrmd: 32,64
-            os: windows-2025
-          - toolset: gcc
-            cxxstd: "03,11,14,17,2a"
-            addrmd: 64
-            os: windows-2025
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v6
-
-      - 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 10 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 --include benchmark --include example --include examples --include tools --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
-
-  finish:
-    needs: posix
-    runs-on: ubuntu-latest
-    steps:
-    - name: Coveralls Finished
-      uses: coverallsapp/github-action@master
-      with:
-        github-token: ${{ secrets.github_token }}
-        parallel-finished: true

CMakeLists.txt

@@ -1,27 +0,0 @@
-# Copyright 2019 Mike Dev
-# Distributed under the Boost Software License, Version 1.0.
-# See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
-
-cmake_minimum_required( VERSION 3.5...3.20 )
-project( boost_variant VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX )
-
-add_library( boost_variant INTERFACE )
-add_library( Boost::variant ALIAS boost_variant )
-
-target_include_directories( boost_variant INTERFACE include )
-
-target_link_libraries( boost_variant
-    INTERFACE
-        Boost::assert
-        Boost::config
-        Boost::container_hash
-        Boost::core
-        Boost::detail
-        Boost::integer
-        Boost::mpl
-        Boost::preprocessor
-        Boost::throw_exception
-        Boost::type_index
-        Boost::type_traits
-        Boost::utility
-)

README.md

@@ -1,16 +0,0 @@
-# [Boost.Variant](https://boost.org/libs/variant)
-Boost.Variant, part of collection of the [Boost C++ Libraries](https://github.com/boostorg). It is a safe, generic, stack-based discriminated union container, offering a simple solution for manipulating an object from a heterogeneous set of types in a uniform manner.
-
-### Test results
-
-@               | Build         | Tests coverage | More info
-----------------|-------------- | -------------- |-----------
-Develop branch: | [![CI](https://github.com/boostorg/variant/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/variant/actions/workflows/ci.yml) [![Build status](https://ci.appveyor.com/api/projects/status/bijfdoy7byfgc6e2/branch/develop?svg=true)](https://ci.appveyor.com/project/apolukhin/variant-ykfti/branch/develop) | [![Coverage Status](https://coveralls.io/repos/boostorg/variant/badge.png?branch=develop)](https://coveralls.io/r/apolukhin/variant?branch=develop) | [details...](https://regression.boost.io/develop/developer/variant.html)
-Master branch:  | [![CI](https://github.com/boostorg/variant/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/variant/actions/workflows/ci.yml) [![Build status](https://ci.appveyor.com/api/projects/status/bijfdoy7byfgc6e2/branch/master?svg=true)](https://ci.appveyor.com/project/apolukhin/variant-ykfti/branch/master) | [![Coverage Status](https://coveralls.io/repos/boostorg/variant/badge.png?branch=master)](https://coveralls.io/r/apolukhin/variant?branch=master)  | [details...](https://regression.boost.io/master/developer/variant.html)
-
-
-[Latest developer documentation](https://www.boost.org/doc/libs/develop/doc/html/variant.html)
-
-### License
-
-Distributed under the [Boost Software License, Version 1.0](https://boost.org/LICENSE_1_0.txt).

build.jam

@@ -1,34 +0,0 @@
-# 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/container_hash//boost_container_hash
-    /boost/core//boost_core
-    /boost/detail//boost_detail
-    /boost/integer//boost_integer
-    /boost/mpl//boost_mpl
-    /boost/preprocessor//boost_preprocessor
-    /boost/throw_exception//boost_throw_exception
-    /boost/type_index//boost_type_index
-    /boost/type_traits//boost_type_traits
-    /boost/utility//boost_utility ;
-
-project /boost/variant
-    : common-requirements
-        <include>include
-    ;
-
-explicit
-    [ alias boost_variant : : : : <library>$(boost_dependencies) ]
-    [ alias all : boost_variant test ]
-    ;
-
-call-if : boost-library variant
-    ;
-

doc/Jamfile.v2

@@ -1,13 +1,4 @@
-#  Boost.Variant Library doc Jamfile
-#
-#  Copyright (C) 2003, Eric Friedman, Itay Maman.
-#
-# 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)
-#
-
-project variant/doc ;
+project boost/doc ;
 import boostbook : boostbook ;
 
 boostbook variant-doc 
@@ -18,12 +9,3 @@ boostbook variant-doc
         <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
     ;
 
-###############################################################################
-alias boostdoc
-    : variant.xml
-    :
-    :
-    : ;
-explicit boostdoc ;
-alias boostrelease ;
-explicit boostrelease ;

doc/biblio.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE section PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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 id="variant.refs">
   <title>References</title>
 
@@ -115,4 +109,4 @@
     2002.
 </para>
 
-</section>
+</section>

doc/design.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE section PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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 id="variant.design">
   <title>Design Overview</title>
 
@@ -276,6 +270,29 @@
 
       </para>
 
+      <para><emphasis role="bold">Caveat</emphasis>: On most platforms, the
+        <libraryname>Type Traits</libraryname> templates
+        <code>has_nothrow_copy</code> and <code>has_nothrow_constructor</code>
+        by default return <code>false</code> for all <code>class</code> and
+        <code>struct</code> types. It is necessary therefore to provide
+        specializations of these templates as appropriate for user-defined
+        types, as demonstrated in the following:
+
+<programlisting>// ...in your code (at file scope)...
+
+namespace boost {
+
+  template &lt;&gt;
+  struct <classname>has_nothrow_copy</classname>&lt; myUDT &gt;
+    : <classname>mpl::true_</classname>
+  {
+  };
+
+}
+</programlisting>
+
+      </para>
+
       <para><emphasis role="bold">Implementation Note</emphasis>: So as to make
         the behavior of <code>variant</code> more predictable in the aftermath
         of an exception, the current implementation prefers to default-construct
@@ -307,4 +324,4 @@
 
   </section>
 
-</section>
+</section>

doc/introduction.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE section PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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 id="variant.intro">
   <title>Introduction</title>
 
@@ -138,4 +132,4 @@ int main()
 
 </section>
 
-</section>
+</section>

doc/misc.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE section PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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 id="variant.misc">
   <title>Miscellaneous Notes</title>
 
@@ -238,4 +232,4 @@ interface, and implementation of the library.</para>
 
 </section>
 
-</section>
+</section>

doc/reference/apply_visitor.xml

@@ -1,13 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-    Copyright 2013-2026 Antony Polukhin.
-
-    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)
--->
 <header name="boost/variant/apply_visitor.hpp">
   <namespace name="boost">
     <class name="apply_visitor_delayed_t">
@@ -21,9 +14,6 @@
         <simpara>See the &quot;visitor-only&quot; form of
           <code><functionname>apply_visitor</functionname></code> for a simple
           way to create <code>apply_visitor_delayed_t</code> objects.</simpara>
-        <simpara>See <code><classname>apply_visitor_delayed_cpp14_t</classname></code>
-            which is used on C++14 compatible compilers when <code>Visitor</code> has no
-            <code>result_type</code> typedef.</simpara>
       </description>
 
       <template>
@@ -47,18 +37,6 @@
 
       <method-group name="function object interface">
         <overloaded-method name="operator()">
-          <signature>
-            <template>
-              <template-type-parameter name="... Variant"/>
-            </template>
-
-            <type>result_type</type>
-            <parameter name="operand">
-              <paramtype>Variant&amp;...</paramtype>
-            </parameter>
-          </signature>
-
-
           <signature>
             <template>
               <template-type-parameter name="Variant"/>
@@ -94,63 +72,7 @@
         </overloaded-method>
       </method-group>
     </class>
-
-    <class name="apply_visitor_delayed_cpp14_t">
-      <purpose>Adapts a visitor for use as a function object.</purpose>
-      <description>
-        <simpara>Adapts the function given at construction for use as a
-          function object. This is useful, for example, when one needs to
-          operate on each element of a sequence of variant objects using a
-          standard library algorithm such as
-          <code>std::for_each</code>.</simpara>
-        <simpara>See the &quot;visitor-only&quot; form of
-          <code><functionname>apply_visitor</functionname></code> for a simple
-          way to create <code>apply_visitor_delayed_t</code> objects.</simpara>
-        <simpara>See <code><classname>apply_visitor_delayed_t</classname></code>
-            which is used when <code>Visitor</code> has <code>result_type</code>
-            typedef.</simpara>
-        <simpara>Available only if
-          compiler supports <code>decltype(auto)</code> and <code>decltype(some-expression)</code>.</simpara>
-      </description>
-
-      <template>
-        <template-type-parameter name="Visitor"/>
-      </template>
-
-      <constructor specifiers="explicit">
-        <parameter name="visitor">
-          <paramtype>Visitor &amp;</paramtype>
-        </parameter>
-
-        <effects>
-          <simpara>Constructs the function object with the given
-            visitor.</simpara>
-        </effects>
-      </constructor>
-
-      <method-group name="function object interface">
-        <overloaded-method name="operator()">
-          <signature>
-            <template>
-              <template-type-parameter name="... Variant"/>
-            </template>
-
-            <type>decltype(auto)</type>
-            <parameter name="operand">
-              <paramtype>Variant&amp;...</paramtype>
-            </parameter>
-          </signature>
-
-          <purpose>Function call operator.</purpose>
-          <description>
-            <simpara>Invokes
-            <code><functionname>apply_visitor</functionname></code> on the
-            stored visitor using the given operands.</simpara>
-          </description>
-        </overloaded-method>
-      </method-group>
-    </class>
-
+  
     <overloaded-function name="apply_visitor">
       <signature>
         <template>
@@ -164,10 +86,10 @@
           <paramtype>Visitor &amp;</paramtype>
         </parameter>
         <parameter name="operand">
-          <paramtype>Variant&amp;&amp;</paramtype>
+          <paramtype>Variant &amp;</paramtype>
         </parameter>
       </signature>
-
+      
       <signature>
         <template>
           <template-type-parameter name="Visitor"/>
@@ -180,7 +102,7 @@
           <paramtype>const Visitor &amp;</paramtype>
         </parameter>
         <parameter name="operand">
-          <paramtype>Variant&amp;&amp;</paramtype>
+          <paramtype>Variant &amp;</paramtype>
         </parameter>
       </signature>
 
@@ -191,16 +113,16 @@
           <template-type-parameter name="Variant2"/>
         </template>
 
-        <type>typename BinaryVisitor::result_type OR decltype(auto)</type>
+        <type>typename BinaryVisitor::result_type</type>
 
         <parameter name="visitor">
           <paramtype>BinaryVisitor &amp;</paramtype>
         </parameter>
         <parameter name="operand1">
-          <paramtype>Variant1&amp;&amp;</paramtype>
+          <paramtype>Variant1 &amp;</paramtype>
         </parameter>
         <parameter name="operand2">
-          <paramtype>Variant2&amp;&amp;</paramtype>
+          <paramtype>Variant2 &amp;</paramtype>
         </parameter>
       </signature>
 
@@ -211,16 +133,16 @@
           <template-type-parameter name="Variant2"/>
         </template>
 
-        <type>typename BinaryVisitor::result_type OR decltype(auto)</type>
+        <type>typename BinaryVisitor::result_type</type>
 
         <parameter name="visitor">
           <paramtype>const BinaryVisitor &amp;</paramtype>
         </parameter>
         <parameter name="operand1">
-          <paramtype>Variant1&amp;&amp;</paramtype>
+          <paramtype>Variant1 &amp;</paramtype>
         </parameter>
         <parameter name="operand2">
-          <paramtype>Variant2&amp;&amp;</paramtype>
+          <paramtype>Variant2 &amp;</paramtype>
         </parameter>
       </signature>
 
@@ -232,19 +154,19 @@
           <template-type-parameter name="Variant3"/>
         </template>
 
-        <type>typename MultiVisitor::result_type OR decltype(auto)</type>
+        <type>typename MultiVisitor::result_type</type>
 
         <parameter name="visitor">
           <paramtype>MultiVisitor &amp;</paramtype>
         </parameter>
         <parameter name="operand1">
-          <paramtype>Variant1&amp;&amp;</paramtype>
+          <paramtype>Variant1 &amp;</paramtype>
         </parameter>
         <parameter name="operand2">
-          <paramtype>Variant2&amp;&amp;</paramtype>
+          <paramtype>Variant2 &amp;</paramtype>
         </parameter>
         <parameter name="operand3">
-          <paramtype>Variant3&amp;&amp;</paramtype>
+          <paramtype>Variant3 &amp;</paramtype>
         </parameter>
         <parameter name="other_operands">
           <paramtype>...</paramtype>
@@ -259,19 +181,19 @@
           <template-type-parameter name="Variant3"/>
         </template>
 
-        <type>typename MultiVisitor::result_type OR decltype(auto)</type>
+        <type>typename MultiVisitor::result_type</type>
 
         <parameter name="visitor">
           <paramtype>const MultiVisitor &amp;</paramtype>
         </parameter>
         <parameter name="operand1">
-          <paramtype>Variant1&amp;&amp;</paramtype>
+          <paramtype>Variant1 &amp;</paramtype>
         </parameter>
         <parameter name="operand2">
-          <paramtype>Variant2&amp;&amp;</paramtype>
+          <paramtype>Variant2 &amp;</paramtype>
         </parameter>
         <parameter name="operand3">
-          <paramtype>Variant3&amp;&amp;</paramtype>
+          <paramtype>Variant3 &amp;</paramtype>
         </parameter>
         <parameter name="other_operands">
           <paramtype>...</paramtype>
@@ -290,19 +212,6 @@
         </parameter>
       </signature>
 
-
-      <signature>
-        <template>
-          <template-type-parameter name="Visitor"/>
-        </template>
-
-        <type><classname>apply_visitor_delayed_cpp14_t</classname>&lt;Visitor&gt;</type>
-
-        <parameter name="visitor">
-          <paramtype>Visitor &amp;</paramtype>
-        </parameter>
-      </signature>
-
       <purpose>
         <simpara>Allows compile-time checked type-safe application of the
         given visitor to the content of the given variant, ensuring that all
@@ -312,8 +221,7 @@
       <description>
         <simpara>The behavior of <code>apply_visitor</code> is dependent on
         the number of arguments on which it operates (i.e., other than the
-        visitor). If your compiler does not support the rvalue references or reference qualifiers then all the 
-        forwarding references from above degrade to non const lvalue reference. The function behaves as follows:
+        visitor). The function behaves as follows:
 
           <itemizedlist>
             <listitem>Overloads accepting one operand invoke the unary function
@@ -328,17 +236,13 @@
             <listitem>Overloads accepting three or more operands invoke the
               function call operator of the given visitor on the content of
               the given <code><classname>variant</classname></code>
-              operands. Maximum amount of parameters controlled by
+              operands. Maximum amount of parameters controlled by 
               <code><emphasis role="bold"><macroname>BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS</macroname></emphasis></code>
-              macro. Those functions are actually defined in a header <code>boost/variant/multivisitors.hpp</code>
-              (See <xref linkend="header.boost.variant.multivisitors_hpp"/>). That header must be manually included
-              if multi visitors are meant for use.</listitem>
+              macro. Those functions are actually defined in <xref linkend="header.boost.variant.multivisitors_hpp"/>.</listitem>
 
-            <listitem>The overloads accepting only a visitor return a
-              <classname alt="boost::apply_visitor_delayed_t">C++03 compatible generic function object</classname>
-              or
-                <classname alt="boost::apply_visitor_delayed_cpp14_t">C++14 compatible generic function object</classname>
-              that accepts either one, two or arbitrary count of arguments and invoke
+            <listitem>The overload accepting only a visitor returns a
+              <classname alt="boost::apply_visitor_delayed_t">generic function object</classname>
+              that accepts either one or two arguments and invokes
               <code><functionname>apply_visitor</functionname></code> using
               these arguments and <code>visitor</code>, thus behaving as
               specified above. (This behavior is particularly useful, for

doc/reference/bad_visit.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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)
--->
 <header name="boost/variant/bad_visit.hpp">
   <namespace name="boost">
 
@@ -26,4 +20,4 @@
     </class>
 
   </namespace>
-</header>
+</header>

doc/reference/concepts.xml

@@ -1,12 +1,4 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
-  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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)
--->
+<?xml version="1.0" encoding="utf-8" ?> 
 <section id="variant.concepts">
   <title>Concepts</title>
 
@@ -82,9 +74,7 @@
       <listitem>Must allow invocation as a function by overloading
         <code>operator()</code>, unambiguously accepting any value of type
         <code>T</code>.</listitem>
-      <listitem>Must expose inner type <code>result_type</code>. C++14 compatible compilers
-        could detect <code>result_type</code> automatically, but will stick to
-        <code>result_type</code> if it is defined. (See 
+      <listitem>Must expose inner type <code>result_type</code>. (See 
         <code><functionname>boost::visitor_ptr</functionname></code> for a
         solution to using functions as visitors.)</listitem>
       <listitem>If <code>result_type</code> is not <code>void</code>, then
@@ -133,18 +123,6 @@ public:
     }
 };</programlisting>
 
-      <para>C++14 compatible compilers detect <code>result_type</code> automatically:</para>
-
-<programlisting>
-    <classname>boost::variant</classname>&lt;int, float&gt; v;
-    // ...
-
-    <functionname>boost::apply_visitor</functionname>(
-        [](auto val) { return std::to_string(val); },
-        v
-    );
-</programlisting>
-
     </section>
   </section>
 
@@ -173,4 +151,4 @@ public:
     </itemizedlist>
   </section>
   
-</section>
+</section>

doc/reference/get.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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)
--->
 <header name="boost/variant/get.hpp">
   <namespace name="boost">
 
@@ -16,17 +10,17 @@
       </inherit>
 
       <purpose>
-        <simpara>The exception thrown in the event of a failed application of
-        <code><functionname>boost::get</functionname></code> on the given
+        <simpara>The exception thrown in	the	event	of a failed application of
+        <code><functionname>boost::get</functionname></code> on	the given
         operand value.</simpara>
       </purpose>
 
-      <method name="what" specifiers="virtual" cv="const">
-        <type>const char *</type>
+      <method	name="what"	specifiers="virtual" cv="const">
+        <type>const	char *</type>
       </method>
     </class>
 
-    <overloaded-function name="relaxed_get">
+    <overloaded-function name="get">
       <signature>
         <template>
           <template-type-parameter name="U"/>
@@ -58,7 +52,7 @@
           <paramtype>const <classname>variant</classname>&lt;T1, T2, ..., TN&gt; *</paramtype>
         </parameter>
       </signature>
-
+      
       <signature>
         <template>
           <template-type-parameter name="U"/>
@@ -91,27 +85,9 @@
         </parameter>
       </signature>
 
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U &amp;&amp;</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;&amp;</paramtype>
-        </parameter>
-      </signature>
-
       <purpose>
         <simpara>Retrieves a value of a specified type from a given
-          <code><classname>variant</classname></code>. </simpara>
-        <simpara>Unlike <functionname>strict_get</functionname> does not assert at compile time
-        that type <code>U</code> is one of the types that can be stored in variant.</simpara>
+          <code><classname>variant</classname></code>.</simpara>
       </purpose>
 
       <description>
@@ -120,11 +96,6 @@
           <code><classname>variant</classname></code>. The function succeeds
           only if the content is of the specified type <code>U</code>, with
           failure indicated as described below.</simpara>
-        <simpara><emphasis role="bold">Recomendation</emphasis>: Use
-          <functionname>get</functionname> or <functionname>strict_get</functionname> in new code.
-          <functionname>strict_get</functionname>
-          provides more compile time checks and its behavior is closer to <code>std::get</code>
-          from C++ Standard Library.</simpara>
         <simpara><emphasis role="bold">Warning</emphasis>: After either
           <code>operand</code> or its content is destroyed (e.g., when the
           given <code><classname>variant</classname></code> is assigned a
@@ -171,196 +142,5 @@
       </rationale>
     </overloaded-function>
 
-    <overloaded-function name="strict_get">
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U *</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; *</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>const U *</type>
-
-        <parameter name="operand">
-          <paramtype>const <classname>variant</classname>&lt;T1, T2, ..., TN&gt; *</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U &amp;</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>const U &amp;</type>
-
-        <parameter name="operand">
-          <paramtype>const <classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U &amp;&amp;</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;&amp;</paramtype>
-        </parameter>
-      </signature>
-
-      <purpose>
-        <simpara>Retrieves a value of a specified type from a given
-          <code><classname>variant</classname></code>.</simpara>
-      </purpose>
-
-      <description>
-        <simpara>Acts exactly like <functionname>relaxed_get</functionname> but does a compile time check
-        that type <code>U</code> is one of the types that can be stored in variant.</simpara>
-      </description>
-    </overloaded-function>
-
-    <overloaded-function name="get">
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U *</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; *</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>const U *</type>
-
-        <parameter name="operand">
-          <paramtype>const <classname>variant</classname>&lt;T1, T2, ..., TN&gt; *</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U &amp;</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>const U &amp;</type>
-
-        <parameter name="operand">
-          <paramtype>const <classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U &amp;&amp;</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;&amp;</paramtype>
-        </parameter>
-      </signature>
-
-      <purpose>
-        <simpara>Retrieves a value of a specified type from a given
-          <code><classname>variant</classname></code>.</simpara>
-      </purpose>
-
-      <description>
-        <simpara>Evaluates to <functionname>strict_get</functionname> if <code>BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT</code>
-          is not defined. If <code>BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT</code>
-          is defined then evaluates to <functionname>relaxed_get</functionname>. </simpara>
-
-        <simpara><emphasis role="bold">Recomendation</emphasis>: Use
-          <functionname>get</functionname> in new code without defining
-          <code>BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT</code>. In that way <functionname>get</functionname>
-          provides more compile time checks and its behavior is closer to <code>std::get</code>
-          from C++ Standard Library.</simpara>
-      </description>
-    </overloaded-function>
-
   </namespace>
 </header>

doc/reference/multivisitor.xml

@@ -1,18 +1,26 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2013-2026 Antony Polukhin.
-
-    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)
--->
 <header name="boost/variant/multivisitors.hpp">
   <using-namespace name="boost"/>
 
   <para>Provides declarations of <functionname>apply_visitor</functionname> for three or more
     <code><classname>variant</classname></code> parameters.</para>
 
+    <macro name="BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS">
+      <purpose>
+        <simpara>Controls maximum amount of <code><classname>variant</classname></code>
+          parameters for multi visistors. </simpara>
+      </purpose>
+
+      <description>
+        <para><emphasis role="bold">Note</emphasis>: Default amount is 4. Define it 
+          to bigger value before including &lt;boost/variant/multivisitors.hpp&gt; to
+          increase maximum amount of <code><classname>variant</classname></code>
+          parameters for <functionname>apply_visitor</functionname>.</para>
+      </description>
+    </macro>
+
   <namespace name="boost">
     <overloaded-function name="apply_visitor /*three or more variant parameters*/">
       <description>
@@ -30,19 +38,19 @@
           <template-type-parameter name="Variant3"/>
         </template>
 
-        <type>typename MultiVisitor::result_type OR decltype(auto)</type>
+        <type>typename MultiVisitor::result_type</type>
 
         <parameter name="visitor">
           <paramtype>MultiVisitor &amp;</paramtype>
         </parameter>
         <parameter name="operand1">
-          <paramtype>Variant1&amp;&amp;</paramtype>
+          <paramtype>Variant1 &amp;</paramtype>
         </parameter>
         <parameter name="operand2">
-          <paramtype>Variant2&amp;&amp;</paramtype>
+          <paramtype>Variant2 &amp;</paramtype>
         </parameter>
         <parameter name="operand3">
-          <paramtype>Variant3&amp;&amp;</paramtype>
+          <paramtype>Variant3 &amp;</paramtype>
         </parameter>
         <parameter name="other_operands">
           <paramtype>...</paramtype>
@@ -57,19 +65,19 @@
           <template-type-parameter name="Variant3"/>
         </template>
 
-        <type>typename MultiVisitor::result_type OR decltype(auto)</type>
+        <type>typename MultiVisitor::result_type</type>
 
         <parameter name="visitor">
           <paramtype>const MultiVisitor &amp;</paramtype>
         </parameter>
         <parameter name="operand1">
-          <paramtype>Variant1&amp;&amp;</paramtype>
+          <paramtype>Variant1 &amp;</paramtype>
         </parameter>
         <parameter name="operand2">
-          <paramtype>Variant2&amp;&amp;</paramtype>
+          <paramtype>Variant2 &amp;</paramtype>
         </parameter>
         <parameter name="operand3">
-          <paramtype>Variant3&amp;&amp;</paramtype>
+          <paramtype>Variant3 &amp;</paramtype>
         </parameter>
         <parameter name="other_operands">
           <paramtype>...</paramtype>

doc/reference/polymorphic_get.xml

@@ -1,326 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
-  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2013-2026 Antony Polukhin.
-
-    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)
--->
-<header name="boost/variant/polymorphic_get.hpp">
-  <namespace name="boost">
-
-    <class name="bad_polymorphic_get">
-      <inherit access="public">
-        <classname>boost::bad_get</classname>
-      </inherit>
-
-      <purpose>
-        <simpara>The exception thrown in the event of a failed application of
-        <code><functionname>boost::polymorphic_get</functionname></code> on the given
-        operand value.</simpara>
-      </purpose>
-
-      <method name="what" specifiers="virtual" cv="const">
-        <type>const char *</type>
-      </method>
-    </class>
-
-    <overloaded-function name="polymorphic_relaxed_get">
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U *</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; *</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>const U *</type>
-
-        <parameter name="operand">
-          <paramtype>const <classname>variant</classname>&lt;T1, T2, ..., TN&gt; *</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U &amp;</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>const U &amp;</type>
-
-        <parameter name="operand">
-          <paramtype>const <classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;</paramtype>
-        </parameter>
-      </signature>
-
-      <purpose>
-        <simpara>Retrieves a value of a specified type from a given
-          <code><classname>variant</classname></code>.</simpara>
-        <simpara>Unlike <functionname>polymorphic_strict_get</functionname> does not assert at compile time
-        that type <code>U</code> is one of the types that can be stored in variant.</simpara>
-      </purpose>
-
-      <description>
-        <simpara>The <code>polymorphic_get</code> function allows run-time checked,
-          type-safe retrieval of the content of the given
-          <code><classname>variant</classname></code>. The function succeeds
-          only if the content is of the specified type <code>U</code> or of type
-          derived from type <code>U</code>, with
-          failure indicated as described below.</simpara>
-        <simpara><emphasis role="bold">Recomendation</emphasis>: Use
-          <functionname>polymorphic_get</functionname> or <functionname>polymorphic_strict_get</functionname>
-          in new code.
-          <functionname>polymorphic_strict_get</functionname>
-          provides more compile time checks and its behavior is closer to <code>std::get</code>
-          from C++ Standard Library.</simpara>
-        <simpara><emphasis role="bold">Warning</emphasis>: After either
-          <code>operand</code> or its content is destroyed (e.g., when the
-          given <code><classname>variant</classname></code> is assigned a
-          value of different type), the returned reference is invalidated.
-          Thus, significant care and caution must be extended when handling
-          the returned reference.</simpara>
-      </description>
-
-      <notes>
-        <simpara>As part of its guarantee of type-safety, <code>polymorphic_get</code>
-        enforces <code>const</code>-correctness. Thus, the specified type
-        <code>U</code> must be <code>const</code>-qualified whenever
-        <code>operand</code> or its content is likewise
-        <code>const</code>-qualified. The converse, however, is not required:
-        that is, the specified type <code>U</code> may be
-        <code>const</code>-qualified even when <code>operand</code> and its
-        content are not.</simpara>
-      </notes>
-
-      <returns>
-        <simpara>If passed a pointer, <code>polymorphic_get</code> returns a pointer to
-        the value content if it is of the specified type <code>U</code> or of type
-        derived from type <code>U</code>;
-        otherwise, a null pointer is returned. If passed a reference,
-        <code>polymorphic_get</code> returns a reference to the value content if it is of
-        the specified type <code>U</code>  or of type
-          derived from type <code>U</code>; otherwise, an exception is thrown
-        (see below).</simpara>
-      </returns>
-
-      <throws>
-        <simpara>Overloads taking a
-        <code><classname>variant</classname></code> pointer will not
-        throw; the overloads taking a
-        <code><classname>variant</classname></code> reference throw
-        <code><classname>bad_polymorphic_get</classname></code> if the content is not of
-        the specified type <code>U</code>or of type
-        derived from type <code>U</code>.</simpara>
-      </throws>
-
-      <rationale>
-        <simpara>While visitation via
-        <code><functionname>apply_visitor</functionname></code>
-        is generally preferred due to its greater safety, <code>polymorphic_get</code> may
-        may be more convenient in some cases due to its straightforward
-        usage.</simpara>
-      </rationale>
-    </overloaded-function>
-
-
-
-    <overloaded-function name="polymorphic_strict_get">
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U *</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; *</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>const U *</type>
-
-        <parameter name="operand">
-          <paramtype>const <classname>variant</classname>&lt;T1, T2, ..., TN&gt; *</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U &amp;</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>const U &amp;</type>
-
-        <parameter name="operand">
-          <paramtype>const <classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;</paramtype>
-        </parameter>
-      </signature>
-
-      <purpose>
-        <simpara>Retrieves a value of a specified type from a given
-          <code><classname>variant</classname></code>.</simpara>
-      </purpose>
-
-      <description>
-        <simpara>Acts exactly like <functionname>polymorphic_relaxed_get</functionname> but does a compile time check
-        that type <code>U</code> is one of the types that can be stored in variant.</simpara>
-      </description>
-    </overloaded-function>
-
-    <overloaded-function name="polymorphic_get">
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U *</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; *</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>const U *</type>
-
-        <parameter name="operand">
-          <paramtype>const <classname>variant</classname>&lt;T1, T2, ..., TN&gt; *</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>U &amp;</type>
-
-        <parameter name="operand">
-          <paramtype><classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;</paramtype>
-        </parameter>
-      </signature>
-
-      <signature>
-        <template>
-          <template-type-parameter name="U"/>
-          <template-type-parameter name="T1"/>
-          <template-type-parameter name="T2"/>
-          <template-varargs/>
-          <template-type-parameter name="TN"/>
-        </template>
-
-        <type>const U &amp;</type>
-
-        <parameter name="operand">
-          <paramtype>const <classname>variant</classname>&lt;T1, T2, ..., TN&gt; &amp;</paramtype>
-        </parameter>
-      </signature>
-
-      <purpose>
-        <simpara>Retrieves a value of a specified type from a given
-          <code><classname>variant</classname></code>.</simpara>
-      </purpose>
-
-      <description>
-        <simpara>Evaluates to <functionname>polymorphic_strict_get</functionname>
-          if <code>BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT</code>
-          is not defined. If <code>BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT</code>
-          is defined then evaluates to <functionname>polymorphic_relaxed_get</functionname>. </simpara>
-
-        <simpara><emphasis role="bold">Recomendation</emphasis>: Use
-          <functionname>polymorphic_get</functionname> in new code without defining
-          <code>BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT</code>. In that way
-          <functionname>polymorphic_get</functionname>
-          provides more compile time checks and its behavior is closer to <code>std::get</code>
-          from C++ Standard Library.</simpara>
-      </description>
-    </overloaded-function>
-  </namespace>
-</header>

doc/reference/recursive_variant.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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)
--->
 <header name="boost/variant/recursive_variant.hpp">
   <namespace name="boost">
 
@@ -104,9 +98,14 @@
           <listitem><code>Sequence</code> must meet the requirements of
             <libraryname>MPL</libraryname>'s <emphasis>Sequence</emphasis>
             concept.</listitem>
+          <listitem>Due to standard conformance problems in several compilers,
+            <code>make_recursive_variant_over</code> may not be supported on
+            your compiler. See
+            <code><macroname>BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT</macroname></code>
+            for more information.</listitem>
         </itemizedlist>
       </description>
     </class>
 
   </namespace>
-</header>
+</header>

doc/reference/recursive_wrapper.xml

@@ -1,12 +1,6 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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)
--->
 <header name="boost/variant/recursive_wrapper.hpp">
   <namespace name="boost">
 
@@ -267,4 +261,4 @@
     </class>
 
   </namespace>
-</header>
+</header>

doc/reference/reference.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE library-reference PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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)
--->
 <library-reference xmlns:xi="http://www.w3.org/2001/XInclude">
 
   <xi:include href="concepts.xml"/>
@@ -25,7 +19,6 @@
   <xi:include href="apply_visitor.xml"/>
   <xi:include href="multivisitor.xml"/>
   <xi:include href="get.xml"/>
-  <xi:include href="polymorphic_get.xml"/>
   <xi:include href="bad_visit.xml"/>
   <xi:include href="static_visitor.xml"/>
   <xi:include href="visitor_ptr.xml"/>

doc/reference/static_visitor.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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)
--->
 <header name="boost/variant/static_visitor.hpp">
   <namespace name="boost">
 
@@ -34,4 +28,4 @@
     </class>
 
   </namespace>
-</header>
+</header>

doc/reference/variant.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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)
--->
 <header name="boost/variant/variant.hpp">
   <namespace name="boost">
     <class name="variant">
@@ -508,12 +502,6 @@
         <method name="type" cv="const">
           <type>const std::type_info &amp;</type>
 
-          <notes>
-            <simpara><code>boost::variant</code> usues Boost.TypeIndex library so actually
-            <code>const boost::typeindex::type_info &amp;</code> is returned.
-            This method is available even if RTTI is off.</simpara>
-          </notes>
-
           <returns>
             <simpara><code>typeid(x)</code>, where <code>x</code> is the the
               content of <code>*this</code>.</simpara>
@@ -521,6 +509,10 @@
 
           <throws>Will not throw.</throws>
           
+          <notes>
+            <simpara>Not available when <code>BOOST_NO_TYPEID</code> is
+              defined.</simpara>
+          </notes>
         </method>
 
       </method-group>
@@ -536,7 +528,7 @@
               <paramtype>const variant &amp;</paramtype>
             </parameter>
           </signature>
-
+          
           <signature cv="const">
             <type>void</type>
             <template>
@@ -562,60 +554,14 @@
           </requires>
 
           <returns>
-            <simpara><code>true</code> if <code>which() == rhs.which()</code>
+            <simpara><code>true</code> iff <code>which() == rhs.which()</code>
               <emphasis>and</emphasis>
               <code>content_this == content_rhs</code>, where
               <code>content_this</code> is the content of <code>*this</code>
               and <code>content_rhs</code> is the content of
               <code>rhs</code>.</simpara>
           </returns>
-
-          <throws>
-            <simpara>If <code>which() == rhs.which()</code> then may fail with
-              any exceptions arising from <code>operator==(T,T)</code>, where
-              <code>T</code> is the contained type of
-              <code>*this</code>.</simpara>
-          </throws>
-        </overloaded-method>
-
-        <overloaded-method name="operator!=" cv="const">
-          <purpose>InEquality comparison.</purpose>
-
-          <signature cv="const">
-            <type>bool</type>
-            <parameter name="rhs">
-              <paramtype>const variant &amp;</paramtype>
-            </parameter>
-          </signature>
-
-          <signature cv="const">
-            <type>void</type>
-            <template>
-              <template-type-parameter name="U"/>
-            </template>
-            <parameter>
-              <paramtype>const U &amp;</paramtype>
-            </parameter>
-          </signature>
-
-          <notes>
-            <simpara>The overload returning <code>void</code> exists only to
-              prohibit implicit conversion of the operator's right-hand side
-              to <code>variant</code>; thus, its use will (purposefully)
-              result in a compile-time error.</simpara>
-          </notes>
-
-          <requires>
-            <simpara>Every bounded type of the <code>variant</code> must
-              fulfill the requirements of the
-              <conceptname>EqualityComparable</conceptname>
-              concept.</simpara>
-          </requires>
-
-          <returns>
-            <simpara><code>true</code> if <code>!(*this == rhs)</code>.</simpara>
-          </returns>
-
+          
           <throws>
             <simpara>If <code>which() == rhs.which()</code> then may fail with
               any exceptions arising from <code>operator==(T,T)</code>, where
@@ -633,7 +579,7 @@
               <paramtype>const variant &amp;</paramtype>
             </parameter>
           </signature>
-
+          
           <signature cv="const">
             <type>void</type>
             <template>
@@ -674,147 +620,6 @@
           </throws>
         </overloaded-method>
 
-
-        <overloaded-method name="operator&gt;">
-          <purpose>GreaterThan comparison.</purpose>
-
-          <signature cv="const">
-            <type>bool</type>
-            <parameter name="rhs">
-              <paramtype>const variant &amp;</paramtype>
-            </parameter>
-          </signature>
-
-          <signature cv="const">
-            <type>void</type>
-            <template>
-              <template-type-parameter name="U"/>
-            </template>
-            <parameter>
-              <paramtype>const U &amp;</paramtype>
-            </parameter>
-          </signature>
-
-          <notes>
-            <simpara>The overload returning <code>void</code> exists only to
-              prohibit implicit conversion of the operator's right-hand side
-              to <code>variant</code>; thus, its use will (purposefully)
-              result in a compile-time error.</simpara>
-          </notes>
-
-          <requires>
-            <simpara>Every bounded type of the <code>variant</code> must
-              fulfill the requirements of the
-              <conceptname>LessThanComparable</conceptname>
-              concept.</simpara>
-          </requires>
-
-          <returns>
-            <simpara>true if <code>rhs &lt; *this</code>.</simpara>
-          </returns>
-
-          <throws>
-            <simpara>May fail with
-              any exceptions arising from <code>operator&lt;(T,T)</code>,
-              where <code>T</code> is the contained type of
-              <code>*this</code>.</simpara>
-          </throws>
-        </overloaded-method>
-
-
-        <overloaded-method name="operator&lt;=">
-          <purpose>LessThan or Equal comparison.</purpose>
-
-          <signature cv="const">
-            <type>bool</type>
-            <parameter name="rhs">
-              <paramtype>const variant &amp;</paramtype>
-            </parameter>
-          </signature>
-
-          <signature cv="const">
-            <type>void</type>
-            <template>
-              <template-type-parameter name="U"/>
-            </template>
-            <parameter>
-              <paramtype>const U &amp;</paramtype>
-            </parameter>
-          </signature>
-
-          <notes>
-            <simpara>The overload returning <code>void</code> exists only to
-              prohibit implicit conversion of the operator's right-hand side
-              to <code>variant</code>; thus, its use will (purposefully)
-              result in a compile-time error.</simpara>
-          </notes>
-
-          <requires>
-            <simpara>Every bounded type of the <code>variant</code> must
-              fulfill the requirements of the
-              <conceptname>LessThanComparable</conceptname>
-              concept.</simpara>
-          </requires>
-
-          <returns>
-            <simpara>true if <code>!(*this > rhs)</code>.</simpara>
-          </returns>
-
-          <throws>
-            <simpara>May fail with
-              any exceptions arising from <code>operator&lt;(T,T)</code>,
-              where <code>T</code> is the contained type of
-              <code>*this</code>.</simpara>
-          </throws>
-        </overloaded-method>
-
-
-        <overloaded-method name="operator&gt;=">
-          <purpose>GreaterThan or Equal comparison.</purpose>
-
-          <signature cv="const">
-            <type>bool</type>
-            <parameter name="rhs">
-              <paramtype>const variant &amp;</paramtype>
-            </parameter>
-          </signature>
-
-          <signature cv="const">
-            <type>void</type>
-            <template>
-              <template-type-parameter name="U"/>
-            </template>
-            <parameter>
-              <paramtype>const U &amp;</paramtype>
-            </parameter>
-          </signature>
-
-          <notes>
-            <simpara>The overload returning <code>void</code> exists only to
-              prohibit implicit conversion of the operator's right-hand side
-              to <code>variant</code>; thus, its use will (purposefully)
-              result in a compile-time error.</simpara>
-          </notes>
-
-          <requires>
-            <simpara>Every bounded type of the <code>variant</code> must
-              fulfill the requirements of the
-              <conceptname>LessThanComparable</conceptname>
-              concept.</simpara>
-          </requires>
-
-          <returns>
-            <simpara>true if <code>!(*this &lt; lhs)</code>.</simpara>
-          </returns>
-
-          <throws>
-            <simpara>May fail with
-              any exceptions arising from <code>operator&lt;(T,T)</code>,
-              where <code>T</code> is the contained type of
-              <code>*this</code>.</simpara>
-          </throws>
-        </overloaded-method>
-
       </method-group>
     </class>
 
@@ -951,6 +756,11 @@
           <listitem><code>Sequence</code> must meet the requirements of
             <libraryname>MPL</libraryname>'s <emphasis>Sequence</emphasis>
             concept.</listitem>
+          <listitem>Due to standard conformance problems in several compilers,
+            <code>make_variant_over</code> may not be supported on your
+            compiler. See
+            <code><macroname>BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT</macroname></code>
+            for more information.</listitem>
         </itemizedlist>
       </description>
     </class>

doc/reference/variant_fwd.xml

@@ -1,13 +1,4 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
-  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-    Copyright 2016-2026 Antony Polukhin.
-
-    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)
--->
+<?xml version="1.0" encoding="utf-8" ?> 
 <header name="boost/variant/variant_fwd.hpp">
   <using-namespace name="boost"/>
 
@@ -19,6 +10,21 @@
     class templates and the <code>boost::recursive_variant_</code> tag type.
     Also defines several preprocessor symbols, as described below.</para>
 
+  <macro name="BOOST_VARIANT_LIMIT_TYPES">
+    <purpose>
+      <simpara>Expands to the length of the
+        template parameter list for
+        <code><classname>variant</classname></code>.</simpara>
+    </purpose>
+
+    <description>
+      <para><emphasis role="bold">Note</emphasis>: Conforming
+        implementations of <code>variant</code> must allow at least ten
+        template arguments. That is, BOOST_VARIANT_LIMIT_TYPES must be greater
+        or equal to <code>10</code>.</para>
+    </description>
+  </macro>
+
   <macro name="BOOST_VARIANT_ENUM_PARAMS" kind="functionlike">
     <macro-parameter name="param"/>
 
@@ -28,19 +34,7 @@
     </purpose>
 
     <description>
-      <para> Expands to variadic template list in the following manner:
-        <code><programlisting>
-            BOOST_VARIANT_ENUM_PARAMS(T)                    => T0, TN...
-            BOOST_VARIANT_ENUM_PARAMS(class T)              => class T0, class... TN
-            BOOST_VARIANT_ENUM_PARAMS(class Something)      => class Something0, class... SomethingN
-            BOOST_VARIANT_ENUM_PARAMS(typename Something)   => typename Something0, typename... SomethingN
-            BOOST_VARIANT_ENUM_PARAMS(Something)            => Something0, SomethingN...
-            BOOST_VARIANT_ENUM_PARAMS(Something)            => Something0, SomethingN...
-        </programlisting></code>
-      </para>
-
-      <para>
-        Otherwise expands to a comma-separated sequence of length
+      <para>Expands to a comma-separated sequence of length
         <code><macroname>BOOST_VARIANT_LIMIT_TYPES</macroname></code>, where
         each element in the sequence consists of the concatenation of
         <emphasis>param</emphasis> with its zero-based index into the
@@ -65,19 +59,7 @@
     </purpose>
 
     <description>
-      <para> Expands to variadic template list in the following manner:
-        <code><programlisting>
-            BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)                    => TN...
-            BOOST_VARIANT_ENUM_SHIFTED_PARAMS(class T)              => class... TN
-            BOOST_VARIANT_ENUM_SHIFTED_PARAMS(class Something)      => class... SomethingN
-            BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename Something)   => typename... SomethingN
-            BOOST_VARIANT_ENUM_SHIFTED_PARAMS(Something)            => SomethingN...
-            BOOST_VARIANT_ENUM_SHIFTED_PARAMS(Something)            => SomethingN...
-        </programlisting></code>
-      </para>
-
-      <para>
-        Otherwise expands to a comma-separated sequence of length
+      <para>Expands to a comma-separated sequence of length
         <code><macroname>BOOST_VARIANT_LIMIT_TYPES</macroname> - 1</code>,
         where each element in the sequence consists of the concatenation of
         <emphasis>param</emphasis> with its one-based index into the sequence.
@@ -91,11 +73,31 @@
     </description>
   </macro>
 
-  <macro name="BOOST_VARIANT_DO_NOT_SPECIALIZE_STD_HASH">
+  <macro name="BOOST_VARIANT_NO_REFERENCE_SUPPORT">
     <purpose>
-      <simpara>Define this macro if you do not wish to have a <code><classname>std::hash</classname></code> specialization for
-      <code><classname>boost::variant</classname></code>.</simpara>
+      <simpara>Indicates <code><classname>variant</classname></code> does not
+        support references as bounded types.</simpara>
     </purpose>
+
+    <description>
+      <para>Defined only if <code><classname>variant</classname></code> does
+        not support references as bounded types.</para>
+    </description>
+  </macro>
+
+  <macro name="BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT">
+    <purpose>
+      <simpara>Indicates absence of support for specifying the bounded types
+        of a <code><classname>variant</classname></code> by the elements of a
+        type sequence.</simpara>
+    </purpose>
+
+    <description>
+      <para>Defined only if
+        <code><classname>make_variant_over</classname></code> and
+        <code><classname>make_recursive_variant_over</classname></code>
+        are not supported for some reason on the target compiler.</para>
+    </description>
   </macro>
 
   <macro name="BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT">
@@ -119,4 +121,4 @@
         full lambda support either.)</para>
     </description>
   </macro>
-</header>
+</header>

doc/reference/visitor_ptr.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE header PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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)
--->
 <header name="boost/variant/visitor_ptr.hpp">
   <namespace name="boost">
 
@@ -111,4 +105,4 @@
     </function>
 
   </namespace>
-</header>
+</header>

doc/tutorial/advanced.xml

@@ -1,13 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-    Copyright 2013-2026 Antony Polukhin.
-
-    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 id="variant.tutorial.advanced">
   <title>Advanced Topics</title>
 
@@ -90,6 +83,13 @@ typedef <classname>mpl::push_front</classname>&lt; types_initial, int &gt;::type
 
   </para>
 
+  <para><emphasis role="bold">Portability</emphasis>: Unfortunately, due to
+    standard conformance issues in several compilers,
+    <code>make_variant_over</code> is not universally available. On these
+    compilers the library indicates its lack of support for the syntax via the
+    definition of the preprocessor symbol
+    <code><macroname>BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT</macroname></code>.</para>
+
 </section>
 
 <section id="variant.tutorial.recursive">
@@ -390,16 +390,21 @@ struct if_visitor: public <classname>boost::static_visitor</classname>&lt;arithm
     arguments by means of <code>apply_visitor</code>:
 
 <programlisting>
-bool_like_t v0(true), v1(1), v2(2.0);
+bool_like_t v0(1), v1(true), v2(1.0);
 
 assert(
     <functionname>boost::apply_visitor</functionname>(if_visitor(), v0, v1, v2)
     ==
-    arithmetics_t(1)
+    arithmetics_t(true)
 );
 </programlisting>
   </para>
 
+  <para>Finally, we must note that multi visitation does not support 
+    &quot;delayed&quot; form of
+    <code><functionname>apply_visitor</functionname></code>.
+  </para>
+
 </section>
 
 

doc/tutorial/basic.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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 id="variant.tutorial.basic">
   <title>Basic Usage</title>
 

doc/tutorial/tutorial.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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 xmlns:xi="http://www.w3.org/2001/XInclude" id="variant.tutorial">
 
 <title>Tutorial</title>

doc/variant.xml

@@ -1,12 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
-<!--
-    Copyright 2003, Eric Friedman, Itay Maman.
-
-    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)
--->
 <library name="Variant" dirname="variant" 
          xmlns:xi="http://www.w3.org/2001/XInclude" id="variant">
 <libraryinfo>
@@ -26,10 +20,6 @@
     <holder>Itay Maman</holder>
   </copyright>
 
-  <copyright>
-    <year>2014-2026</year>
-    <holder>Antony Polukhin</holder>
-  </copyright>
   <legalnotice>
     <para>Distributed under the Boost Software License, Version 1.0.
     (See accompanying file <filename>LICENSE_1_0.txt</filename> or copy at 

include/boost/variant.hpp

@@ -14,14 +14,14 @@
 #define BOOST_VARIANT_HPP
 
 // variant "main"
-#include <boost/variant/variant.hpp>
-#include <boost/variant/recursive_variant.hpp>
-#include <boost/variant/recursive_wrapper.hpp>
+#include "boost/variant/variant.hpp"
+#include "boost/variant/recursive_variant.hpp"
+#include "boost/variant/recursive_wrapper.hpp"
 
 // common applications
-#include <boost/variant/get.hpp>
-#include <boost/variant/apply_visitor.hpp>
-#include <boost/variant/static_visitor.hpp>
-#include <boost/variant/visitor_ptr.hpp>
+#include "boost/variant/get.hpp"
+#include "boost/variant/apply_visitor.hpp"
+#include "boost/variant/static_visitor.hpp"
+#include "boost/variant/visitor_ptr.hpp"
 
 #endif // BOOST_VARIANT_HPP

include/boost/variant/apply_visitor.hpp

@@ -13,8 +13,8 @@
 #ifndef BOOST_VARIANT_APPLY_VISITOR_HPP
 #define BOOST_VARIANT_APPLY_VISITOR_HPP
 
-#include <boost/variant/detail/apply_visitor_unary.hpp>
-#include <boost/variant/detail/apply_visitor_binary.hpp>
-#include <boost/variant/detail/apply_visitor_delayed.hpp>
+#include "boost/variant/detail/apply_visitor_unary.hpp"
+#include "boost/variant/detail/apply_visitor_binary.hpp"
+#include "boost/variant/detail/apply_visitor_delayed.hpp"
 
 #endif // BOOST_VARIANT_APPLY_VISITOR_HPP

include/boost/variant/bad_visit.hpp

@@ -13,8 +13,6 @@
 #ifndef BOOST_VARIANT_BAD_VISIT_HPP
 #define BOOST_VARIANT_BAD_VISIT_HPP
 
-#include <boost/config.hpp>
-
 #include <exception>
 
 namespace boost {
@@ -25,12 +23,12 @@ namespace boost {
 // Exception thrown when a visitation attempt via apply_visitor fails due
 // to invalid visited subtype or contents.
 //
-struct BOOST_SYMBOL_VISIBLE bad_visit
+struct bad_visit
     : std::exception
 {
 public: // std::exception interface
 
-    const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE
+    virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
     {
         return "boost::bad_visit: "
                "failed visitation using boost::apply_visitor";

include/boost/variant/detail/apply_visitor_binary.hpp

@@ -3,8 +3,8 @@
 // See http://www.boost.org for updates, documentation, and revision history.
 //-----------------------------------------------------------------------------
 //
-// Copyright (c) 2002-2003 Eric Friedman
-// Copyright (c) 2014-2026 Antony Polukhin
+// Copyright (c) 2002-2003
+// Eric Friedman
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,19 +13,18 @@
 #ifndef BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP
 #define BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP
 
-#include <boost/config.hpp>
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+#include "boost/variant/detail/generic_result_type.hpp"
 
-#include <boost/variant/detail/apply_visitor_unary.hpp>
+#include "boost/variant/detail/apply_visitor_unary.hpp"
 
-#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
-#   include <boost/variant/detail/has_result_type.hpp>
+#if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
+#include "boost/utility/enable_if.hpp"
+#include "boost/mpl/not.hpp"
+#include "boost/type_traits/is_const.hpp"
 #endif
 
-#include <boost/core/enable_if.hpp>
-#include <boost/type_traits/is_lvalue_reference.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <utility>
-
 namespace boost {
 
 //////////////////////////////////////////////////////////////////////////
@@ -38,7 +37,7 @@ namespace boost {
 
 namespace detail { namespace variant {
 
-template <typename Visitor, typename Value1, bool MoveSemantics>
+template <typename Visitor, typename Value1>
 class apply_visitor_binary_invoke
 {
 public: // visitor typedefs
@@ -62,24 +61,18 @@ public: // structors
 public: // visitor interfaces
 
     template <typename Value2>
-        typename enable_if_c<MoveSemantics && is_same<Value2, Value2>::value, result_type>::type
-    operator()(Value2&& value2)
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Value2& value2)
     {
-        return visitor_(std::move(value1_), std::forward<Value2>(value2));
-    }
-
-    template <typename Value2>
-        typename disable_if_c<MoveSemantics && is_same<Value2, Value2>::value, result_type>::type
-    operator()(Value2&& value2)
-    {
-        return visitor_(value1_, std::forward<Value2>(value2));
+        return visitor_(value1_, value2);
     }
 
 private:
     apply_visitor_binary_invoke& operator=(const apply_visitor_binary_invoke&);
+
 };
 
-template <typename Visitor, typename Visitable2, bool MoveSemantics>
+template <typename Visitor, typename Visitable2>
 class apply_visitor_binary_unwrap
 {
 public: // visitor typedefs
@@ -103,26 +96,12 @@ public: // structors
 public: // visitor interfaces
 
     template <typename Value1>
-        typename enable_if_c<MoveSemantics && is_same<Value1, Value1>::value, result_type>::type
-    operator()(Value1&& value1)
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Value1& value1)
     {
         apply_visitor_binary_invoke<
               Visitor
             , Value1
-            , ! ::boost::is_lvalue_reference<Value1>::value
-            > invoker(visitor_, value1);
-
-        return boost::apply_visitor(invoker, std::move(visitable2_));
-    }
-
-    template <typename Value1>
-        typename disable_if_c<MoveSemantics && is_same<Value1, Value1>::value, result_type>::type
-    operator()(Value1&& value1)
-    {
-        apply_visitor_binary_invoke<
-              Visitor
-            , Value1
-            , ! ::boost::is_lvalue_reference<Value1>::value
             > invoker(visitor_, value1);
 
         return boost::apply_visitor(invoker, visitable2_);
@@ -139,153 +118,61 @@ private:
 // nonconst-visitor version:
 //
 
+#if !BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
+
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \
+    /**/
+
+#else // EDG-based compilers
+
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \
+    typename enable_if< \
+          mpl::not_< is_const< V > > \
+        , BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \
+        >::type \
+    /**/
+
+#endif // EDG-based compilers workaround
+
 template <typename Visitor, typename Visitable1, typename Visitable2>
-inline typename Visitor::result_type
-apply_visitor( Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2)
+inline
+    BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor)
+apply_visitor(
+      Visitor& visitor
+    , Visitable1& visitable1, Visitable2& visitable2
+    )
 {
     ::boost::detail::variant::apply_visitor_binary_unwrap<
-          Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
+          Visitor, Visitable2
         > unwrapper(visitor, visitable2);
 
-    return boost::apply_visitor(unwrapper, std::forward<Visitable1>(visitable1));
+    return boost::apply_visitor(unwrapper, visitable1);
 }
 
+#undef BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE
+
 //
 // const-visitor version:
 //
 
-
 template <typename Visitor, typename Visitable1, typename Visitable2>
-inline typename Visitor::result_type
-apply_visitor( const Visitor& visitor , Visitable1&& visitable1 , Visitable2&& visitable2)
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+          typename Visitor::result_type
+        )
+apply_visitor(
+      const Visitor& visitor
+    , Visitable1& visitable1, Visitable2& visitable2
+    )
 {
     ::boost::detail::variant::apply_visitor_binary_unwrap<
-          const Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
+          const Visitor, Visitable2
         > unwrapper(visitor, visitable2);
 
-    return boost::apply_visitor(unwrapper, std::forward<Visitable1>(visitable1));
+    return boost::apply_visitor(unwrapper, visitable1);
 }
 
-
-#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
-
-//////////////////////////////////////////////////////////////////////////
-// function template apply_visitor(visitor, visitable1, visitable2)
-//
-// C++14 part.
-//
-
-namespace detail { namespace variant {
-
-template <typename Visitor, typename Value1, bool MoveSemantics>
-class apply_visitor_binary_invoke_cpp14
-{
-    Visitor& visitor_;
-    Value1& value1_;
-
-public: // structors
-
-    apply_visitor_binary_invoke_cpp14(Visitor& visitor, Value1& value1) BOOST_NOEXCEPT
-        : visitor_(visitor)
-        , value1_(value1)
-    {
-    }
-
-public: // visitor interfaces
-
-    template <typename Value2>
-    decltype(auto) operator()(Value2&& value2, typename enable_if_c<MoveSemantics && is_same<Value2, Value2>::value, bool>::type = true)
-    {
-        return visitor_(std::move(value1_), std::forward<Value2>(value2));
-    }
-
-    template <typename Value2>
-    decltype(auto) operator()(Value2&& value2, typename disable_if_c<MoveSemantics && is_same<Value2, Value2>::value, bool>::type = true)
-    {
-        return visitor_(value1_, std::forward<Value2>(value2));
-    }
-
-private:
-    apply_visitor_binary_invoke_cpp14& operator=(const apply_visitor_binary_invoke_cpp14&);
-};
-
-template <typename Visitor, typename Visitable2, bool MoveSemantics>
-class apply_visitor_binary_unwrap_cpp14
-{
-    Visitor& visitor_;
-    Visitable2& visitable2_;
-
-public: // structors
-
-    apply_visitor_binary_unwrap_cpp14(Visitor& visitor, Visitable2& visitable2) BOOST_NOEXCEPT
-        : visitor_(visitor)
-        , visitable2_(visitable2)
-    {
-    }
-
-public: // visitor interfaces
-
-    template <typename Value1>
-    decltype(auto) operator()(Value1&& value1, typename enable_if_c<MoveSemantics && is_same<Value1, Value1>::value, bool>::type = true)
-    {
-        apply_visitor_binary_invoke_cpp14<
-              Visitor
-            , Value1
-            , ! ::boost::is_lvalue_reference<Value1>::value
-            > invoker(visitor_, value1);
-
-        return boost::apply_visitor(invoker, std::move(visitable2_));
-    }
-
-    template <typename Value1>
-    decltype(auto) operator()(Value1&& value1, typename disable_if_c<MoveSemantics && is_same<Value1, Value1>::value, bool>::type = true)
-    {
-        apply_visitor_binary_invoke_cpp14<
-              Visitor
-            , Value1
-            , ! ::boost::is_lvalue_reference<Value1>::value
-            > invoker(visitor_, value1);
-
-        return boost::apply_visitor(invoker, visitable2_);
-    }
-
-private:
-    apply_visitor_binary_unwrap_cpp14& operator=(const apply_visitor_binary_unwrap_cpp14&);
-};
-
-}} // namespace detail::variant
-
-template <typename Visitor, typename Visitable1, typename Visitable2>
-inline decltype(auto) apply_visitor(Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2,
-    typename boost::disable_if<
-        boost::detail::variant::has_result_type<Visitor>,
-        bool
-    >::type = true)
-{
-    ::boost::detail::variant::apply_visitor_binary_unwrap_cpp14<
-          Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
-        > unwrapper(visitor, visitable2);
-
-    return boost::apply_visitor(unwrapper, std::forward<Visitable1>(visitable1));
-}
-
-template <typename Visitor, typename Visitable1, typename Visitable2>
-inline decltype(auto) apply_visitor(const Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2,
-    typename boost::disable_if<
-        boost::detail::variant::has_result_type<Visitor>,
-        bool
-    >::type = true)
-{
-    ::boost::detail::variant::apply_visitor_binary_unwrap_cpp14<
-          const Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
-        > unwrapper(visitor, visitable2);
-
-    return boost::apply_visitor(unwrapper, std::forward<Visitable1>(visitable1));
-}
-
-
-#endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
-
 } // namespace boost
 
 #endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP

include/boost/variant/detail/apply_visitor_delayed.hpp

@@ -13,13 +13,10 @@
 #ifndef BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP
 #define BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP
 
-#include <boost/variant/detail/apply_visitor_unary.hpp>
-#include <boost/variant/detail/apply_visitor_binary.hpp>
-#include <boost/variant/variant_fwd.hpp>
+#include "boost/variant/detail/generic_result_type.hpp"
 
-
-#include <boost/variant/detail/has_result_type.hpp>
-#include <boost/core/enable_if.hpp>
+#include "boost/variant/detail/apply_visitor_unary.hpp"
+#include "boost/variant/detail/apply_visitor_binary.hpp"
 
 namespace boost {
 
@@ -57,11 +54,22 @@ public: // structors
     {
     }
 
-public: // N-ary visitor interface
-    template <typename... Visitables>
-    result_type operator()(Visitables&... visitables) const
+public: // unary visitor interface
+
+    template <typename Visitable>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Visitable& visitable) const
     {
-        return apply_visitor(visitor_, visitables...);
+        return apply_visitor(visitor_, visitable);
+    }
+
+public: // binary visitor interface
+
+    template <typename Visitable1, typename Visitable2>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Visitable1& visitable1, Visitable2& visitable2) const
+    {
+        return apply_visitor(visitor_, visitable1, visitable2);
     }
 
 private:
@@ -70,53 +78,11 @@ private:
 };
 
 template <typename Visitor>
-inline typename boost::enable_if<
-        boost::detail::variant::has_result_type<Visitor>,
-        apply_visitor_delayed_t<Visitor>
-    >::type apply_visitor(Visitor& visitor)
+inline apply_visitor_delayed_t<Visitor> apply_visitor(Visitor& visitor)
 {
     return apply_visitor_delayed_t<Visitor>(visitor);
 }
 
-#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO)
-
-template <typename Visitor>
-class apply_visitor_delayed_cpp14_t
-{
-private: // representation
-    Visitor& visitor_;
-
-public: // structors
-
-    explicit apply_visitor_delayed_cpp14_t(Visitor& visitor) BOOST_NOEXCEPT
-      : visitor_(visitor)
-    {
-    }
-
-public: // N-ary visitor interface
-    template <typename... Visitables>
-    decltype(auto) operator()(Visitables&... visitables) const
-    {
-        return apply_visitor(visitor_, visitables...);
-    }
-
-private:
-    apply_visitor_delayed_cpp14_t& operator=(const apply_visitor_delayed_cpp14_t&);
-
-};
-
-template <typename Visitor>
-inline  typename boost::disable_if<
-        boost::detail::variant::has_result_type<Visitor>,
-        apply_visitor_delayed_cpp14_t<Visitor>
-    >::type apply_visitor(Visitor& visitor)
-{
-    return apply_visitor_delayed_cpp14_t<Visitor>(visitor);
-}
-
-#endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO)
-
-
 } // namespace boost
 
 #endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP

include/boost/variant/detail/apply_visitor_unary.hpp

@@ -3,8 +3,8 @@
 // See http://www.boost.org for updates, documentation, and revision history.
 //-----------------------------------------------------------------------------
 //
-// Copyright (c) 2002-2003 Eric Friedman
-// Copyright (c) 2014-2026 Antony Polukhin
+// Copyright (c) 2002-2003
+// Eric Friedman
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,19 +13,14 @@
 #ifndef BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP
 #define BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP
 
-#include <boost/config.hpp>
-#include <utility>
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+#include "boost/variant/detail/generic_result_type.hpp"
 
-#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
-#   include <boost/mpl/distance.hpp>
-#   include <boost/mpl/advance.hpp>
-#   include <boost/mpl/deref.hpp>
-#   include <boost/mpl/size.hpp>
-#   include <boost/utility/declval.hpp>
-#   include <boost/core/enable_if.hpp>
-#   include <boost/type_traits/copy_cv_ref.hpp>
-#   include <boost/type_traits/remove_reference.hpp>
-#   include <boost/variant/detail/has_result_type.hpp>
+#if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
+#include "boost/utility/enable_if.hpp"
+#include "boost/mpl/not.hpp"
+#include "boost/type_traits/is_const.hpp"
 #endif
 
 namespace boost {
@@ -40,88 +35,45 @@ namespace boost {
 // nonconst-visitor version:
 //
 
+#if !BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
+
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \
+    /**/
+
+#else // EDG-based compilers
+
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \
+    typename enable_if< \
+          mpl::not_< is_const< V > > \
+        , BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \
+        >::type \
+    /**/
+
+#endif // EDG-based compilers workaround
+
 template <typename Visitor, typename Visitable>
-inline typename Visitor::result_type
-apply_visitor(Visitor& visitor, Visitable&& visitable)
+inline
+    BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor)
+apply_visitor(Visitor& visitor, Visitable& visitable)
 {
-    return std::forward<Visitable>(visitable).apply_visitor(visitor);
+    return visitable.apply_visitor(visitor);
 }
 
+#undef BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE
+
 //
 // const-visitor version:
 //
 
 template <typename Visitor, typename Visitable>
-inline typename Visitor::result_type
-apply_visitor(const Visitor& visitor, Visitable&& visitable)
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+apply_visitor(const Visitor& visitor, Visitable& visitable)
 {
-    return std::forward<Visitable>(visitable).apply_visitor(visitor);
+    return visitable.apply_visitor(visitor);
 }
 
-
-#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
-#define BOOST_VARIANT_HAS_DECLTYPE_APPLY_VISITOR_RETURN_TYPE
-
-// C++14
-namespace detail { namespace variant {
-
-// This class serves only metaprogramming purposes. none of its methods must be called at runtime!
-template <class Visitor, class Variant>
-struct result_multideduce1 {
-    typedef typename remove_reference<Variant>::type::types types;
-    typedef typename boost::mpl::begin<types>::type begin_it;
-    typedef typename boost::mpl::advance<
-        begin_it, boost::mpl::int_<boost::mpl::size<types>::type::value - 1>
-    >::type                                         last_it;
-
-    template <class It, class Dummy = void> // avoid explicit specialization in class scope
-    struct deduce_impl {
-        typedef typename boost::mpl::next<It>::type next_t;
-        typedef typename boost::mpl::deref<It>::type value_t;
-        typedef decltype(true ? boost::declval< Visitor& >()( boost::declval< copy_cv_ref_t< value_t, Variant > >() )
-                              : boost::declval< typename deduce_impl<next_t>::type >()) type;
-    };
-
-    template <class Dummy>
-    struct deduce_impl<last_it, Dummy> {
-        typedef typename boost::mpl::deref<last_it>::type value_t;
-        typedef decltype(boost::declval< Visitor& >()( boost::declval< copy_cv_ref_t< value_t, Variant > >() )) type;
-    };
-
-    typedef typename deduce_impl<begin_it>::type type;
-};
-
-template <class Visitor, class Variant>
-struct result_wrapper1
-{
-    typedef typename result_multideduce1<Visitor, Variant>::type result_type;
-
-    Visitor&& visitor_;
-    explicit result_wrapper1(Visitor&& visitor) BOOST_NOEXCEPT
-        : visitor_(std::forward<Visitor>(visitor))
-    {}
-
-    template <class T>
-    result_type operator()(T&& val) const {
-        return visitor_(std::forward<T>(val));
-    }
-};
-
-}} // namespace detail::variant
-
-template <typename Visitor, typename Visitable>
-inline decltype(auto) apply_visitor(Visitor&& visitor, Visitable&& visitable,
-    typename boost::disable_if<
-        boost::detail::variant::has_result_type<Visitor>,
-        bool
-    >::type = true)
-{
-    boost::detail::variant::result_wrapper1<Visitor, Visitable> cpp14_vis(std::forward<Visitor>(visitor));
-    return std::forward<Visitable>(visitable).apply_visitor(cpp14_vis);
-}
-
-#endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
-
 } // namespace boost
 
 #endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP

include/boost/variant/detail/backup_holder.hpp

@@ -13,8 +13,8 @@
 #ifndef BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP
 #define BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP
 
-#include <boost/config.hpp>
-#include <boost/assert.hpp>
+#include "boost/config.hpp"
+#include "boost/assert.hpp"
 
 namespace boost {
 namespace detail { namespace variant {

include/boost/variant/detail/bool_trait_def.hpp

@@ -0,0 +1,30 @@
+//-----------------------------------------------------------------------------
+// boost/variant/detail/bool_trait_def.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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)
+
+// Needed until move-related traits incorporated into type_traits library.
+// no include guards, the header is intended for multiple inclusion!
+
+// should be the last #include
+#include "boost/type_traits/detail/bool_trait_def.hpp"
+
+#define BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) \
+template< typename T > struct trait \
+    BOOST_TT_AUX_BOOL_C_BASE(C) \
+{ \
+    BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
+}; \
+/**/
+
+#define BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX(arity, name) \
+BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(arity, name) \
+/**/

include/boost/variant/detail/bool_trait_undef.hpp

@@ -0,0 +1,21 @@
+//-----------------------------------------------------------------------------
+// boost/variant/detail/bool_trait_undef.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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)
+
+// Needed until move-related traits incorporated into type_traits library.
+// no include guards, the header is intended for multiple inclusion!
+
+// should be the last #include
+#include "boost/type_traits/detail/bool_trait_undef.hpp"
+
+
+#undef BOOST_VARIANT_TT_AUX_BOOL_TRAIT_DEF1
+#undef BOOST_VARIANT_TT_AUX_TRAIT_SUFFIX

include/boost/variant/detail/cast_storage.hpp

@@ -13,7 +13,7 @@
 #ifndef BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP
 #define BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP
 
-#include <boost/config.hpp>
+#include "boost/config.hpp"
 
 namespace boost {
 namespace detail { namespace variant {

include/boost/variant/detail/config.hpp

@@ -3,8 +3,8 @@
 // See http://www.boost.org for updates, documentation, and revision history.
 //-----------------------------------------------------------------------------
 //
-// Copyright (c) 2003 Eric Friedman
-// Copyright (c) 2016-2026 Antony Polukhin
+// Copyright (c) 2003
+// Eric Friedman
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,7 +13,25 @@
 #ifndef BOOST_VARIANT_DETAIL_CONFIG_HPP
 #define BOOST_VARIANT_DETAIL_CONFIG_HPP
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING
+//
+#if BOOST_WORKAROUND(__MWERKS__, <= 0x3201) \
+ || BOOST_WORKAROUND(BOOST_INTEL, <= 700) \
+ && !defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING)
+#   define BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND
+//
+#if !defined(BOOST_NO_SFINAE) \
+ && !BOOST_WORKAROUND(BOOST_INTEL, <= 700) \
+ && !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND)
+#   define BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND
+#endif
 
 #endif // BOOST_VARIANT_DETAIL_CONFIG_HPP

include/boost/variant/detail/element_index.hpp

@@ -1,63 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost variant/detail/element_index.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2014-2026 Antony Polukhin
-//
-// 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)
-
-#ifndef BOOST_VARIANT_DETAIL_ELEMENT_INDEX_HPP
-#define BOOST_VARIANT_DETAIL_ELEMENT_INDEX_HPP
-
-#include <boost/config.hpp>
-#include <boost/variant/recursive_wrapper_fwd.hpp>
-#include <boost/variant/variant_fwd.hpp>
-
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/mpl/find_if.hpp>
-
-namespace boost { namespace detail { namespace variant {
-
-template <class VariantElement, class T>
-struct variant_element_functor :
-    boost::mpl::or_<
-        boost::is_same<VariantElement, T>,
-        boost::is_same<VariantElement, boost::recursive_wrapper<T> >,
-        boost::is_same<VariantElement, T& >
-    >
-{};
-
-template <class Types, class T>
-struct element_iterator_impl :
-    boost::mpl::find_if<
-        Types,
-        boost::mpl::or_<
-            variant_element_functor<boost::mpl::_1, T>,
-            variant_element_functor<boost::mpl::_1, typename boost::remove_cv<T>::type >
-        >
-    >
-{};
-
-template <class Variant, class T>
-struct element_iterator :
-    element_iterator_impl< typename Variant::types, typename boost::remove_reference<T>::type >
-{};
-
-template <class Variant, class T>
-struct holds_element :
-    boost::mpl::not_<
-        boost::is_same<
-            typename boost::mpl::end<typename Variant::types>::type,
-            typename element_iterator<Variant, T>::type
-        >
-    >
-{};
-
-
-}}} // namespace boost::detail::variant
-
-#endif // BOOST_VARIANT_DETAIL_ELEMENT_INDEX_HPP

include/boost/variant/detail/enable_recursive.hpp

@@ -13,33 +13,65 @@
 #ifndef BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP
 #define BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP
 
-#include <boost/variant/detail/enable_recursive_fwd.hpp>
-#include <boost/variant/variant_fwd.hpp>
+#include "boost/variant/detail/enable_recursive_fwd.hpp"
+#include "boost/variant/variant_fwd.hpp"
 
 #if !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)
-#   include <boost/mpl/apply.hpp>
-#   include <boost/mpl/eval_if.hpp>
-#   include <boost/mpl/lambda.hpp>
+#   include "boost/mpl/apply.hpp"
+#   include "boost/mpl/eval_if.hpp"
+#   include "boost/mpl/lambda.hpp"
 #endif
 
-#include <boost/variant/detail/substitute.hpp>
-#include <boost/mpl/aux_/config/ctps.hpp>
-#include <boost/mpl/bool_fwd.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/is_same.hpp>
+#include "boost/variant/detail/substitute.hpp"
+#include "boost/mpl/aux_/config/ctps.hpp"
+#include "boost/mpl/bool_fwd.hpp"
+#include "boost/mpl/if.hpp"
+#include "boost/mpl/or.hpp"
+#include "boost/type_traits/is_pointer.hpp"
+#include "boost/type_traits/is_reference.hpp"
+#include "boost/type_traits/is_same.hpp"
 
-#include <boost/variant/recursive_wrapper.hpp>
+#include "boost/variant/recursive_wrapper.hpp"
 
 namespace boost {
 namespace detail { namespace variant {
 
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
 #   define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(T,Dest,Source) \
     substitute< T , Dest , Source > \
     /**/
 
+#else // defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class template rebind1
+//
+// Limited workaround in case 'substitute' metafunction unavailable.
+//
+
+template <typename T, typename U1>
+struct rebind1
+{
+private:
+    typedef typename mpl::lambda<
+          mpl::identity<T>
+        >::type le_;
+
+public:
+    typedef typename mpl::eval_if<
+          is_same< le_, mpl::identity<T> >
+        , le_ // identity<T>
+        , mpl::apply1<le_, U1>
+        >::type type;
+};
+
+#   define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(T,Dest,Source) \
+    rebind1< T , Dest > \
+    /**/
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
 ///////////////////////////////////////////////////////////////////////////////
 // (detail) metafunction enable_recursive
 //

include/boost/variant/detail/enable_recursive_fwd.hpp

@@ -13,11 +13,11 @@
 #ifndef BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP
 #define BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP
 
-#include <boost/mpl/aux_/config/ctps.hpp>
+#include "boost/mpl/aux_/config/ctps.hpp"
 
-#include <boost/mpl/bool_fwd.hpp>
+#include "boost/mpl/bool_fwd.hpp"
 
-#   include <boost/mpl/bool.hpp>
+#   include "boost/mpl/bool.hpp"
 
 namespace boost {
 namespace detail { namespace variant {

include/boost/variant/detail/forced_return.hpp

@@ -3,8 +3,8 @@
 // See http://www.boost.org for updates, documentation, and revision history.
 //-----------------------------------------------------------------------------
 //
-// Copyright (c) 2003 Eric Friedman
-// Copyright (c) 2015-2026 Antony Polukhin
+// Copyright (c) 2003
+// Eric Friedman
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,16 +13,16 @@
 #ifndef BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP
 #define BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP
 
-#include <boost/config.hpp>
-#include <boost/assert.hpp>
+#include "boost/config.hpp"
+#include "boost/variant/detail/generic_result_type.hpp"
+#include "boost/assert.hpp"
 
-
-#ifdef BOOST_MSVC
-# pragma warning( push )
-# pragma warning( disable : 4702 ) // unreachable code
+#if !defined(BOOST_MSVC)
+#   include "boost/type_traits/remove_reference.hpp"
 #endif
 
-namespace boost { namespace detail { namespace variant {
+namespace boost {
+namespace detail { namespace variant {
 
 ///////////////////////////////////////////////////////////////////////////////
 // (detail) function template forced_return
@@ -30,23 +30,74 @@ namespace boost { namespace detail { namespace variant {
 // Logical error to permit invocation at runtime, but (artificially) satisfies
 // compile-time requirement of returning a result value.
 //
+
+#if !defined(BOOST_MSVC)                                \
+ && !defined(BOOST_NO_VOID_RETURNS)
+
+// "standard" implementation:
+
 template <typename T>
-BOOST_NORETURN inline T
+inline T forced_return()
+{
+    // logical error: should never be here! (see above)
+    BOOST_ASSERT(false);
+
+    typedef typename boost::remove_reference<T>::type basic_type;
+    basic_type* dummy = 0;
+    return *static_cast< basic_type* >(dummy);
+}
+
+template <>
+inline void forced_return<void>()
+{
+    // logical error: should never be here! (see above)
+    BOOST_ASSERT(false);
+}
+
+#elif !defined(BOOST_MSVC)
+
+// workaround implementation
+//
+// TODO: Determine the most efficient way to handle this -- as below? by
+// throwing? by recursive call to forced_return itself? etc.
+//
+
+template <typename T>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T)
 forced_return()
 {
     // logical error: should never be here! (see above)
     BOOST_ASSERT(false);
 
-    T (*dummy)() = 0;
-    (void)dummy;
-    BOOST_UNREACHABLE_RETURN(dummy());
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) (*dummy)() = 0;
+    return dummy();
 }
 
-}}} // namespace boost::detail::variant
+#else // defined(BOOST_MSVC)
 
+// msvc-specific implementation
+//
+// Leverages __declspec(noreturn) for optimized implementation.
+//
 
-#ifdef BOOST_MSVC
-# pragma warning( pop )
-#endif
+__declspec(noreturn)
+inline void forced_return_no_return() {};
+
+template <typename T>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T)
+forced_return()
+{
+    // logical error: should never be here! (see above)
+    BOOST_ASSERT(false);
+
+    forced_return_no_return();
+}
+
+#endif // BOOST_MSVC optimization
+
+}} // namespace detail::variant
+} // namespace boost
 
 #endif // BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP

include/boost/variant/detail/generic_result_type.hpp

@@ -0,0 +1,88 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/generic_result_type.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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)
+
+#ifndef BOOST_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP
+#define BOOST_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP
+
+#include "boost/config.hpp"
+
+//////////////////////////////////////////////////////////////////////////
+// (workaround) macro BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE
+//
+// On compilers with BOOST_NO_VOID_RETURNS, this macro provides a route
+// to a single syntax for dealing with template functions that may (but
+// not necessarily) return nothing (i.e. void).
+//
+// BOOST_VARIANT_AUX_RETURN_VOID provided for compilers w/ (erroneous?)
+// warnings about non-void functions not returning a value.
+//
+
+#if !defined(BOOST_NO_VOID_RETURNS)
+
+#define BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) \
+    T   \
+    /**/
+
+#define BOOST_VARIANT_AUX_RETURN_VOID  \
+    /**/
+
+#define BOOST_VARIANT_AUX_RETURN_VOID_TYPE \
+    void    \
+    /**/
+
+#else // defined(BOOST_NO_VOID_RETURNS)
+
+namespace boost {
+namespace detail { namespace variant {
+
+struct fake_return_void
+{
+    fake_return_void()
+    {
+    }
+
+    template <typename T>
+    fake_return_void(const T&)
+    {
+    }
+};
+
+template <typename T>
+struct no_void_returns_helper
+{
+    typedef T type;
+};
+
+template <>
+struct no_void_returns_helper<void>
+{
+    typedef fake_return_void type;
+};
+
+}} // namespace detail::variant
+} // namespace boost
+
+#define BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) \
+    BOOST_DEDUCED_TYPENAME                                           \
+        ::boost::detail::variant::no_void_returns_helper< T >::type  \
+    /**/
+
+#define BOOST_VARIANT_AUX_RETURN_VOID  \
+    return ::boost::detail::variant::fake_return_void()     \
+    /**/
+
+#define BOOST_VARIANT_AUX_RETURN_VOID_TYPE  \
+    ::boost::detail::variant::fake_return_void
+
+#endif // BOOST_NO_VOID_RETURNS workaround
+
+#endif // BOOST_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP

include/boost/variant/detail/has_result_type.hpp

@@ -1,37 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost variant/detail/has_result_type.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2014-2026 Antony Polukhin
-//
-// 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)
-
-#ifndef BOOST_VARIANT_DETAIL_HAS_RESULT_TYPE_HPP
-#define BOOST_VARIANT_DETAIL_HAS_RESULT_TYPE_HPP
-
-#include <boost/config.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-
-
-namespace boost { namespace detail { namespace variant {
-
-template <typename T >
-struct has_result_type {
-private:
-    typedef char                      yes;
-    typedef struct { char array[2]; } no;
-
-    template<typename C> static yes test(typename boost::remove_reference<typename C::result_type>::type*);
-    template<typename C> static no  test(...);
-
-public:
-    BOOST_STATIC_CONSTANT(bool, value = sizeof(test<T>(0)) == sizeof(yes));
-};
-
-}}} // namespace boost::detail::variant
-
-#endif // BOOST_VARIANT_DETAIL_HAS_RESULT_TYPE_HPP
-

include/boost/variant/detail/hash_variant.hpp

@@ -3,7 +3,8 @@
 // See http://www.boost.org for updates, documentation, and revision history.
 //-----------------------------------------------------------------------------
 //
-// Copyright (c) 2011-2026 Antony Polukhin
+// Copyright (c) 2011
+// Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

include/boost/variant/detail/initializer.hpp

@@ -15,21 +15,27 @@
 
 #include <new> // for placement new
 
-#include <boost/config.hpp>
+#include "boost/config.hpp"
 
-#include <boost/call_traits.hpp>
-#include <boost/detail/reference_content.hpp>
-#include <boost/variant/recursive_wrapper_fwd.hpp>
-#include <boost/variant/detail/move.hpp>
-
-#   include <boost/mpl/aux_/value_wknd.hpp>
-#   include <boost/mpl/int.hpp>
-#   include <boost/mpl/iter_fold.hpp>
-#   include <boost/mpl/next.hpp>
-#   include <boost/mpl/deref.hpp>
-#   include <boost/mpl/pair.hpp>
-#   include <boost/mpl/protect.hpp>
+#include "boost/call_traits.hpp"
+#include "boost/detail/reference_content.hpp"
+#include "boost/variant/recursive_wrapper_fwd.hpp"
+#include "boost/variant/detail/move.hpp"
 
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+#   include "boost/mpl/aux_/value_wknd.hpp"
+#   include "boost/mpl/int.hpp"
+#   include "boost/mpl/iter_fold.hpp"
+#   include "boost/mpl/next.hpp"
+#   include "boost/mpl/deref.hpp"
+#   include "boost/mpl/pair.hpp"
+#   include "boost/mpl/protect.hpp"
+#else
+#   include "boost/variant/variant_fwd.hpp"
+#   include "boost/preprocessor/cat.hpp"
+#   include "boost/preprocessor/enum.hpp"
+#   include "boost/preprocessor/repeat.hpp"
+#endif
 
 namespace boost {
 namespace detail { namespace variant {
@@ -47,6 +53,8 @@ namespace detail { namespace variant {
 // size of the variant's psuedo-variadic template parameter list.
 //
 
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
 // (detail) quoted metafunction make_initializer_node
 //
 // Exposes a pair whose first type is a node in the initializer hierarchy.
@@ -73,6 +81,7 @@ struct make_initializer_node
             typedef typename unwrap_recursive<recursive_enabled_T>::type
                 public_T;
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
             typedef boost::is_reference<public_T> 
                 is_reference_content_t;
 
@@ -83,6 +92,10 @@ struct make_initializer_node
 
             typedef typename boost::mpl::if_<is_reference_content_t, disable_overload<public_T>, public_T&& >::type 
                 param2_T;
+#else
+            typedef typename call_traits<public_T>::param_type
+                param_T;
+#endif
 
         public: // static functions
 
@@ -98,6 +111,7 @@ struct make_initializer_node
                 return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which
             }
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES            
             static int initialize(void* dest, param2_T operand)
             {
                 // This assert must newer trigger, because all the reference contents are
@@ -108,6 +122,7 @@ struct make_initializer_node
                 new(dest) value_T( boost::detail::variant::move(operand) );
                 return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which
             }
+#endif
         };
 
         friend class initializer_node;
@@ -135,6 +150,61 @@ public: // static functions
 
 };
 
+#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+    // Obsolete. Remove.
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \
+          BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \
+    /**/
+
+    // Obsolete. Remove.
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \
+        typedef typename unwrap_recursive< \
+              BOOST_PP_CAT(recursive_enabled_T,N) \
+            >::type BOOST_PP_CAT(public_T,N); \
+        typedef typename call_traits< \
+              BOOST_PP_CAT(public_T,N) \
+            >::param_type BOOST_PP_CAT(param_T,N); \
+    /**/
+
+template < BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) >
+struct preprocessor_list_initializer
+{
+public: // static functions
+
+    #define BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION(z,N,_) \
+        typedef typename unwrap_recursive< \
+              BOOST_PP_CAT(recursive_enabled_T,N) \
+            >::type BOOST_PP_CAT(public_T,N); \
+        typedef typename call_traits< \
+              BOOST_PP_CAT(public_T,N) \
+            >::param_type BOOST_PP_CAT(param_T,N); \
+        static int initialize( \
+              void* dest \
+            , BOOST_PP_CAT(param_T,N) operand \
+            ) \
+        { \
+            typedef typename boost::detail::make_reference_content< \
+                  BOOST_PP_CAT(recursive_enabled_T,N) \
+                >::type internal_T; \
+            \
+            new(dest) internal_T(operand); \
+            return (N); /*which*/ \
+        } \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION
+
+};
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
 }} // namespace detail::variant
 } // namespace boost
 
@@ -146,6 +216,8 @@ public: // static functions
 // most appropriate to the current compiler.
 //
 
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
 #define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \
     ::boost::mpl::iter_fold< \
           mpl_seq \
@@ -159,4 +231,19 @@ public: // static functions
         >::type::first \
     /**/
 
+#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+    // Obsolete. Remove.
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \
+          BOOST_VARIANT_ENUM_PARAMS(typename_base) \
+        /**/
+
+#define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \
+    ::boost::detail::variant::preprocessor_list_initializer< \
+          BOOST_VARIANT_ENUM_PARAMS(typename_base) \
+        > \
+    /**/
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
 #endif // BOOST_VARIANT_DETAIL_INITIALIZER_HPP

include/boost/variant/detail/make_variant_list.hpp

@@ -4,7 +4,7 @@
 //-----------------------------------------------------------------------------
 //
 // Copyright (c) 2002-2003 Eric Friedman, Itay Maman
-// Copyright (c) 2013-2026 Antony Polukhin
+// Copyright (c) 2013 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,13 +13,14 @@
 #ifndef BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP
 #define BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP
 
-#include <boost/variant/variant_fwd.hpp>
+#include "boost/variant/variant_fwd.hpp"
 
-#include <boost/mpl/list.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/enum.hpp>
+#include "boost/mpl/list.hpp"
+#include "boost/preprocessor/cat.hpp"
+#include "boost/preprocessor/enum.hpp"
 
-namespace boost { namespace detail { namespace variant {
+namespace boost {
+namespace detail { namespace variant {
 
 ///////////////////////////////////////////////////////////////////////////////
 // (detail) metafunction make_variant_list
@@ -31,12 +32,42 @@ namespace boost { namespace detail { namespace variant {
 // declaration workaround (below).
 //
 
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && defined(BOOST_VARIANT_USE_VARIADIC_TEMPLATES)
+
 template < typename... T >
 struct make_variant_list
 {
     typedef typename mpl::list< T... >::type type;
 };
 
-}}} // namespace boost::detail::variant
+#else
+
+template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
+struct make_variant_list
+{
+public: // metafunction result
+
+    // [Define a macro to convert any void(NN) tags to mpl::void...]
+#   define BOOST_VARIANT_AUX_CONVERT_VOID(z, N,_)  \
+        typename convert_void< BOOST_PP_CAT(T,N) >::type
+
+    // [...so that the specified types can be passed to mpl::list...]
+    typedef typename mpl::list< 
+          BOOST_PP_ENUM(
+              BOOST_VARIANT_LIMIT_TYPES
+            , BOOST_VARIANT_AUX_CONVERT_VOID
+            , _
+            )
+        >::type type;
+
+    // [...and, finally, the conversion macro can be undefined:]
+#   undef BOOST_VARIANT_AUX_CONVERT_VOID
+
+};
+
+#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+}} // namespace detail::variant
+} // namespace boost
 
 #endif // BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP

include/boost/variant/detail/move.hpp

@@ -5,7 +5,7 @@
 //
 //  Copyright (c) 2002-2003 Eric Friedman
 //  Copyright (c) 2002 by Andrei Alexandrescu
-//  Copyright (c) 2013-2026 Antony Polukhin
+//  Copyright (c) 2013 Antony Polukhin
 //
 //  Use, modification and distribution are subject to the
 //  Boost Software License, Version 1.0. (See accompanying file
@@ -20,13 +20,16 @@
 #ifndef BOOST_VARIANT_DETAIL_MOVE_HPP
 #define BOOST_VARIANT_DETAIL_MOVE_HPP
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <utility>
+#include <iterator> // for iterator_traits
+#include <new> // for placement new
+
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+#include "boost/move/move.hpp"
 
 namespace boost { namespace detail { namespace variant {
 
-using std::move;
+using boost::move;
 
 //////////////////////////////////////////////////////////////////////////
 // function template move_swap
@@ -35,11 +38,27 @@ using std::move;
 // types and on non-conforming compilers.
 //
 
+namespace move_swap_fallback {
+
+template <typename T1, typename T2>
+inline void swap(T1& lhs, T2& rhs)
+{
+    T1 tmp( boost::detail::variant::move(lhs) );
+    lhs = boost::detail::variant::move(rhs);
+    rhs = boost::detail::variant::move(tmp);
+}
+
+} // namespace move_swap_fallback
+
 template <typename T>
 inline void move_swap(T& lhs, T& rhs)
 {
-    using std::swap;
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
+    move_swap_fallback::swap(lhs, rhs);
+#else
+    using move_swap_fallback::swap;
     swap(lhs, rhs);
+#endif
 }
 
 }}} // namespace boost::detail::variant

include/boost/variant/detail/multivisitors_cpp11_based.hpp

@@ -1,212 +0,0 @@
-//  Boost.Varaint
-//  Contains multivisitors that are implemented via variadic templates and std::tuple
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2013-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).
-
-#ifndef BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP11_BASED_HPP
-#define BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP11_BASED_HPP
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#include <boost/variant/detail/apply_visitor_unary.hpp>
-#include <boost/variant/variant_fwd.hpp>
-#include <boost/type_traits/is_lvalue_reference.hpp>
-#include <boost/core/enable_if.hpp>
-
-#include <tuple>
-
-namespace boost { 
-
-namespace detail { namespace variant {
-
-    // Implementing some of the C++14 features in C++11
-    template <std::size_t... I> class index_sequence {};
-
-    template <std::size_t N, std::size_t... I> 
-    struct make_index_sequence 
-        : make_index_sequence<N-1, N-1, I...> 
-    {};
-    template <std::size_t... I> 
-    struct make_index_sequence<0, I...> 
-        : index_sequence<I...> 
-    {};
-
-    template <typename T_, bool MoveSemantics_>
-    struct MoveableWrapper //Just a reference with some metadata
-    {
-        typedef T_ T;
-        static constexpr bool MoveSemantics = MoveSemantics_;
-
-        T& v;
-    };
-
-    template <typename Tp, bool MoveSemantics>
-    MoveableWrapper<Tp, MoveSemantics>
-        wrap(Tp& t)
-    {
-        return MoveableWrapper<Tp, MoveSemantics>{t};
-    }
-
-    template <typename Wrapper>
-    typename enable_if_c<Wrapper::MoveSemantics, typename Wrapper::T>::type
-        unwrap(Wrapper& w)
-    {
-        return std::move(w.v);
-    }
-
-    template <typename Wrapper>
-    typename disable_if_c<Wrapper::MoveSemantics, typename Wrapper::T>::type &
-        unwrap(Wrapper& w)
-    {
-        return w.v;
-    }
-
-    // Implementing some of the helper tuple methods
-    template <std::size_t... I, typename Tuple>
-    std::tuple<typename std::tuple_element<I + 1, Tuple>::type...> 
-        tuple_tail_impl(const Tuple& tpl, index_sequence<I...>)
-    {
-        return std::tuple<
-            typename std::tuple_element<I + 1, Tuple>::type...
-        > (std::get<I + 1>(tpl)...);
-    }
-
-    template <typename Head, typename... Tail>
-    std::tuple<Tail...> tuple_tail(const std::tuple<Head, Tail...>& tpl)
-    {
-        return tuple_tail_impl(tpl, make_index_sequence<sizeof...(Tail)>());
-    }
-
-
-    // Forward declaration
-    template <typename Visitor, typename Visitables, typename... Values>
-    class one_by_one_visitor_and_value_referer;
-
-    template <typename Visitor, typename Visitables, typename... Values>
-    inline one_by_one_visitor_and_value_referer<Visitor, Visitables, Values... >
-        make_one_by_one_visitor_and_value_referer(
-            Visitor& visitor, Visitables visitables, std::tuple<Values...> values
-        )
-    {
-        return one_by_one_visitor_and_value_referer<Visitor, Visitables, Values... > (
-            visitor, visitables, values
-        );
-    }
-
-    template <typename Visitor, typename Visitables, typename... Values>
-    class one_by_one_visitor_and_value_referer
-    {
-        Visitor&                        visitor_;
-        std::tuple<Values...>           values_;
-        Visitables                      visitables_;
-
-    public: // structors
-        one_by_one_visitor_and_value_referer(
-                    Visitor& visitor, Visitables visitables, std::tuple<Values...> values
-                ) BOOST_NOEXCEPT
-            : visitor_(visitor)
-            , values_(values)
-            , visitables_(visitables)
-        {}
-
-    public: // visitor interfaces
-        typedef typename Visitor::result_type result_type;
-
-        template <typename Value>
-        result_type operator()(Value&& value) const
-        {
-            return ::boost::apply_visitor(
-                make_one_by_one_visitor_and_value_referer(
-                    visitor_,
-                    tuple_tail(visitables_),
-                    std::tuple_cat(values_, std::make_tuple(wrap<Value, ! ::boost::is_lvalue_reference<Value>::value>(value)))
-                )
-                , unwrap(std::get<0>(visitables_)) // getting Head element
-            );
-        }
-
-    private:
-        one_by_one_visitor_and_value_referer& operator=(const one_by_one_visitor_and_value_referer&);
-    };
-
-    template <typename Visitor, typename... Values>
-    class one_by_one_visitor_and_value_referer<Visitor, std::tuple<>, Values...>
-    {
-        Visitor&                        visitor_;
-        std::tuple<Values...>           values_;
-
-    public:
-        one_by_one_visitor_and_value_referer(
-                    Visitor& visitor, std::tuple<> /*visitables*/, std::tuple<Values...> values
-                ) BOOST_NOEXCEPT
-            : visitor_(visitor)
-            , values_(values)
-        {}
-
-        typedef typename Visitor::result_type result_type;
-
-        template <class Tuple, std::size_t... I>
-        result_type do_call(Tuple t, index_sequence<I...>) const {
-            return visitor_(unwrap(std::get<I>(t))...);
-        }
-
-        template <typename Value>
-        result_type operator()(Value&& value) const
-        {
-            return do_call(
-                std::tuple_cat(values_, std::make_tuple(wrap<Value, ! ::boost::is_lvalue_reference<Value>::value>(value))),
-                make_index_sequence<sizeof...(Values) + 1>()
-            );
-        }
-    };
-
-}} // namespace detail::variant
-
-    template <class Visitor, class T1, class T2, class T3, class... TN>
-    inline typename Visitor::result_type
-        apply_visitor(const Visitor& visitor, T1&& v1, T2&& v2, T3&& v3, TN&&... vn)
-    {
-        return ::boost::apply_visitor(
-            ::boost::detail::variant::make_one_by_one_visitor_and_value_referer(
-                visitor,
-                std::make_tuple(
-                    ::boost::detail::variant::wrap<T2, ! ::boost::is_lvalue_reference<T2>::value>(v2),
-                    ::boost::detail::variant::wrap<T3, ! ::boost::is_lvalue_reference<T3>::value>(v3),
-                    ::boost::detail::variant::wrap<TN, ! ::boost::is_lvalue_reference<TN>::value>(vn)...
-                    ),
-                std::tuple<>()
-                ),
-                std::forward<T1>(v1)
-            );
-    }
-    
-    template <class Visitor, class T1, class T2, class T3, class... TN>
-    inline typename Visitor::result_type
-        apply_visitor(Visitor& visitor, T1&& v1, T2&& v2, T3&& v3, TN&&... vn)
-    {
-        return ::boost::apply_visitor(
-            ::boost::detail::variant::make_one_by_one_visitor_and_value_referer(
-                visitor,
-                std::make_tuple(
-                    ::boost::detail::variant::wrap<T2, ! ::boost::is_lvalue_reference<T2>::value>(v2),
-                    ::boost::detail::variant::wrap<T3, ! ::boost::is_lvalue_reference<T3>::value>(v3),
-                    ::boost::detail::variant::wrap<TN, ! ::boost::is_lvalue_reference<TN>::value>(vn)...
-                    ),
-                std::tuple<>()
-                ),
-                std::forward<T1>(v1)
-            );
-    }
-
-} // namespace boost
-
-#endif // BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP11_BASED_HPP
-

include/boost/variant/detail/multivisitors_cpp14_based.hpp

@@ -1,152 +0,0 @@
-//  Boost.Varaint
-//  Contains multivisitors that are implemented via variadic templates, std::tuple
-//  and decltype(auto)
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2013-2014.
-//
-//  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).
-
-#ifndef BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP14_BASED_HPP
-#define BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP14_BASED_HPP
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#include <tuple>
-
-namespace boost {
-
-namespace detail { namespace variant {
-
-    // Forward declaration
-    template <typename Visitor, typename Visitables, typename... Values>
-    class one_by_one_visitor_and_value_referer_cpp14;
-
-    template <typename Visitor, typename Visitables, typename... Values>
-    inline one_by_one_visitor_and_value_referer_cpp14<Visitor, Visitables, Values... >
-        make_one_by_one_visitor_and_value_referer_cpp14(
-            Visitor& visitor, Visitables visitables, std::tuple<Values...> values
-        )
-    {
-        return one_by_one_visitor_and_value_referer_cpp14<Visitor, Visitables, Values... > (
-            visitor, visitables, values
-        );
-    }
-
-    template <typename Visitor, typename Visitables, typename... Values>
-    class one_by_one_visitor_and_value_referer_cpp14
-    {
-        Visitor&                        visitor_;
-        std::tuple<Values...>           values_;
-        Visitables                      visitables_;
-
-    public: // structors
-        one_by_one_visitor_and_value_referer_cpp14(
-                    Visitor& visitor, Visitables visitables, std::tuple<Values...> values
-                ) BOOST_NOEXCEPT
-            : visitor_(visitor)
-            , values_(values)
-            , visitables_(visitables)
-        {}
-
-    public: // visitor interfaces
-        template <typename Value>
-        decltype(auto) operator()(Value&& value) const
-        {
-            return ::boost::apply_visitor(
-                make_one_by_one_visitor_and_value_referer_cpp14(
-                    visitor_,
-                    tuple_tail(visitables_),
-                    std::tuple_cat(values_, std::make_tuple(wrap<Value, ! ::boost::is_lvalue_reference<Value>::value>(value)))
-                )
-                , unwrap(std::get<0>(visitables_)) // getting Head element
-            );
-        }
-
-    private:
-        one_by_one_visitor_and_value_referer_cpp14& operator=(const one_by_one_visitor_and_value_referer_cpp14&);
-    };
-
-    template <typename Visitor, typename... Values>
-    class one_by_one_visitor_and_value_referer_cpp14<Visitor, std::tuple<>, Values...>
-    {
-        Visitor&                        visitor_;
-        std::tuple<Values...>           values_;
-
-    public:
-        one_by_one_visitor_and_value_referer_cpp14(
-                    Visitor& visitor, std::tuple<> /*visitables*/, std::tuple<Values...> values
-                ) BOOST_NOEXCEPT
-            : visitor_(visitor)
-            , values_(values)
-        {}
-
-        template <class Tuple, std::size_t... I>
-        decltype(auto) do_call(Tuple t, index_sequence<I...>) const {
-            return visitor_(unwrap(std::get<I>(t))...);
-        }
-
-        template <typename Value>
-        decltype(auto) operator()(Value&& value) const
-        {
-            return do_call(
-                std::tuple_cat(values_, std::make_tuple(wrap<Value, ! ::boost::is_lvalue_reference<Value>::value>(value))),
-                make_index_sequence<sizeof...(Values) + 1>()
-            );
-        }
-    };
-
-}} // namespace detail::variant
-
-    template <class Visitor, class T1, class T2, class T3, class... TN>
-    inline decltype(auto) apply_visitor(const Visitor& visitor, T1&& v1, T2&& v2, T3&& v3, TN&&... vn,
-        typename boost::disable_if<
-            boost::detail::variant::has_result_type<Visitor>,
-            bool
-        >::type = true)
-    {
-        return boost::apply_visitor(
-            ::boost::detail::variant::make_one_by_one_visitor_and_value_referer_cpp14(
-                visitor,
-                std::make_tuple(
-                    ::boost::detail::variant::wrap<T2, ! ::boost::is_lvalue_reference<T2>::value>(v2),
-                    ::boost::detail::variant::wrap<T3, ! ::boost::is_lvalue_reference<T3>::value>(v3),
-                    ::boost::detail::variant::wrap<TN, ! ::boost::is_lvalue_reference<TN>::value>(vn)...
-                    ),
-                std::tuple<>()
-            ),
-            std::forward<T1>(v1)
-        );
-    }
-
-
-    template <class Visitor, class T1, class T2, class T3, class... TN>
-    inline decltype(auto) apply_visitor(Visitor& visitor, T1&& v1, T2&& v2, T3&& v3, TN&&... vn,
-        typename boost::disable_if<
-            boost::detail::variant::has_result_type<Visitor>,
-            bool
-        >::type = true)
-    {
-        return ::boost::apply_visitor(
-            ::boost::detail::variant::make_one_by_one_visitor_and_value_referer_cpp14(
-                visitor,
-                std::make_tuple(
-                    ::boost::detail::variant::wrap<T2, ! ::boost::is_lvalue_reference<T2>::value>(v2),
-                    ::boost::detail::variant::wrap<T3, ! ::boost::is_lvalue_reference<T3>::value>(v3),
-                    ::boost::detail::variant::wrap<TN, ! ::boost::is_lvalue_reference<TN>::value>(vn)...
-                    ),
-                std::tuple<>()
-            ),
-            std::forward<T1>(v1)
-        );
-    }
-
-} // namespace boost
-
-#endif // BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP14_BASED_HPP
-

include/boost/variant/detail/over_sequence.hpp

@@ -15,7 +15,7 @@
 #ifndef BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP
 #define BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP
 
-#include <boost/mpl/aux_/config/ctps.hpp>
+#include "boost/mpl/aux_/config/ctps.hpp"
 
 
 namespace boost {

include/boost/variant/detail/std_hash.hpp

@@ -1,46 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost variant/detail/std_hash.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2018-2026 Antony Polukhin
-//
-// 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)
-
-
-#ifndef BOOST_VARIANT_DETAIL_STD_HASH_HPP
-#define BOOST_VARIANT_DETAIL_STD_HASH_HPP
-
-#include <boost/config.hpp>
-#ifdef BOOST_HAS_PRAGMA_ONCE
-# pragma once
-#endif
-
-#include <boost/variant/variant_fwd.hpp>
-#include <boost/variant/detail/hash_variant.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-// macro BOOST_VARIANT_DO_NOT_SPECIALIZE_STD_HASH
-//
-// Define this macro if you do not wish to have a std::hash specialization for
-// boost::variant.
-
-#if !defined(BOOST_VARIANT_DO_NOT_SPECIALIZE_STD_HASH) && !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
-
-#include <functional> // for std::hash
-
-namespace std {
-    template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
-    struct hash<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) > > {
-        std::size_t operator()(const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& val) const {
-            return ::boost::hash_value(val);
-        }
-    };
-}
-
-#endif // #if !defined(BOOST_VARIANT_DO_NOT_SPECIALIZE_STD_HASH) && !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
-
-#endif // BOOST_VARIANT_DETAIL_STD_HASH_HPP
-

include/boost/variant/detail/substitute.hpp

@@ -1,3 +1,8 @@
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
 //-----------------------------------------------------------------------------
 // boost variant/detail/substitute.hpp header file
 // See http://www.boost.org for updates, documentation, and revision history.
@@ -13,20 +18,24 @@
 #ifndef BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP
 #define BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP
 
-#include <boost/mpl/aux_/config/ctps.hpp>
+#include "boost/mpl/aux_/config/ctps.hpp"
 
-#include <boost/variant/detail/substitute_fwd.hpp>
-#include <boost/variant/variant_fwd.hpp>
-#include <boost/mpl/aux_/lambda_arity_param.hpp>
-#include <boost/mpl/aux_/preprocessor/params.hpp>
-#include <boost/mpl/aux_/preprocessor/repeat.hpp>
-#include <boost/mpl/int_fwd.hpp>
-#include <boost/mpl/limits/arity.hpp>
-#include <boost/preprocessor/empty.hpp>
+#include "boost/variant/detail/substitute_fwd.hpp"
+#include "boost/mpl/aux_/lambda_arity_param.hpp"
+#include "boost/mpl/aux_/preprocessor/params.hpp"
+#include "boost/mpl/aux_/preprocessor/repeat.hpp"
+#include "boost/mpl/int_fwd.hpp"
+#include "boost/mpl/limits/arity.hpp"
+#include "boost/preprocessor/cat.hpp"
+#include "boost/preprocessor/empty.hpp"
+#include "boost/preprocessor/arithmetic/inc.hpp"
+#include "boost/preprocessor/iterate.hpp"
 
 namespace boost {
 namespace detail { namespace variant {
 
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
 ///////////////////////////////////////////////////////////////////////////////
 // (detail) metafunction substitute
 //
@@ -116,23 +125,58 @@ struct substitute<
 // template expression (i.e., F<...>) specializations
 //
 
+#define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL(N) \
+    typedef typename substitute< \
+          BOOST_PP_CAT(U,N), Dest, Source \
+        >::type BOOST_PP_CAT(u,N); \
+    /**/
+
+#define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF(z, N, _) \
+    BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL( BOOST_PP_INC(N) ) \
+    /**/
+
+#define BOOST_PP_ITERATION_LIMITS (0,BOOST_MPL_LIMIT_METAFUNCTION_ARITY)
+#define BOOST_PP_FILENAME_1 "boost/variant/detail/substitute.hpp"
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL
+#undef BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP
+
+///// iteration, depth == 1
+
+#elif BOOST_PP_ITERATION_DEPTH() == 1
+#define i BOOST_PP_FRAME_ITERATION(1)
+
+#if i > 0
+
+//
+// template specializations
+//
 template <
-      template <typename...> class F
-    , typename... Ts
+      template < BOOST_MPL_PP_PARAMS(i,typename P) > class T
+    , BOOST_MPL_PP_PARAMS(i,typename U)
     , typename Dest
     , typename Source
-      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity)
     >
 struct substitute<
-      F<Ts...>
+      T< BOOST_MPL_PP_PARAMS(i,U) >
     , Dest
     , Source
-      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity)
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<( i )>)
     >
 {
-    typedef F<typename substitute<
-          Ts, Dest, Source
-        >::type...> type;
+private:
+    BOOST_MPL_PP_REPEAT(i, BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF, _)
+
+public:
+    typedef T< BOOST_MPL_PP_PARAMS(i,u) > type;
 };
 
 //
@@ -140,12 +184,35 @@ struct substitute<
 //
 template <
       typename R
-    , typename... A
+    , BOOST_MPL_PP_PARAMS(i,typename U)
     , typename Dest
     , typename Source
     >
 struct substitute<
-      R (*)(A...)
+      R (*)( BOOST_MPL_PP_PARAMS(i,U) )
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>)
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+    BOOST_MPL_PP_REPEAT(i, BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF, _)
+
+public:
+    typedef r (*type)( BOOST_MPL_PP_PARAMS(i,u) );
+};
+
+#elif i == 0
+
+//
+// zero-arg function specialization
+//
+template <
+      typename R, typename Dest, typename Source
+    >
+struct substitute<
+      R (*)( void )
     , Dest
     , Source
       BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>)
@@ -155,12 +222,10 @@ private:
     typedef typename substitute< R, Dest, Source >::type r;
 
 public:
-    typedef r (*type)(typename substitute<
-          A, Dest, Source
-        >::type...);
+    typedef r (*type)( void );
 };
 
-}} // namespace detail::variant
-} // namespace boost
+#endif // i
 
-#endif // BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP
+#undef i
+#endif // BOOST_PP_IS_ITERATING

include/boost/variant/detail/substitute_fwd.hpp

@@ -13,17 +13,30 @@
 #ifndef BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP
 #define BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP
 
-#include <boost/mpl/aux_/lambda_arity_param.hpp>
-#include <boost/mpl/aux_/template_arity.hpp>
-#include <boost/mpl/int_fwd.hpp>
+#include "boost/mpl/aux_/lambda_arity_param.hpp"
+#include "boost/mpl/aux_/template_arity.hpp"
+#include "boost/mpl/int_fwd.hpp"
 
 
-#include <boost/mpl/aux_/config/ctps.hpp>
-#include <boost/mpl/aux_/config/ttp.hpp>
+///////////////////////////////////////////////////////////////////////////////
+// BOOST_VARIANT_DETAIL_NO_SUBSTITUTE
+//
+// Defined if 'substitute' is not implementable on the current compiler.
+//
+
+#include "boost/mpl/aux_/config/ctps.hpp"
+#include "boost/mpl/aux_/config/ttp.hpp"
+
+#if defined(BOOST_NO_TEMPLATE_TEMPLATE_PARAMETERS) \
+ && !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+#   define BOOST_VARIANT_DETAIL_NO_SUBSTITUTE
+#endif
 
 namespace boost {
 namespace detail { namespace variant {
 
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
 ///////////////////////////////////////////////////////////////////////////////
 // metafunction substitute
 //
@@ -37,6 +50,8 @@ template <
     >
 struct substitute;
 
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
 }} // namespace detail::variant
 } // namespace boost
 

include/boost/variant/detail/variant_io.hpp

@@ -15,8 +15,10 @@
 
 #include <iosfwd> // for std::basic_ostream forward declare
 
-#include <boost/variant/variant_fwd.hpp>
-#include <boost/variant/static_visitor.hpp>
+#include "boost/variant/variant_fwd.hpp"
+
+#include "boost/detail/templated_streams.hpp"
+#include "boost/variant/static_visitor.hpp"
 
 namespace boost {
 
@@ -27,9 +29,14 @@ namespace boost {
 //
 
 // forward declare (allows output of embedded variant< variant< ... >, ... >)
-template <class CharT, class Trait, typename... U>
-inline std::basic_ostream<CharT, Trait>& operator<<(
-      std::basic_ostream<CharT, Trait>& out, const variant<U...>& rhs
+template <
+      BOOST_TEMPLATED_STREAM_ARGS(E,T)
+    BOOST_TEMPLATED_STREAM_COMMA
+      BOOST_VARIANT_ENUM_PARAMS(typename U)
+    >
+inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<(
+      BOOST_TEMPLATED_STREAM(ostream, E,T)& out
+    , const variant< BOOST_VARIANT_ENUM_PARAMS(U) >& rhs
     );
 
 namespace detail { namespace variant {
@@ -64,13 +71,18 @@ private:
 
 }} // namespace detail::variant
 
-template <class CharT, class Trait, typename... U>
-inline std::basic_ostream<CharT, Trait>& operator<<(
-      std::basic_ostream<CharT, Trait>& out, const variant<U...>& rhs
+template <
+      BOOST_TEMPLATED_STREAM_ARGS(E,T)
+    BOOST_TEMPLATED_STREAM_COMMA
+      BOOST_VARIANT_ENUM_PARAMS(typename U)
+    >
+inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<(
+      BOOST_TEMPLATED_STREAM(ostream, E,T)& out
+    , const variant< BOOST_VARIANT_ENUM_PARAMS(U) >& rhs
     )
 {
     detail::variant::printer<
-          std::basic_ostream<CharT, Trait>
+          BOOST_TEMPLATED_STREAM(ostream, E,T)
         > visitor(out);
 
     rhs.apply_visitor(visitor);

include/boost/variant/detail/visitation_impl.hpp

@@ -13,30 +13,31 @@
 #ifndef BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP
 #define BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP
 
-#include <boost/config.hpp>
+#include "boost/config.hpp"
 
-#include <boost/variant/detail/backup_holder.hpp>
-#include <boost/variant/detail/cast_storage.hpp>
-#include <boost/variant/detail/forced_return.hpp>
-#include <boost/variant/variant_fwd.hpp>
+#include "boost/variant/detail/backup_holder.hpp"
+#include "boost/variant/detail/cast_storage.hpp"
+#include "boost/variant/detail/forced_return.hpp"
+#include "boost/variant/detail/generic_result_type.hpp"
 
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/next.hpp>
-#include <boost/mpl/deref.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/inc.hpp>
-#include <boost/preprocessor/repeat.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/has_nothrow_copy.hpp>
-#include <boost/type_traits/is_nothrow_move_constructible.hpp>
+#include "boost/assert.hpp"
+#include "boost/mpl/eval_if.hpp"
+#include "boost/mpl/bool.hpp"
+#include "boost/mpl/identity.hpp"
+#include "boost/mpl/int.hpp"
+#include "boost/mpl/next.hpp"
+#include "boost/mpl/deref.hpp"
+#include "boost/mpl/or.hpp"
+#include "boost/preprocessor/cat.hpp"
+#include "boost/preprocessor/inc.hpp"
+#include "boost/preprocessor/repeat.hpp"
+#include "boost/type_traits/is_same.hpp"
+#include "boost/type_traits/has_nothrow_copy.hpp"
+#include "boost/type_traits/is_nothrow_move_constructible.hpp"
 
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-# pragma warning (push)
-# pragma warning (disable : 4702) //unreachable code
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) 
+# pragma warning (push) 
+# pragma warning (disable : 4702) //unreachable code 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -46,11 +47,8 @@
 // and potentially increase runtime performance. (TODO: Investigate further.)
 //
 #if !defined(BOOST_VARIANT_VISITATION_UNROLLING_LIMIT)
-
-#   include <boost/mpl/limits/list.hpp>
 #   define BOOST_VARIANT_VISITATION_UNROLLING_LIMIT   \
-        BOOST_MPL_LIMIT_LIST_SIZE
-
+        BOOST_VARIANT_LIMIT_TYPES
 #endif
 
 namespace boost {
@@ -96,7 +94,8 @@ struct visitation_impl_step< LastIter,LastIter >
 //
 
 template <typename Visitor, typename VoidPtrCV, typename T>
-inline typename Visitor::result_type
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
 visitation_impl_invoke_impl(
       int, Visitor& visitor, VoidPtrCV storage, T*
     , mpl::true_// never_uses_backup
@@ -108,7 +107,8 @@ visitation_impl_invoke_impl(
 }
 
 template <typename Visitor, typename VoidPtrCV, typename T>
-inline typename Visitor::result_type
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
 visitation_impl_invoke_impl(
       int internal_which, Visitor& visitor, VoidPtrCV storage, T*
     , mpl::false_// never_uses_backup
@@ -129,7 +129,8 @@ visitation_impl_invoke_impl(
 }
 
 template <typename Visitor, typename VoidPtrCV, typename T, typename NoBackupFlag>
-inline typename Visitor::result_type
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
 visitation_impl_invoke(
       int internal_which, Visitor& visitor, VoidPtrCV storage, T* t
     , NoBackupFlag
@@ -149,10 +150,12 @@ visitation_impl_invoke(
 }
 
 template <typename Visitor, typename VoidPtrCV, typename NBF>
-inline typename Visitor::result_type
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
 visitation_impl_invoke(int, Visitor&, VoidPtrCV, apply_visitor_unrolled*, NBF, long)
 {
-    // should never be here at runtime!
+    // should never be here at runtime:
+    BOOST_ASSERT(false);
     typedef typename Visitor::result_type result_type;
     return ::boost::detail::variant::forced_return< result_type >();
 }
@@ -168,14 +171,16 @@ template <
     , typename Visitor, typename VPCV
     , typename NBF
     >
-inline typename Visitor::result_type
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
 visitation_impl(
       int, int, Visitor&, VPCV
     , mpl::true_ // is_apply_visitor_unrolled
-    , NBF, W* = nullptr, S* = nullptr
+    , NBF, W* = 0, S* = 0
     )
 {
-    // should never be here at runtime!
+    // should never be here at runtime:
+    BOOST_ASSERT(false);
     typedef typename Visitor::result_type result_type;
     return ::boost::detail::variant::forced_return< result_type >();
 }
@@ -185,13 +190,14 @@ template <
     , typename Visitor, typename VoidPtrCV
     , typename NoBackupFlag
     >
-BOOST_FORCEINLINE typename Visitor::result_type
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
 visitation_impl(
       const int internal_which, const int logical_which
     , Visitor& visitor, VoidPtrCV storage
     , mpl::false_ // is_apply_visitor_unrolled
     , NoBackupFlag no_backup_flag
-    , Which* = nullptr, step0* = nullptr
+    , Which* = 0, step0* = 0
     )
 {
     // Typedef apply_visitor_unrolled steps and associated types...
@@ -246,7 +252,7 @@ visitation_impl(
     typedef typename is_same< next_type,apply_visitor_unrolled >::type
         is_apply_visitor_unrolled;
 
-    return detail::variant::visitation_impl(
+    return visitation_impl(
           internal_which, logical_which
         , visitor, storage
         , is_apply_visitor_unrolled()
@@ -258,8 +264,8 @@ visitation_impl(
 }} // namespace detail::variant
 } // namespace boost
 
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-# pragma warning(pop)
-#endif
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
+# pragma warning(pop)  
+#endif 
 
 #endif // BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP

include/boost/variant/get.hpp

@@ -3,8 +3,8 @@
 // See http://www.boost.org for updates, documentation, and revision history.
 //-----------------------------------------------------------------------------
 //
-// Copyright (c) 2003 Eric Friedman, Itay Maman
-// Copyright (c) 2014-2026 Antony Polukhin
+// Copyright (c) 2003
+// Eric Friedman, Itay Maman
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -15,46 +15,34 @@
 
 #include <exception>
 
-#include <boost/config.hpp>
-#include <boost/core/addressof.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/variant/variant_fwd.hpp>
-#include <boost/variant/detail/element_index.hpp>
-#include <boost/variant/detail/move.hpp>
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+#include "boost/throw_exception.hpp"
+#include "boost/utility/addressof.hpp"
+#include "boost/variant/variant_fwd.hpp"
 
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/add_pointer.hpp>
-#include <boost/type_traits/is_lvalue_reference.hpp>
+#include "boost/type_traits/add_reference.hpp"
+#include "boost/type_traits/add_pointer.hpp"
 
 namespace boost {
 
-#if defined(BOOST_CLANG)
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
 //////////////////////////////////////////////////////////////////////////
 // class bad_get
 //
 // The exception thrown in the event of a failed get of a value.
 //
-class BOOST_SYMBOL_VISIBLE bad_get
+class bad_get
     : public std::exception
 {
 public: // std::exception implementation
 
-    const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE
+    virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
     {
         return "boost::bad_get: "
                "failed value get using boost::get";
     }
 
 };
-#if defined(BOOST_CLANG)
-#   pragma clang diagnostic pop
-#endif
-
 
 //////////////////////////////////////////////////////////////////////////
 // function template get<T>
@@ -98,27 +86,17 @@ public: // visitor interfaces
 
 }} // namespace detail::variant
 
-#ifndef BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE
-#   if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x0551))
-#       define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)
-#   else
-#       if defined(BOOST_NO_CXX11_NULLPTR)
-#           define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
-            , t* = 0
-#       else
-#           define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
-            , t* = nullptr
-#       endif
-#   endif
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))
+#   define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)
+#else
+#   define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
+    , t* = 0
 #endif
 
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// relaxed_get<U>(variant) methods
-//
 template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
 inline
     typename add_pointer<U>::type
-relaxed_get(
+get(
       boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
       BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
     ) BOOST_NOEXCEPT
@@ -133,7 +111,7 @@ relaxed_get(
 template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
 inline
     typename add_pointer<const U>::type
-relaxed_get(
+get(
       const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
       BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
     ) BOOST_NOEXCEPT
@@ -148,13 +126,13 @@ relaxed_get(
 template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
 inline
     typename add_reference<U>::type
-relaxed_get(
+get(
       boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
       BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
     )
 {
     typedef typename add_pointer<U>::type U_ptr;
-    U_ptr result = relaxed_get<U>(boost::addressof(operand));
+    U_ptr result = get<U>(&operand);
 
     if (!result)
         boost::throw_exception(bad_get());
@@ -164,225 +142,19 @@ relaxed_get(
 template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
 inline
     typename add_reference<const U>::type
-relaxed_get(
+get(
       const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
       BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
     )
 {
     typedef typename add_pointer<const U>::type U_ptr;
-    U_ptr result = relaxed_get<const U>(boost::addressof(operand));
+    U_ptr result = get<const U>(&operand);
 
     if (!result)
         boost::throw_exception(bad_get());
     return *result;
 }
 
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-#if defined(BOOST_MSVC) && (_MSC_VER < 1900) // MSVC-2014 has fixed the incorrect diagnostics.
-#   pragma warning(push)
-#   pragma warning(disable: 4172) // returning address of local variable or temporary
-#endif
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    U&&
-relaxed_get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >&& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-    typedef typename add_pointer<U>::type U_ptr;
-    U_ptr result = relaxed_get<U>(boost::addressof(operand));
-
-    if (!result)
-        boost::throw_exception(bad_get());
-    return static_cast<U&&>(*result);
-}
-
-#if defined(BOOST_MSVC) && (_MSC_VER < 1900)
-#   pragma warning(pop)
-#endif
-
-#endif
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// strict_get<U>(variant) methods
-//
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_pointer<U>::type
-strict_get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    ) BOOST_NOEXCEPT
-{
-    BOOST_STATIC_ASSERT_MSG(
-        (boost::detail::variant::holds_element<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
-        "boost::variant does not contain specified type U, "
-        "call to boost::get<U>(boost::variant<T...>*) will always return NULL"
-    );
-
-    return relaxed_get<U>(operand);
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_pointer<const U>::type
-strict_get(
-      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    ) BOOST_NOEXCEPT
-{
-    BOOST_STATIC_ASSERT_MSG(
-        (boost::detail::variant::holds_element<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, const U >::value),
-        "boost::variant does not contain specified type U, "
-        "call to boost::get<U>(const boost::variant<T...>*) will always return NULL"
-    );
-
-    return relaxed_get<U>(operand);
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_reference<U>::type
-strict_get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-    BOOST_STATIC_ASSERT_MSG(
-        (boost::detail::variant::holds_element<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
-        "boost::variant does not contain specified type U, "
-        "call to boost::get<U>(boost::variant<T...>&) will always throw boost::bad_get exception"
-    );
-
-    return relaxed_get<U>(operand);
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_reference<const U>::type
-strict_get(
-      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-    BOOST_STATIC_ASSERT_MSG(
-        (boost::detail::variant::holds_element<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, const U >::value),
-        "boost::variant does not contain specified type U, "
-        "call to boost::get<U>(const boost::variant<T...>&) will always throw boost::bad_get exception"
-    );
-
-    return relaxed_get<U>(operand);
-}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    U&&
-strict_get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >&& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-    BOOST_STATIC_ASSERT_MSG(
-        (!boost::is_lvalue_reference<U>::value),
-        "remove ampersand '&' from template type U in boost::get<U>(boost::variant<T...>&&) "
-    );
-
-    BOOST_STATIC_ASSERT_MSG(
-        (boost::detail::variant::holds_element<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
-        "boost::variant does not contain specified type U, "
-        "call to boost::get<U>(const boost::variant<T...>&) will always throw boost::bad_get exception"
-    );
-
-    return relaxed_get<U>(detail::variant::move(operand));
-}
-#endif
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// get<U>(variant) methods
-//
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_pointer<U>::type
-get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    ) BOOST_NOEXCEPT
-{
-#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
-    return relaxed_get<U>(operand);
-#else
-    return strict_get<U>(operand);
-#endif
-
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_pointer<const U>::type
-get(
-      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    ) BOOST_NOEXCEPT
-{
-#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
-    return relaxed_get<U>(operand);
-#else
-    return strict_get<U>(operand);
-#endif
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_reference<U>::type
-get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
-    return relaxed_get<U>(operand);
-#else
-    return strict_get<U>(operand);
-#endif
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_reference<const U>::type
-get(
-      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
-    return relaxed_get<U>(operand);
-#else
-    return strict_get<U>(operand);
-#endif
-}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    U&&
-get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >&& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
-    return relaxed_get<U>(detail::variant::move(operand));
-#else
-    return strict_get<U>(detail::variant::move(operand));
-#endif
-}
-#endif
-
 } // namespace boost
 
 #endif // BOOST_VARIANT_GET_HPP

include/boost/variant/multivisitors.hpp

@@ -3,7 +3,7 @@
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
-//  Copyright (c) 2013-2026 Antony Polukhin.
+//  Copyright Antony Polukhin, 2013.
 //
 //  Distributed under the Boost
 //  Software License, Version 1.0. (See accompanying file
@@ -16,13 +16,128 @@
 # pragma once
 #endif
 
-#include <boost/config.hpp>
-#include <boost/variant/variant_fwd.hpp>
+#include <boost/variant.hpp>
+#include <boost/bind.hpp>
 
-#include <boost/variant/detail/multivisitors_cpp11_based.hpp>
-#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
-#   include <boost/variant/detail/multivisitors_cpp14_based.hpp>
+#include <boost/preprocessor/repetition.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+
+#ifndef BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS
+#   define BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS 4
 #endif
 
+namespace boost { 
+
+namespace detail { namespace variant {
+
+    template <class VisitorT, class Visitable1T, class Visitable2T>
+    struct two_variables_holder {
+    private:
+        VisitorT&       visitor_;
+        Visitable1T&    visitable1_;
+        Visitable2T&    visitable2_;
+
+        // required to supress warnings and enshure that we do not copy 
+        // this visitor
+        two_variables_holder& operator=(const two_variables_holder&);
+
+    public:
+        typedef BOOST_DEDUCED_TYPENAME VisitorT::result_type result_type;
+
+        explicit two_variables_holder(VisitorT& visitor, Visitable1T& visitable1, Visitable2T& visitable2) BOOST_NOEXCEPT 
+            : visitor_(visitor)
+            , visitable1_(visitable1)
+            , visitable2_(visitable2)
+        {}
+
+#define BOOST_VARIANT_OPERATOR_BEG()                            \
+    return ::boost::apply_visitor(                              \
+    ::boost::bind<result_type>(boost::ref(visitor_), _1, _2     \
+    /**/
+
+#define BOOST_VARIANT_OPERATOR_END()                            \
+    ), visitable1_, visitable2_);                               \
+    /**/
+
+#define BOOST_VARANT_VISITORS_VARIABLES_PRINTER(z, n, data)     \
+    BOOST_PP_COMMA() boost::ref( BOOST_PP_CAT(vis, n) )         \
+    /**/
+
+#define BOOST_VARIANT_VISIT(z, n, data)                                                     \
+    template <BOOST_PP_ENUM_PARAMS(BOOST_PP_ADD(n, 1), class VisitableUnwrapped)>           \
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) operator()(                          \
+        BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ADD(n, 1), VisitableUnwrapped, & vis)          \
+    ) const                                                                                 \
+    {                                                                                       \
+        BOOST_VARIANT_OPERATOR_BEG()                                                        \
+        BOOST_PP_REPEAT(BOOST_PP_ADD(n, 1), BOOST_VARANT_VISITORS_VARIABLES_PRINTER, ~)     \
+        BOOST_VARIANT_OPERATOR_END()                                                        \
+    }                                                                                       \
+    /**/
+
+BOOST_PP_REPEAT( BOOST_PP_SUB(BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS, 2), BOOST_VARIANT_VISIT, ~)
+#undef BOOST_VARIANT_OPERATOR_BEG
+#undef BOOST_VARIANT_OPERATOR_END
+#undef BOOST_VARANT_VISITORS_VARIABLES_PRINTER
+#undef BOOST_VARIANT_VISIT
+
+    };
+
+    template <class VisitorT, class Visitable1T, class Visitable2T>
+    inline two_variables_holder<VisitorT, Visitable1T, Visitable2T> make_two_variables_holder(
+            VisitorT& visitor, Visitable1T& visitable1, Visitable2T& visitable2
+        ) BOOST_NOEXCEPT
+    {
+        return two_variables_holder<VisitorT, Visitable1T, Visitable2T>(visitor, visitable1, visitable2);
+    }
+
+    template <class VisitorT, class Visitable1T, class Visitable2T>
+    inline two_variables_holder<const VisitorT, Visitable1T, Visitable2T> make_two_variables_holder(
+            const VisitorT& visitor, Visitable1T& visitable1, Visitable2T& visitable2
+        ) BOOST_NOEXCEPT
+    {
+        return two_variables_holder<const VisitorT, Visitable1T, Visitable2T>(visitor, visitable1, visitable2);
+    }
+
+}} // namespace detail::variant
+
+#define BOOST_VARIANT_APPLY_VISITOR_BEG()                                               \
+    return ::boost::apply_visitor(                                                      \
+            boost::detail::variant::make_two_variables_holder(visitor, var0 , var1),    \
+            var2                                                                        \
+    /**/
+
+#define BOOST_VARIANT_APPLY_VISITOR_END()                       \
+    );                                                          \
+    /**/
+
+#define BOOST_VARANT_VISITORS_VARIABLES_PRINTER(z, n, data)     \
+    BOOST_PP_COMMA() BOOST_PP_CAT(var, BOOST_PP_ADD(n, 3))      \
+    /**/
+
+#define BOOST_VARIANT_VISIT(z, n, data)                                                                 \
+    template <class Visitor BOOST_PP_COMMA() BOOST_PP_ENUM_PARAMS(BOOST_PP_ADD(n, 3), class T)>         \
+    inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(BOOST_DEDUCED_TYPENAME Visitor::result_type) apply_visitor( \
+        data BOOST_PP_COMMA() BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ADD(n, 3), T, & var)     \
+    )                                                                                                   \
+    {                                                                                                   \
+        BOOST_VARIANT_APPLY_VISITOR_BEG()                                                               \
+        BOOST_PP_REPEAT(n, BOOST_VARANT_VISITORS_VARIABLES_PRINTER, ~)                                  \
+        BOOST_VARIANT_APPLY_VISITOR_END()                                                               \
+    }                                                                                                   \
+    /**/
+
+BOOST_PP_REPEAT( BOOST_PP_SUB(BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS, 2), BOOST_VARIANT_VISIT, const Visitor& visitor)
+BOOST_PP_REPEAT( BOOST_PP_SUB(BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS, 2), BOOST_VARIANT_VISIT, Visitor& visitor)
+
+#undef BOOST_VARIANT_APPLY_VISITOR_BEG
+#undef BOOST_VARIANT_APPLY_VISITOR_END
+#undef BOOST_VARANT_VISITORS_VARIABLES_PRINTER
+#undef BOOST_VARIANT_VISIT
+    
+} // namespace boost
+
 #endif // BOOST_VARIANT_MULTIVISITORS_HPP
 

include/boost/variant/polymorphic_get.hpp

@@ -1,352 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost variant/polymorphic_get.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2013-2026 Antony Polukhin
-//
-// 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)
-
-#ifndef BOOST_VARIANT_POLYMORPHIC_GET_HPP
-#define BOOST_VARIANT_POLYMORPHIC_GET_HPP
-
-#include <exception>
-
-#include <boost/config.hpp>
-#include <boost/core/addressof.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/variant/variant_fwd.hpp>
-#include <boost/variant/get.hpp>
-
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/add_pointer.hpp>
-#include <boost/type_traits/is_base_of.hpp>
-#include <boost/type_traits/is_const.hpp>
-
-namespace boost {
-
-//////////////////////////////////////////////////////////////////////////
-// class bad_polymorphic_get
-//
-// The exception thrown in the event of a failed get of a value.
-//
-class BOOST_SYMBOL_VISIBLE bad_polymorphic_get
-    : public bad_get
-{
-public: // std::exception implementation
-
-    virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
-    {
-        return "boost::bad_polymorphic_get: "
-               "failed value get using boost::polymorphic_get";
-    }
-
-};
-
-//////////////////////////////////////////////////////////////////////////
-// function template get<T>
-//
-// Retrieves content of given variant object if content is of type T.
-// Otherwise: pointer ver. returns 0; reference ver. throws bad_get.
-//
-
-namespace detail { namespace variant {
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// polymorphic metafunctions to detect index of a value
-//
-
-template <class Types, class T>
-struct element_polymorphic_iterator_impl :
-    boost::mpl::find_if<
-        Types,
-        boost::mpl::or_<
-            variant_element_functor<boost::mpl::_1, T>,
-            variant_element_functor<boost::mpl::_1, typename boost::remove_cv<T>::type >,
-            boost::is_base_of<T, boost::mpl::_1>
-        >
-    >
-{};
-
-template <class Variant, class T>
-struct holds_element_polymorphic :
-    boost::mpl::not_<
-        boost::is_same<
-            typename boost::mpl::end<typename Variant::types>::type,
-            typename element_polymorphic_iterator_impl<typename Variant::types, typename boost::remove_reference<T>::type >::type
-        >
-    >
-{};
-
-// (detail) class template get_polymorphic_visitor
-//
-// Generic static visitor that: if the value is of the specified
-// type or of a type derived from specified, returns a pointer
-// to the value it visits; else a null pointer.
-//
-template <typename Base>
-struct get_polymorphic_visitor
-{
-private: // private typedefs
-    typedef get_polymorphic_visitor<Base>       this_type;
-    typedef typename add_pointer<Base>::type    pointer;
-    typedef typename add_reference<Base>::type  reference;
-
-    pointer get(reference operand, boost::true_type) const BOOST_NOEXCEPT
-    {
-        return boost::addressof(operand);
-    }
-
-    template <class T>
-    pointer get(T&, boost::false_type) const BOOST_NOEXCEPT
-    {
-        return static_cast<pointer>(0);
-    }
-
-public: // visitor interfaces
-    typedef pointer result_type;
-
-    template <typename U>
-    pointer operator()(U& operand) const BOOST_NOEXCEPT
-    {
-        typedef typename boost::remove_reference<Base>::type base_t;
-        typedef boost::integral_constant<
-            bool,
-            (
-                boost::is_base_of<base_t, U>::value &&
-                (boost::is_const<base_t>::value || !boost::is_const<U>::value)
-            )
-            || boost::is_same<base_t, U>::value
-            || boost::is_same<typename boost::remove_cv<base_t>::type, U >::value
-        > tag_t;
-
-        return this_type::get(operand, tag_t());
-    }
-};
-
-}} // namespace detail::variant
-
-#ifndef BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE
-#   if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x0551))
-#       define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)
-#   else
-#       if defined(BOOST_NO_CXX11_NULLPTR)
-#           define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
-            , t* = 0
-#       else
-#           define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
-            , t* = nullptr
-#       endif
-#   endif
-#endif
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////
-// polymorphic_relaxed_get
-//
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_pointer<U>::type
-polymorphic_relaxed_get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    ) BOOST_NOEXCEPT
-{
-    typedef typename add_pointer<U>::type U_ptr;
-    if (!operand) return static_cast<U_ptr>(0);
-
-    detail::variant::get_polymorphic_visitor<U> v;
-    return operand->apply_visitor(v);
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_pointer<const U>::type
-polymorphic_relaxed_get(
-      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    ) BOOST_NOEXCEPT
-{
-    typedef typename add_pointer<const U>::type U_ptr;
-    if (!operand) return static_cast<U_ptr>(0);
-
-    detail::variant::get_polymorphic_visitor<const U> v;
-    return operand->apply_visitor(v);
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_reference<U>::type
-polymorphic_relaxed_get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-    typedef typename add_pointer<U>::type U_ptr;
-    U_ptr result = polymorphic_relaxed_get<U>(&operand);
-
-    if (!result)
-        boost::throw_exception(bad_polymorphic_get());
-    return *result;
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_reference<const U>::type
-polymorphic_relaxed_get(
-      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-    typedef typename add_pointer<const U>::type U_ptr;
-    U_ptr result = polymorphic_relaxed_get<const U>(&operand);
-
-    if (!result)
-        boost::throw_exception(bad_polymorphic_get());
-    return *result;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////
-// polymorphic_strict_get
-//
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_pointer<U>::type
-polymorphic_strict_get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    ) BOOST_NOEXCEPT
-{
-    BOOST_STATIC_ASSERT_MSG(
-        (boost::detail::variant::holds_element_polymorphic<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
-        "boost::variant does not contain specified type U, "
-        "call to boost::polymorphic_get<U>(boost::variant<T...>*) will always return NULL"
-    );
-
-    return polymorphic_relaxed_get<U>(operand);
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_pointer<const U>::type
-polymorphic_strict_get(
-      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    ) BOOST_NOEXCEPT
-{
-    BOOST_STATIC_ASSERT_MSG(
-        (boost::detail::variant::holds_element_polymorphic<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
-        "boost::variant does not contain specified type U, "
-        "call to boost::polymorphic_get<U>(const boost::variant<T...>*) will always return NULL"
-    );
-
-    return polymorphic_relaxed_get<U>(operand);
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_reference<U>::type
-polymorphic_strict_get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-    BOOST_STATIC_ASSERT_MSG(
-        (boost::detail::variant::holds_element_polymorphic<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
-        "boost::variant does not contain specified type U, "
-        "call to boost::polymorphic_get<U>(boost::variant<T...>&) will always throw boost::bad_polymorphic_get exception"
-    );
-
-    return polymorphic_relaxed_get<U>(operand);
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_reference<const U>::type
-polymorphic_strict_get(
-      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-    BOOST_STATIC_ASSERT_MSG(
-        (boost::detail::variant::holds_element_polymorphic<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
-        "boost::variant does not contain specified type U, "
-        "call to boost::polymorphic_get<U>(const boost::variant<T...>&) will always throw boost::bad_polymorphic_get exception"
-    );
-
-    return polymorphic_relaxed_get<U>(operand);
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// polymorphic_get<U>(variant) methods
-//
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_pointer<U>::type
-polymorphic_get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    ) BOOST_NOEXCEPT
-{
-#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
-    return polymorphic_relaxed_get<U>(operand);
-#else
-    return polymorphic_strict_get<U>(operand);
-#endif
-
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_pointer<const U>::type
-polymorphic_get(
-      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    ) BOOST_NOEXCEPT
-{
-#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
-    return polymorphic_relaxed_get<U>(operand);
-#else
-    return polymorphic_strict_get<U>(operand);
-#endif
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_reference<U>::type
-polymorphic_get(
-      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
-    return polymorphic_relaxed_get<U>(operand);
-#else
-    return polymorphic_strict_get<U>(operand);
-#endif
-}
-
-template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
-inline
-    typename add_reference<const U>::type
-polymorphic_get(
-      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
-      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
-    )
-{
-#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
-    return polymorphic_relaxed_get<U>(operand);
-#else
-    return polymorphic_strict_get<U>(operand);
-#endif
-}
-} // namespace boost
-
-#endif // BOOST_VARIANT_POLYMORPHIC_GET_HPP

include/boost/variant/recursive_variant.hpp

@@ -4,7 +4,7 @@
 //-----------------------------------------------------------------------------
 //
 // Copyright (c) 2003 Eric Friedman
-// Copyright (c) 2013-2026 Antony Polukhin
+// Copyright (c) 2013 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,27 +13,27 @@
 #ifndef BOOST_VARIANT_RECURSIVE_VARIANT_HPP
 #define BOOST_VARIANT_RECURSIVE_VARIANT_HPP
 
-#include <boost/variant/variant_fwd.hpp>
-#include <boost/variant/detail/enable_recursive.hpp>
-#include <boost/variant/detail/substitute_fwd.hpp>
-#include <boost/variant/detail/make_variant_list.hpp>
-#include <boost/variant/detail/over_sequence.hpp>
+#include "boost/variant/variant_fwd.hpp"
+#include "boost/variant/detail/enable_recursive.hpp"
+#include "boost/variant/detail/substitute_fwd.hpp"
+#include "boost/variant/detail/make_variant_list.hpp"
+#include "boost/variant/detail/over_sequence.hpp"
 
-#include <boost/mpl/aux_/lambda_arity_param.hpp>
+#include "boost/mpl/aux_/lambda_arity_param.hpp"
 
-#include <boost/mpl/equal.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/protect.hpp>
-#include <boost/mpl/transform.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/repeat.hpp>
+#include "boost/mpl/equal.hpp"
+#include "boost/mpl/eval_if.hpp"
+#include "boost/mpl/identity.hpp"
+#include "boost/mpl/if.hpp"
+#include "boost/mpl/protect.hpp"
+#include "boost/mpl/transform.hpp"
+#include "boost/type_traits/is_same.hpp"
+#include "boost/preprocessor/cat.hpp"
+#include "boost/preprocessor/repeat.hpp"
 
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/is_sequence.hpp>
-#include <boost/variant/variant.hpp>
+#include "boost/mpl/bool.hpp"
+#include "boost/mpl/is_sequence.hpp"
+#include "boost/variant/variant.hpp"
 
 namespace boost {
 
@@ -45,6 +45,8 @@ namespace detail { namespace variant {
 // Handles embedded variant types when substituting for recursive_variant_.
 //
 
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
 template <
       BOOST_VARIANT_ENUM_PARAMS(typename T)
     , typename RecursiveVariant
@@ -113,7 +115,9 @@ struct substitute<
     , ::boost::recursive_variant_
       BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity)
     >
-{   
+{
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && defined(BOOST_VARIANT_USE_VARIADIC_TEMPLATES)
+    
     typedef ::boost::variant<
         typename enable_recursive<   
               T0              
@@ -126,8 +130,41 @@ struct substitute<
             , mpl::true_                     
         >::type...  
     > type;
+
+#else
+
+private: // helpers, for metafunction result (below)
+
+    #define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS(z,N,_)  \
+        typedef typename enable_recursive<   \
+              BOOST_PP_CAT(T,N)              \
+            , RecursiveVariant               \
+            , mpl::true_                     \
+            >::type BOOST_PP_CAT(wknd_T,N);  \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS
+
+public: // metafunction result
+
+    typedef ::boost::variant< BOOST_VARIANT_ENUM_PARAMS(wknd_T) > type;
+#endif
 };
 
+#else // defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+//
+// no specializations: embedded variants unsupported on these compilers!
+//
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
 }} // namespace detail::variant
 
 ///////////////////////////////////////////////////////////////////////////////

include/boost/variant/recursive_wrapper.hpp

@@ -13,9 +13,9 @@
 #ifndef BOOST_VARIANT_RECURSIVE_WRAPPER_HPP
 #define BOOST_VARIANT_RECURSIVE_WRAPPER_HPP
 
-#include <boost/variant/recursive_wrapper_fwd.hpp>
-#include <boost/variant/detail/move.hpp>
-#include <boost/core/checked_delete.hpp>
+#include "boost/variant/recursive_wrapper_fwd.hpp"
+#include "boost/variant/detail/move.hpp"
+#include "boost/checked_delete.hpp"
 
 namespace boost {
 

include/boost/variant/recursive_wrapper_fwd.hpp

@@ -3,8 +3,8 @@
 // See http://www.boost.org for updates, documentation, and revision history.
 //-----------------------------------------------------------------------------
 //
-// Copyright (c) 2002 Eric Friedman, Itay Maman
-// Copyright (c) 2016-2026 Antony Polukhin
+// Copyright (c) 2002
+// Eric Friedman, Itay Maman
 //
 // Portions Copyright (C) 2002 David Abrahams
 //
@@ -15,12 +15,12 @@
 #ifndef BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP
 #define BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP
 
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/aux_/config/ctps.hpp>
-#include <boost/mpl/aux_/lambda_support.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/is_constructible.hpp>
-#include <boost/type_traits/is_nothrow_move_constructible.hpp>
+#include "boost/mpl/aux_/config/ctps.hpp"
+
+#include "boost/mpl/aux_/lambda_support.hpp"
+
+// should be the last #include
+#include "boost/type_traits/detail/bool_trait_def.hpp"
 
 namespace boost {
 
@@ -42,38 +42,10 @@ namespace boost {
 //
 template <typename T> class recursive_wrapper;
 
-
-///////////////////////////////////////////////////////////////////////////////
-// metafunction is_constructible partial specializations.
-//
-// recursive_wrapper<T> is constructible only from T and recursive_wrapper<T>.
-//
-template <class T>          struct is_constructible<recursive_wrapper<T>, T>                            : boost::true_type{};
-template <class T>          struct is_constructible<recursive_wrapper<T>, const T>                      : boost::true_type{};
-template <class T>          struct is_constructible<recursive_wrapper<T>, T&>                           : boost::true_type{};
-template <class T>          struct is_constructible<recursive_wrapper<T>, const T&>                     : boost::true_type{};
-template <class T>          struct is_constructible<recursive_wrapper<T>, recursive_wrapper<T> >        : boost::true_type{};
-template <class T>          struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<T> >  : boost::true_type{};
-template <class T>          struct is_constructible<recursive_wrapper<T>, recursive_wrapper<T>& >       : boost::true_type{};
-template <class T>          struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<T>& > : boost::true_type{};
-
-template <class T, class U> struct is_constructible<recursive_wrapper<T>, U >                           : boost::false_type{};
-template <class T, class U> struct is_constructible<recursive_wrapper<T>, const U >                     : boost::false_type{};
-template <class T, class U> struct is_constructible<recursive_wrapper<T>, U& >                          : boost::false_type{};
-template <class T, class U> struct is_constructible<recursive_wrapper<T>, const U& >                    : boost::false_type{};
-template <class T, class U> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<U> >        : boost::false_type{};
-template <class T, class U> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<U> >  : boost::false_type{};
-template <class T, class U> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<U>& >       : boost::false_type{};
-template <class T, class U> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<U>& > : boost::false_type{};
-
-// recursive_wrapper is not nothrow move constructible, because it's constructor does dynamic memory allocation.
-// This specialisation is required to workaround GCC6 issue: https://svn.boost.org/trac/boost/ticket/12680
-template <class T> struct is_nothrow_move_constructible<recursive_wrapper<T> > : boost::false_type{};
-
 ///////////////////////////////////////////////////////////////////////////////
 // metafunction is_recursive_wrapper (modeled on code by David Abrahams)
 //
-// True if specified type matches recursive_wrapper<T>.
+// True iff specified type matches recursive_wrapper<T>.
 //
 
 namespace detail {
@@ -94,12 +66,11 @@ struct is_recursive_wrapper_impl< recursive_wrapper<T> >
 
 } // namespace detail
 
-template< typename T > struct is_recursive_wrapper
-    : public ::boost::integral_constant<bool,(::boost::detail::is_recursive_wrapper_impl<T>::value)>
-{
-public:
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_recursive_wrapper,(T))
-};
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(
+      is_recursive_wrapper
+    , T
+    , (::boost::detail::is_recursive_wrapper_impl<T>::value)
+    )
 
 ///////////////////////////////////////////////////////////////////////////////
 // metafunction unwrap_recursive
@@ -127,4 +98,6 @@ struct unwrap_recursive< recursive_wrapper<T> >
 
 } // namespace boost
 
+#include "boost/type_traits/detail/bool_trait_undef.hpp"
+
 #endif // BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP

include/boost/variant/static_visitor.hpp

@@ -13,14 +13,14 @@
 #ifndef BOOST_VARIANT_STATIC_VISITOR_HPP
 #define BOOST_VARIANT_STATIC_VISITOR_HPP
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
 
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
+#include "boost/mpl/if.hpp"
+#include "boost/type_traits/is_base_and_derived.hpp"
 
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/mpl/aux_/lambda_support.hpp>
+// should be the last #include
+#include "boost/type_traits/detail/bool_trait_def.hpp"
 
 namespace boost {
 
@@ -48,10 +48,12 @@ public: // typedefs
     typedef R result_type;
 
 protected: // for use as base class only
-#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)
+#ifndef BOOST_NO_DEFAULTED_FUNCTIONS
     static_visitor() = default;
+    ~static_visitor() = default;
 #else
     static_visitor()  BOOST_NOEXCEPT { }
+    ~static_visitor()  BOOST_NOEXCEPT { }
 #endif
 };
 
@@ -81,13 +83,14 @@ struct is_static_visitor_impl
 
 } // namespace detail
 
-template< typename T > struct is_static_visitor
-  : public ::boost::integral_constant<bool,(::boost::detail::is_static_visitor_impl<T>::value)>
-{
-public:
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_static_visitor,(T))
-};
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(
+      is_static_visitor
+    , T
+    , (::boost::detail::is_static_visitor_impl<T>::value)
+    )
 
 } // namespace boost
 
+#include "boost/type_traits/detail/bool_trait_undef.hpp"
+
 #endif // BOOST_VARIANT_STATIC_VISITOR_HPP

include/boost/variant/variant_fwd.hpp

@@ -4,7 +4,7 @@
 //-----------------------------------------------------------------------------
 //
 // Copyright (c) 2003 Eric Friedman, Itay Maman
-// Copyright (c) 2013-2026 Antony Polukhin
+// Copyright (c) 2013 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,17 +13,47 @@
 #ifndef BOOST_VARIANT_VARIANT_FWD_HPP
 #define BOOST_VARIANT_VARIANT_FWD_HPP
 
-#include <boost/variant/detail/config.hpp>
+#include "boost/variant/detail/config.hpp"
 
-#include <boost/blank_fwd.hpp>
-#include <boost/mpl/arg.hpp>
-#include <boost/mpl/limits/arity.hpp>
-#include <boost/mpl/aux_/na.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/enum.hpp>
-#include <boost/preprocessor/enum_params.hpp>
-#include <boost/preprocessor/enum_shifted_params.hpp>
-#include <boost/preprocessor/repeat.hpp>
+#include "boost/blank_fwd.hpp"
+#include "boost/mpl/arg.hpp"
+#include "boost/mpl/limits/arity.hpp"
+#include "boost/mpl/aux_/na.hpp"
+#include "boost/preprocessor/cat.hpp"
+#include "boost/preprocessor/enum.hpp"
+#include "boost/preprocessor/enum_params.hpp"
+#include "boost/preprocessor/enum_shifted_params.hpp"
+#include "boost/preprocessor/repeat.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_LIMIT_TYPES
+//
+// Implementation-defined preprocessor symbol describing the actual
+// length of variant's pseudo-variadic template parameter list.
+//
+#include "boost/mpl/limits/list.hpp"
+#define BOOST_VARIANT_LIMIT_TYPES \
+    BOOST_MPL_LIMIT_LIST_SIZE
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_NO_REFERENCE_SUPPORT
+//
+// Defined if variant does not support references as bounded types. 
+//
+#if defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING) \
+ && !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND) \
+ && !defined(BOOST_VARIANT_NO_REFERENCE_SUPPORT)
+#   define BOOST_VARIANT_NO_REFERENCE_SUPPORT
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT
+//
+// Defined if variant does not support make_variant_over (see below). 
+//
+#if defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+#   define BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // macro BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT
@@ -34,8 +64,14 @@
 // so only types declared w/ MPL lambda workarounds will work.
 //
 
-#include <boost/variant/detail/substitute_fwd.hpp>
+#include "boost/variant/detail/substitute_fwd.hpp"
 
+#if defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) \
+ && !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)
+#   define BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT
+#endif
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && defined(BOOST_VARIANT_USE_VARIADIC_TEMPLATES)
 #include <boost/preprocessor/seq/size.hpp>
 
 #define BOOST_VARIANT_CLASS_OR_TYPENAME_TO_SEQ_class class)(
@@ -68,6 +104,9 @@
 // Rationale: Cleaner, simpler code for clients of variant library. Minimal 
 // code modifications to move from C++03 to C++11.
 //
+// Without !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && defined(BOOST_VARIANT_USE_VARIADIC_TEMPLATES)
+// will be used BOOST_VARIANT_ENUM_PARAMS and BOOST_VARIANT_ENUM_SHIFTED_PARAMS from below `#else`
+//
 
 #define BOOST_VARIANT_ENUM_PARAMS(x) \
     x ## 0, \
@@ -78,6 +117,38 @@
     BOOST_VARIANT_MAKE_VARIADIC( (BOOST_VARIANT_CLASS_OR_TYPENAME_TO_SEQ_ ## x), x) \
     /**/
 
+#else 
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_RECURSIVE_VARIANT_MAX_ARITY
+//
+// Exposes maximum allowed arity of class templates with recursive_variant
+// arguments. That is,
+//   make_recursive_variant< ..., T<[1], recursive_variant_, ... [N]> >.
+//
+#include "boost/mpl/limits/arity.hpp"
+#define BOOST_VARIANT_RECURSIVE_VARIANT_MAX_ARITY \
+    BOOST_MPL_LIMIT_METAFUNCTION_ARITY
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_ENUM_PARAMS
+//
+// Convenience macro for enumeration of BOOST_VARIANT_LIMIT_TYPES params.
+//
+// Rationale: Cleaner, simpler code for clients of variant library.
+//
+#define BOOST_VARIANT_ENUM_PARAMS( param )  \
+    BOOST_PP_ENUM_PARAMS(BOOST_VARIANT_LIMIT_TYPES, param)
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_ENUM_SHIFTED_PARAMS
+//
+// Convenience macro for enumeration of BOOST_VARIANT_LIMIT_TYPES-1 params.
+//
+#define BOOST_VARIANT_ENUM_SHIFTED_PARAMS( param )  \
+    BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_VARIANT_LIMIT_TYPES, param)
+
+#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
 
 namespace boost {
 
@@ -109,10 +180,78 @@ struct convert_void< void_ >
     typedef mpl::na type;
 };
 
+///////////////////////////////////////////////////////////////////////////////
+// (workaround) BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
+//
+// Needed to work around compilers that don't support using-declaration
+// overloads. (See the variant::initializer workarounds below.)
+//
+
+#if defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+// (detail) tags voidNN -- NN defined on [0, BOOST_VARIANT_LIMIT_TYPES)
+//
+// Defines void types that are each unique and specializations of
+// convert_void that yields mpl::na for each voidNN type.
+//
+
+#define BOOST_VARIANT_DETAIL_DEFINE_VOID_N(z,N,_)          \
+    struct BOOST_PP_CAT(void,N);                           \
+                                                           \
+    template <>                                            \
+    struct convert_void< BOOST_PP_CAT(void,N) >            \
+    {                                                      \
+        typedef mpl::na type;                              \
+    };                                                     \
+    /**/
+
+BOOST_PP_REPEAT(
+      BOOST_VARIANT_LIMIT_TYPES
+    , BOOST_VARIANT_DETAIL_DEFINE_VOID_N
+    , _
+    )
+
+#undef BOOST_VARIANT_DETAIL_DEFINE_VOID_N
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
 }} // namespace detail::variant
 
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && defined(BOOST_VARIANT_USE_VARIADIC_TEMPLATES)
+
 #define BOOST_VARIANT_AUX_DECLARE_PARAMS BOOST_VARIANT_ENUM_PARAMS(typename T)
 
+#else
+///////////////////////////////////////////////////////////////////////////////
+// (detail) macro BOOST_VARIANT_AUX_DECLARE_PARAM
+//
+// Template parameter list for variant and recursive_variant declarations.
+//
+
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+#   define BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL(z, N, T) \
+    typename BOOST_PP_CAT(T,N) = detail::variant::void_ \
+    /**/
+
+#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+#   define BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL(z, N, T) \
+    typename BOOST_PP_CAT(T,N) = BOOST_PP_CAT(detail::variant::void,N) \
+    /**/
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
+#define BOOST_VARIANT_AUX_DECLARE_PARAMS \
+    BOOST_PP_ENUM( \
+          BOOST_VARIANT_LIMIT_TYPES \
+        , BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL \
+        , T \
+        ) \
+    /**/
+
+#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
 ///////////////////////////////////////////////////////////////////////////////
 // class template variant (concept inspired by Andrei Alexandrescu)
 //

include/boost/variant/visitor_ptr.hpp

@@ -13,15 +13,15 @@
 #ifndef BOOST_VARIANT_VISITOR_PTR_HPP
 #define BOOST_VARIANT_VISITOR_PTR_HPP
 
-#include <boost/variant/bad_visit.hpp>
-#include <boost/variant/static_visitor.hpp>
+#include "boost/variant/bad_visit.hpp"
+#include "boost/variant/static_visitor.hpp"
 
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/is_void.hpp>
+#include "boost/mpl/eval_if.hpp"
+#include "boost/mpl/identity.hpp"
+#include "boost/throw_exception.hpp"
+#include "boost/type_traits/add_reference.hpp"
+#include "boost/type_traits/is_reference.hpp"
+#include "boost/type_traits/is_void.hpp"
 
 namespace boost {
 
@@ -68,6 +68,8 @@ public: // static visitor interfaces
         boost::throw_exception(bad_visit());
     }
 
+#if !defined(BOOST_NO_VOID_RETURNS)
+
 public: // static visitor interfaces, cont.
 
     result_type operator()(argument_fwd_type operand) const
@@ -75,6 +77,33 @@ public: // static visitor interfaces, cont.
         return visitor_(operand);
     }
 
+#else // defined(BOOST_NO_VOID_RETURNS)
+
+private: // helpers, for static visitor interfaces (below)
+
+    result_type execute_impl(argument_fwd_type operand, mpl::false_) const
+    {
+        return visitor_(operand);
+    }
+
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    execute_impl(argument_fwd_type operand, mpl::true_) const
+    {
+        visitor_(operand);
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+public: // static visitor interfaces, cont.
+
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(argument_fwd_type operand) const
+    {
+        typedef typename is_void<result_type>::type has_void_result;
+        return execute_impl(operand, has_void_result());
+    }
+
+#endif // BOOST_NO_VOID_RETURNS workaround
+
 };
 
 template <typename R, typename T>

index.html

@@ -1,35 +1,9 @@
-<!DOCTYPE html>
-<!--
- Copyright 2014-2026 Antony Polukhin
- antoshkka at gmail dot com
-
- 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)
--->
 <html>
 <head>
-<meta charset="utf-8">
 <meta http-equiv="refresh" content="0; URL=../../doc/html/variant.html">
-<title>Boost.Variant</title>
-<style>
-  body {
-    background: #fff;
-    color: #000;
-  }
-  a {
-    color: #00f;
-    text-decoration: none;
-  }
-</style>
 </head>
 <body>
-  <p>
-    Automatic redirection failed, please go to
-    <a href="../../doc/html/variant.html">../../doc/html/variant.html</a>
-  </p>
-  <p>
-    &copy; 2014-2024 Antony Polukhin
-  </p>
+Automatic redirection failed, please go to
+<a href="../../doc/html/variant.html">../../doc/html/variant.html</a>
 </body>
 </html>

meta/libraries.json

@@ -1,18 +0,0 @@
-{
-    "key": "variant",
-    "name": "Variant",
-    "authors": [
-        "Eric Friedman",
-        "Itay Maman"
-    ],
-    "description": "Safe, generic, stack-based discriminated union container.",
-    "category": [
-        "Containers",
-        "Data"
-    ],
-    "maintainers": [
-        "Antony Polukhin <antoshkka -at- gmail.com>",
-        "Eric Friedman <ericbrandon -at- gmail.com>"
-    ],
-    "cxxstd": "11"
-}

perf/Jamfile.v2

@@ -1,5 +1,5 @@
 #==============================================================================
-#   Copyright (c) 2012-2026 Antony Polukhin
+#   Copyright (c) 2012 Antony Polukhin
 #
 #   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)

perf/move_perf.cpp

@@ -1,4 +1,4 @@
-//  (C) Copyright Antony Polukhin 2012-2021.
+//  (C) Copyright Antony Polukhin 2012.
 //  Use, modification and distribution are 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)
@@ -75,7 +75,7 @@ static void do_test(bool do_count_cleanup_time = false) {
     {
         scope sc("boost::variant(variant&&) moving speed");
         for (std::size_t i = 0; i < c_run_count; ++i) {
-            data_to.push_back(boost::move(data_from[i]));
+            data_to.push_back(std::move(data_from[i]));
         }
 
         if (do_count_cleanup_time) {
@@ -108,7 +108,7 @@ static void do_test(bool do_count_cleanup_time = false) {
     {
         scope sc("boost::variant=(variant&&) moving speed on same types");
         for (std::size_t i = 0; i < c_run_count; ++i) {
-            data_to[i] = boost::move(data_from[i]); 
+            data_to[i] = std::move(data_from[i]); 
         }
 
         if (do_count_cleanup_time) {
@@ -142,7 +142,7 @@ static void do_test(bool do_count_cleanup_time = false) {
     {
         scope sc("boost::variant=(variant&&) moving speed on different types");
         for (std::size_t i = 0; i < c_run_count; ++i) {
-            data_to[i] = boost::move(data_from[i]); 
+            data_to[i] = std::move(data_from[i]); 
         }
 
         if (do_count_cleanup_time) {
@@ -176,7 +176,7 @@ static void do_test(bool do_count_cleanup_time = false) {
     {
         scope sc("boost::variant=(variant&&) moving speed on different types II");
         for (std::size_t i = 0; i < c_run_count; ++i) {
-            data_to[i] = boost::move(data_from[i]); 
+            data_to[i] = std::move(data_from[i]); 
         }
 
         if (do_count_cleanup_time) {
@@ -210,7 +210,7 @@ static void do_test(bool do_count_cleanup_time = false) {
     {
         scope sc("boost::variant=(T&&) moving speed");
         for (std::size_t i = 0; i < c_run_count; ++i) {
-            data_to[i] = boost::move(s2[i]);
+            data_to[i] = std::move(s2[i]);
         }
 
         if (do_count_cleanup_time) {
@@ -222,13 +222,6 @@ static void do_test(bool do_count_cleanup_time = false) {
 
 
 int main () {
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    std::cout << "# Running tests in C++11 mode (with rvalues).\n";
-#else
-    std::cout << "# Running tests in C++03 mode (without rvalues).\n";
-#endif
-
     do_test(false);
     do_test(true);
 }

test/Jamfile.v2

@@ -1,53 +1,48 @@
 #  Boost.Variant Library test Jamfile
 #
 #  Copyright (C) 2003, Eric Friedman, Itay Maman.
-#  Copyright (C) 2013-2026 Antony Polukhin.
+#  Copyright (C) 2013, Antony Polukhin.
 #
-# 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)
+#  This material is provided "as is", with absolutely no warranty expressed
+#  or implied. Any use is at your own risk.
+#
+#  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.
 #
-
-require-b2 5.0.1 ;
-import-search /boost/config/checks ;
-import config : requires ;
-import testing ;
-
-local below_cpp14 = 98 03 0x 11 ;
-local since_cpp20 = 2a 20 latest ;
-
 project
     : requirements
-        <library>/boost/variant//boost_variant
-        [ requires cxx11_rvalue_references ]
+        #<dependency>/boost/test//minimal
         <toolset>msvc:<asynch-exceptions>on
+        <toolset>gcc-4.8:<cxxflags>-DBOOST_VARIANT_USE_VARIADIC_TEMPLATES
+        <toolset>gcc-4.9:<cxxflags>-DBOOST_VARIANT_USE_VARIADIC_TEMPLATES
+        <toolset>clang-3.0:<cxxflags>-DBOOST_VARIANT_USE_VARIADIC_TEMPLATES
+        <toolset>clang-3.1:<cxxflags>-DBOOST_VARIANT_USE_VARIADIC_TEMPLATES
+        <toolset>clang-3.2:<cxxflags>-DBOOST_VARIANT_USE_VARIADIC_TEMPLATES
+        <toolset>clang-3.3:<cxxflags>-DBOOST_VARIANT_USE_VARIADIC_TEMPLATES
+        <toolset>clang-3.4:<cxxflags>-DBOOST_VARIANT_USE_VARIADIC_TEMPLATES
     ;
+    
 test-suite variant
-     :
+     : 
     [ run test1.cpp class_a.cpp : : : : variant_test1 ]
     [ run test2.cpp : : : : variant_test2 ]
     [ run test3.cpp : : : : variant_test3 ]
-    [ run test3.cpp : : : <rtti>off <define>BOOST_NO_RTTI <define>BOOST_NO_TYPEID : variant_test3_no_rtti ]
-    [ run test4.cpp class_a.cpp : : : : variant_test4 ]
+    [ run test4.cpp class_a.cpp 
+        : : : : variant_test4 ]
     [ run test5.cpp : : : : variant_test5 ]
     [ run test6.cpp : : : : variant_test6 ]
     [ run test7.cpp : : : : variant_test7 ]
     [ run test8.cpp : : : : variant_test8 ]
-    [ run test9.cpp : : : <library>/boost/fusion//boost_fusion : variant_test9 ]
     [ run recursive_variant_test.cpp ]
     [ run variant_reference_test.cpp ]
     [ run variant_comparison_test.cpp ]
-    [ run variant_visit_internal_linkage.cpp : : : "<cxxstd>$(below_cpp14)"\:<build>no ]
     [ run variant_visit_test.cpp ]
-    [ run variant_get_test.cpp ]
-    [ compile-fail variant_rvalue_get_with_ampersand_test.cpp ]
-    [ compile-fail no_rvalue_to_nonconst_visitation.cpp ]
-    [ compile fusion_interop.cpp : <library>/boost/fusion//boost_fusion ]
-    [ run variant_polymorphic_get_test.cpp ]
     [ run variant_multivisit_test.cpp ]
     [ run hash_variant_test.cpp ]
     [ run rvalue_test.cpp ]
-    [ run variant_nonempty_check.cpp ]
     [ run recursive_variant_test.cpp : : : <define>BOOST_NO_EXCEPTIONS
       <toolset>gcc-4.3:<cxxflags>-fno-exceptions
       <toolset>gcc-4.4:<cxxflags>-fno-exceptions
@@ -58,16 +53,7 @@ test-suite variant
       <toolset>clang:<cxxflags>-fno-exceptions
       : variant_noexcept_test
     ]
-    [ run recursive_variant_test.cpp : : : <rtti>off <define>BOOST_NO_RTTI <define>BOOST_NO_TYPEID : variant_no_rtti_test ]
-    [ run hash_recursive_variant_test.cpp ]
     [ run variant_swap_test.cpp ]
-    [ run auto_visitors.cpp : : : <library>/boost/lexical_cast//boost_lexical_cast ]
-    [ run issue42.cpp ]
-    [ compile issue53.cpp : <library>/boost/thread//boost_thread ]
-    [ run overload_selection.cpp : : : "<cxxstd>$(since_cpp20)"\:<build>no ]
-    [ run recursive_wrapper_move_test.cpp : : : <library>/boost/array//boost_array ]
-    [ run variant_over_joint_view_test.cpp ]
-    [ run const_ref_apply_visitor.cpp : : : <library>/boost/lexical_cast//boost_lexical_cast ]
-   ;
+   ; 
 
 

test/appveyor.yml

@@ -1,92 +0,0 @@
-# Use, modification, and distribution are
-# 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)
-#
-# Copyright Antony Polukhin 2016-2021.
-
-#
-# See https://svn.boost.org/trac/boost/wiki/TravisCoverals for description of this file
-# and how it can be used with Boost libraries.
-#
-# File revision #7
-
-init:
-    # boost-local/libs/ folder to put this library into. This may be useful, if you're for example running Travis
-    # from `Boost.DLL` repo while Boost already has `dll` and with to replace `dll` with content of`Boost.DLL`.
-    #
-    # Otherwise just leave the default value - set BOOST_LIBS_FOLDER=%APPVEYOR_PROJECT_NAME%
-    - set BOOST_LIBS_FOLDER=%APPVEYOR_PROJECT_NAME%
-
-###############################################################################################################
-# From this point and below code is same for all the Boost libs
-###############################################################################################################
-
-version: 1.71.{build}-{branch}
- 
-# branches to build
-branches:
-  except:
-    - gh-pages
-
-skip_tags: true
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1,clang-win
-      CXXSTD: 14,17
-      ADDRMD: 32,64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ADDPATH: C:\cygwin\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ADDPATH: C:\cygwin64\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-      VARIANT: release          # "variant_get_test.o: File too big" errors in debug
-    # MinGW 32-bit is not supported by Boost.System any more
-    # - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-    #  ADDPATH: C:\mingw\bin;
-    #  TOOLSET: gcc
-    #  CXXSTD: 03,11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ADDPATH: C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-      VARIANT: release          # "variant_get_test.o: File too big" errors in debug
-
-before_build:
-    - set BOOST_BRANCH=develop
-    - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
-    - echo "Testing %APPVEYOR_PROJECT_NAME%"
-    # Cloning Boost libraries (fast nondeep cloning)
-    - set BOOST=C:/boost-local
-    - git clone -b %BOOST_BRANCH% --depth 10 https://github.com/boostorg/boost.git %BOOST%
-    - cd %BOOST%
-    - git submodule update --init --depth 10 tools/build tools/boostdep
-
-    - rm -rf %BOOST%/libs/%BOOST_LIBS_FOLDER%
-    - mv -f %APPVEYOR_BUILD_FOLDER% %BOOST%/libs/%BOOST_LIBS_FOLDER%
-    - python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 2" %BOOST_LIBS_FOLDER%
-
-build_script:
-    - cmd /c bootstrap
-    - b2.exe headers
-    - cd %BOOST%/libs/%BOOST_LIBS_FOLDER%/test
-
-after_build:
-before_test:
-test_script:
-  - PATH=%ADDPATH%%PATH%
-  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - if "%VARIANT%"== "" set VARIANT=debug,release
-  - set VARIANT=variant=%VARIANT%
-  - echo "Running command ..\..\..\b2 -j3 toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release"
-  - ..\..\..\b2.exe -j3 toolset=%TOOLSET% %CXXSTD% %ADDRMD% %VARIANT% cxxflags="-DBOOST_TRAVISCI_BUILD"
-
-after_test:
-on_success:
-on_failure:
-on_finish:

test/auto_visitors.cpp

@@ -1,370 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost-libs variant/test/auto_visitors.cpp source file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2014-2026 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#include "boost/config.hpp"
-
-#include "boost/core/lightweight_test.hpp"
-#include "boost/variant.hpp"
-#include "boost/variant/multivisitors.hpp"
-#include "boost/lexical_cast.hpp"
-
-#include <boost/noncopyable.hpp>
-#include <boost/core/ignore_unused.hpp>
-
-namespace has_result_type_tests {
-    template <class T>
-    struct wrap {
-        typedef T result_type;
-    };
-
-    struct s1 : wrap<int> {};
-    struct s2 : wrap<int&> {};
-    struct s3 : wrap<const int&> {};
-    struct s4 {};
-    struct s5 : wrap<int*> {};
-    struct s6 : wrap<int**> {};
-    struct s7 : wrap<const int*> {};
-    struct s8 : wrap<boost::noncopyable> {};
-    struct s9 : wrap<boost::noncopyable&> {};
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    struct s10 : wrap<boost::noncopyable&&> {};
-#endif
-    struct s11 : wrap<const boost::noncopyable&> {};
-    struct s12 : wrap<const boost::noncopyable*> {};
-    struct s13 : wrap<boost::noncopyable*> {};
-    struct s14 { typedef int result_type; };
-    struct s15 { typedef int& result_type; };
-    struct s16 { typedef const int& result_type; };
-}
-
-
-void test_has_result_type_triat() {
-    using namespace has_result_type_tests;
-    using boost::detail::variant::has_result_type;
-
-    BOOST_TEST(has_result_type<s1>::value);
-    BOOST_TEST(has_result_type<s2>::value);
-    BOOST_TEST(has_result_type<s3>::value);
-    BOOST_TEST(!has_result_type<s4>::value);
-    BOOST_TEST(has_result_type<s5>::value);
-    BOOST_TEST(has_result_type<s6>::value);
-    BOOST_TEST(has_result_type<s7>::value);
-    BOOST_TEST(has_result_type<s8>::value);
-    BOOST_TEST(has_result_type<s9>::value);
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    BOOST_TEST(has_result_type<s10>::value);
-#endif
-    BOOST_TEST(has_result_type<s11>::value);
-    BOOST_TEST(has_result_type<s12>::value);
-    BOOST_TEST(has_result_type<s13>::value);
-    BOOST_TEST(has_result_type<s14>::value);
-    BOOST_TEST(has_result_type<s15>::value);
-    BOOST_TEST(has_result_type<s16>::value);
-}
-
-struct lex_streamer_explicit: boost::static_visitor<std::string> {
-    template <class T>
-    const char* operator()(const T& ) {
-        return "10";
-    }
-
-    template <class T1, class T2>
-    const char* operator()(const T1& , const T2& ) {
-        return "100";
-    }
-};
-
-
-void run_explicit()
-{
-    typedef boost::variant<int, std::string, double> variant_type;
-    variant_type v2("10"), v1("100");
-
-    lex_streamer_explicit visitor_ref;
-
-    // Must return instance of std::string
-    BOOST_TEST(boost::apply_visitor(visitor_ref, v2).c_str() == std::string("10"));
-    BOOST_TEST(boost::apply_visitor(visitor_ref, v2, v1).c_str() == std::string("100"));
-}
-
-
-// Most part of tests from this file require decltype(auto)
-
-#ifdef BOOST_NO_CXX14_DECLTYPE_AUTO
-
-void run()
-{
-    BOOST_TEST(true);
-}
-
-void run2()
-{
-    BOOST_TEST(true);
-}
-
-
-void run3()
-{
-    BOOST_TEST(true);
-}
-
-#else
-
-#include <iostream>
-
-struct lex_streamer {
-    template <class T>
-    std::string operator()(const T& val) const {
-        return boost::lexical_cast<std::string>(val);
-    }
-};
-
-struct lex_streamer_void {
-    template <class T>
-    void operator()(const T& val) const {
-        std::cout << val << std::endl;
-    }
-
-
-    template <class T1, class T2>
-    void operator()(const T1& val, const T2& val2) const {
-        std::cout << val << '+' << val2 << std::endl;
-    }
-
-
-    template <class T1, class T2, class T3>
-    void operator()(const T1& val, const T2& val2, const T3& val3) const {
-        std::cout << val << '+' << val2 << '+' << val3 << std::endl;
-    }
-};
-
-
-struct lex_streamer2 {
-    std::string res;
-
-    template <class T>
-    const char* operator()(const T& /*val*/) const {
-        return "fail";
-    }
-
-    template <class T1, class T2>
-    const char* operator()(const T1& /*v1*/, const T2& /*v2*/) const {
-        return "fail2";
-    }
-
-
-    template <class T1, class T2, class T3>
-    const char* operator()(const T1& /*v1*/, const T2& /*v2*/, const T3& /*v3*/) const {
-        return "fail3";
-    }
-
-    template <class T>
-    std::string& operator()(const T& val) {
-        res = boost::lexical_cast<std::string>(val);
-        return res;
-    }
-
-
-    template <class T1, class T2>
-    std::string& operator()(const T1& v1, const T2& v2) {
-        res = boost::lexical_cast<std::string>(v1) + "+" + boost::lexical_cast<std::string>(v2);
-        return res;
-    }
-
-
-    template <class T1, class T2, class T3>
-    std::string& operator()(const T1& v1, const T2& v2, const T3& v3) {
-        res = boost::lexical_cast<std::string>(v1) + "+" + boost::lexical_cast<std::string>(v2) 
-            + "+" + boost::lexical_cast<std::string>(v3);
-        return res;
-    }
-};
-
-void run()
-{
-    typedef boost::variant<int, std::string, double> variant_type;
-    variant_type v1(1), v2("10"), v3(100.0);
-    lex_streamer lex_streamer_visitor;
-
-    BOOST_TEST(boost::apply_visitor(lex_streamer(), v1) == "1");
-    BOOST_TEST(boost::apply_visitor(lex_streamer_visitor)(v1) == "1");
-    BOOST_TEST(boost::apply_visitor(lex_streamer(), v2) == "10");
-    BOOST_TEST(boost::apply_visitor(lex_streamer_visitor)(v2) == "10");
-
-    #ifndef BOOST_NO_CXX14_GENERIC_LAMBDAS
-        BOOST_TEST(boost::apply_visitor([](auto v) { return boost::lexical_cast<std::string>(v); }, v1) == "1");
-        BOOST_TEST(boost::apply_visitor([](auto v) { return boost::lexical_cast<std::string>(v); }, v2) == "10");
-
-        // Retun type must be the same in all instances, so this code does not compile
-        //boost::variant<int, short, unsigned> v_diff_types(1);
-        //BOOST_TEST(boost::apply_visitor([](auto v) { return v; }, v_diff_types) == 1);
-
-        boost::apply_visitor([](auto v) { std::cout << v << std::endl; }, v1);
-        boost::apply_visitor([](auto v) { std::cout << v << std::endl; }, v2);
-    #endif
-
-    lex_streamer2 visitor_ref;
-    BOOST_TEST(boost::apply_visitor(visitor_ref, v1) == "1");
-    BOOST_TEST(boost::apply_visitor(visitor_ref, v2) == "10");
-
-    std::string& ref_to_string = boost::apply_visitor(visitor_ref, v1);
-    BOOST_TEST(ref_to_string == "1");
-
-    lex_streamer_void lex_streamer_void_visitor;
-    boost::apply_visitor(lex_streamer_void(), v1);
-    boost::apply_visitor(lex_streamer_void(), v2);
-
-    boost::apply_visitor(lex_streamer_void_visitor)(v2);
-
-
-    boost::ignore_unused(lex_streamer_visitor, visitor_ref, lex_streamer_void_visitor);
-}
-
-
-struct lex_combine {
-    template <class T1, class T2>
-    std::string operator()(const T1& v1, const T2& v2) const {
-        return boost::lexical_cast<std::string>(v1) + "+" + boost::lexical_cast<std::string>(v2);
-    }
-
-
-    template <class T1, class T2, class T3>
-    std::string operator()(const T1& v1, const T2& v2, const T3& v3) const {
-        return boost::lexical_cast<std::string>(v1) + "+" 
-                + boost::lexical_cast<std::string>(v2) + '+'
-                + boost::lexical_cast<std::string>(v3);
-    }
-};
-
-void run2()
-{
-    typedef boost::variant<int, std::string, double> variant_type;
-    variant_type v1(1), v2("10"), v3(100.0);
-    lex_combine lex_combine_visitor;
-
-    BOOST_TEST(boost::apply_visitor(lex_combine(), v1, v2) == "1+10");
-    BOOST_TEST(boost::apply_visitor(lex_combine(), v2, v1) == "10+1");
-    BOOST_TEST(boost::apply_visitor(lex_combine_visitor)(v2, v1) == "10+1");
-
-
-    #ifndef BOOST_NO_CXX14_GENERIC_LAMBDAS
-        BOOST_TEST(
-            boost::apply_visitor(
-                [](auto v1, auto v2) {
-                    return boost::lexical_cast<std::string>(v1) + "+"
-                        + boost::lexical_cast<std::string>(v2);
-                }
-                , v1
-                , v2
-            ) == "1+10"
-        );
-        BOOST_TEST(
-            boost::apply_visitor(
-                [](auto v1, auto v2) {
-                    return boost::lexical_cast<std::string>(v1) + "+"
-                        + boost::lexical_cast<std::string>(v2);
-                }
-                , v2
-                , v1
-            ) == "10+1"
-        );
-
-        boost::apply_visitor([](auto v1, auto v2) { std::cout << v1 << '+' << v2 << std::endl; }, v1, v2);
-        boost::apply_visitor([](auto v1, auto v2) { std::cout << v1 << '+' << v2 << std::endl; }, v2, v1);
-    #endif
-
-
-    lex_streamer2 visitor_ref;
-    BOOST_TEST(boost::apply_visitor(visitor_ref, v1, v2) == "1+10");
-    BOOST_TEST(boost::apply_visitor(visitor_ref, v2, v1) == "10+1");
-
-    std::string& ref_to_string = boost::apply_visitor(visitor_ref)(v1, v2);
-    BOOST_TEST(ref_to_string == "1+10");
-
-    boost::apply_visitor(lex_streamer_void(), v1, v2);
-    boost::apply_visitor(lex_streamer_void(), v2, v1);
-
-    boost::ignore_unused(lex_combine_visitor, visitor_ref);
-}
-
-void run3()
-{
-    typedef boost::variant<int, std::string, double> variant_type;
-    variant_type v1(1), v2("10"), v3(100);
-    lex_combine lex_combine_visitor;
-
-    BOOST_TEST(boost::apply_visitor(lex_combine(), v1, v2, v3) == "1+10+100");
-    BOOST_TEST(boost::apply_visitor(lex_combine(), v2, v1, v3) == "10+1+100");
-    BOOST_TEST(boost::apply_visitor(lex_combine_visitor)(v2, v1, v3) == "10+1+100");
-
-
-    #ifndef BOOST_NO_CXX14_GENERIC_LAMBDAS
-        BOOST_TEST(
-            boost::apply_visitor(
-                [](auto v1, auto v2, auto v3) {
-                    return boost::lexical_cast<std::string>(v1) + "+"
-                        + boost::lexical_cast<std::string>(v2) + "+"
-                        + boost::lexical_cast<std::string>(v3);
-                }
-                , v1
-                , v2
-                , v3
-            ) == "1+10+100"
-        );
-        BOOST_TEST(
-            boost::apply_visitor(
-                [](auto v1, auto v2, auto v3) {
-                    return boost::lexical_cast<std::string>(v1) + "+"
-                        + boost::lexical_cast<std::string>(v2) + "+"
-                        + boost::lexical_cast<std::string>(v3);
-                }
-                , v3
-                , v1
-                , v3
-            ) == "100+1+100"
-        );
-
-        boost::apply_visitor(
-            [](auto v1, auto v2, auto v3) { std::cout << v1 << '+' << v2 << '+' << v3 << std::endl; }, 
-            v1, v2, v3
-        );
-        boost::apply_visitor(
-            [](auto v1, auto v2, auto v3) { std::cout << v1 << '+' << v2 << '+' << v3 << std::endl; },
-            v2, v1, v3
-        );
-    #endif
-
-
-    lex_streamer2 visitor_ref;
-    BOOST_TEST(boost::apply_visitor(visitor_ref, v1, v2) == "1+10");
-    BOOST_TEST(boost::apply_visitor(visitor_ref)(v2, v1) == "10+1");
-    std::string& ref_to_string = boost::apply_visitor(visitor_ref, v1, v2);
-    BOOST_TEST(ref_to_string == "1+10");
-
-    lex_streamer_void lex_streamer_void_visitor;
-    boost::apply_visitor(lex_streamer_void(), v1, v2, v1);
-    boost::apply_visitor(lex_streamer_void(), v2, v1, v1);
-    boost::apply_visitor(lex_streamer_void_visitor)(v2, v1, v1);
-
-}
-#endif
-
-
-int main()
-{
-    run_explicit();
-    run();
-    run2();
-    run3();
-    test_has_result_type_triat();
-
-    return boost::report_errors();
-}

test/class_a.cpp

@@ -13,8 +13,7 @@
 #include <algorithm> // for std::swap
 #include <sstream>
 #include <iostream>
-
-#include <boost/assert.hpp>
+#include <assert.h>
 
 #include "class_a.h"
 
@@ -23,7 +22,7 @@ using namespace std;
 
 class_a::~class_a()
 {
-   BOOST_ASSERT(self_p_ == this);
+   assert(self_p_ == this);
 }
 
 class_a::class_a(int n)

test/const_ref_apply_visitor.cpp

@@ -1,334 +0,0 @@
-// Copyright (c) 2017 Levon Tarakchyan
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#include "boost/config.hpp"
-
-#include "boost/core/lightweight_test.hpp"
-#include "boost/variant.hpp"
-#include "boost/variant/apply_visitor.hpp"
-#include "boost/variant/multivisitors.hpp"
-#include "boost/lexical_cast.hpp"
-
-#define lcs(val) boost::lexical_cast<std::string>(val)
-
-struct construction_logger
-{
-    int val_;
-
-    construction_logger(int val) : val_(val)
-    {
-        std::cout << val_ << " constructed\n";
-    }
-
-    construction_logger(const construction_logger& cl) :
-        val_(cl.val_)
-    {
-        std::cout << val_ << " copy constructed\n";
-    }
-
-    construction_logger(construction_logger&& cl) :
-        val_(cl.val_)
-    {
-        std::cout << val_ << " move constructed\n";
-    }
-
-    friend std::ostream& operator << (std::ostream& os, const construction_logger& cl)
-    {
-        return os << cl.val_;
-    }
-
-    friend std::istream& operator << (std::istream& is, construction_logger& cl)
-    {
-        return is >> cl.val_;
-    }
-};
-
-struct lex_streamer_explicit : boost::static_visitor<std::string>
-{
-    template <class T>
-    std::string operator()(const T& val) const
-    {
-        return lcs(val);
-    }
-
-    template <class T, class V>
-    std::string operator()(const T& val, const V& val2) const
-    {
-        return lcs(val) + '+' + lcs(val2);
-    }
-
-    template <class T, class V, class P, class S>
-    std::string operator()(const T& val, const V& val2, const P& val3, const S& val4) const
-    {
-        return lcs(val) + '+' + lcs(val2) + '+' + lcs(val3) + '+' + lcs(val4);
-    }
-};
-
-struct lvalue_rvalue_detector : boost::static_visitor<std::string>
-{
-    template <class T>
-    std::string operator()(T&&) const
-    {
-        return std::is_lvalue_reference<T>::value ? "lvalue reference"
-                                                  : "rvalue reference";
-    }
-
-    template <class T, class V>
-    std::string operator()(T&& t, V&& v) const
-    {
-        return operator()(std::forward<T>(t)) + ", " + operator()(std::forward<V>(v));
-    }
-
-    template <class T, class V, class P>
-    std::string operator()(T&& t, V&& v, P&& p) const
-    {
-        return operator()(std::forward<T>(t), std::forward<V>(v)) + ", " + operator()(std::forward<P>(p));
-    }
-
-    template <class T, class V, class P, class S>
-    std::string operator()(T&& t, V&& v, P&& p, S&& s) const
-    {
-        return operator()(std::forward<T>(t), std::forward<V>(v), std::forward<P>(p)) + ", " + operator()(std::forward<S>(s));
-    }
-};
-
-typedef boost::variant<construction_logger, std::string> variant_type;
-
-void test_const_ref_parameter(const variant_type& test_var)
-{
-    std::cout << "Testing const lvalue reference visitable\n";
-
-    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), test_var) == "lvalue reference");
-}
-
-void test_const_ref_parameter2(const variant_type& test_var, const variant_type& test_var2)
-{
-    std::cout << "Testing const lvalue reference visitable\n";
-
-    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), test_var, test_var2) == "lvalue reference, lvalue reference");
-}
-
-void test_const_ref_parameter4(const variant_type& test_var, const variant_type& test_var2, const variant_type& test_var3, const variant_type& test_var4)
-{
-    std::cout << "Testing const lvalue reference visitable with multivisitor\n";
-
-    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), test_var, test_var2, test_var3, test_var4)
-            == "lvalue reference, lvalue reference, lvalue reference, lvalue reference");
-}
-
-void test_rvalue_parameter(variant_type&& test_var)
-{
-    std::cout << "Testing rvalue visitable\n";
-
-    const auto expected_val = lcs(test_var);
-    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), std::move(test_var)) == "rvalue reference");
-}
-
-void test_rvalue_parameter2(variant_type&& test_var, variant_type&& test_var2)
-{
-    std::cout << "Testing rvalue visitable\n";
-
-    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), std::move(test_var), std::move(test_var2)) == "rvalue reference, rvalue reference");
-}
-
-void test_rvalue_parameter4(variant_type&& test_var, variant_type&& test_var2, variant_type&& test_var3, variant_type&& test_var4)
-{
-    std::cout << "Testing rvalue visitable with multivisitor\n";
-
-    auto result = boost::apply_visitor(lvalue_rvalue_detector(), std::move(test_var), std::move(test_var2), std::move(test_var3), std::move(test_var4));
-    std::cout << "result: " << result << std::endl;
-    BOOST_TEST(result == "rvalue reference, rvalue reference, rvalue reference, rvalue reference");
-}
-
-#ifndef BOOST_NO_CXX14_DECLTYPE_AUTO
-
-#define FORWARD(x) std::forward<decltype(x)>(x)
-
-void test_cpp14_visitor(const variant_type& test_var)
-{
-    std::cout << "Testing const lvalue visitable for c++14\n";
-
-    BOOST_TEST(boost::apply_visitor([](auto&& v) { return lvalue_rvalue_detector()(FORWARD(v)); }, test_var) == "lvalue reference");
-}
-
-void test_cpp14_mutable_visitor(const variant_type& test_var)
-{
-    std::cout << "Testing const lvalue visitable for c++14 with inline mutable lambda\n";
-
-    BOOST_TEST(boost::apply_visitor([](auto&& v) mutable -> auto { return lvalue_rvalue_detector()(FORWARD(v)); }, test_var) == "lvalue reference");
-}
-
-void test_cpp14_visitor(const variant_type& test_var, const variant_type& test_var2)
-{
-    std::cout << "Testing const lvalue visitable for c++14\n";
-
-    BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& vv) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(vv)); }, test_var, test_var2)
-            == "lvalue reference, lvalue reference");
-}
-
-void test_cpp14_visitor(const variant_type& test_var, const variant_type& test_var2, const variant_type& test_var3)
-{
-    std::cout << "Testing const lvalue visitable for c++14\n";
-
-    auto result = boost::apply_visitor([](auto&& v, auto&& t, auto&& p) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t), FORWARD(p)); },
-                test_var, test_var2, test_var3);
-    std::cout << "result: " << result << std::endl;
-    BOOST_TEST(result == "lvalue reference, lvalue reference, lvalue reference");
-}
-
-void test_cpp14_visitor(variant_type& test_var)
-{
-    std::cout << "Testing lvalue visitable for c++14\n";
-
-    BOOST_TEST(boost::apply_visitor([](auto& v) { return lvalue_rvalue_detector()(v); }, test_var) == "lvalue reference");
-}
-
-void test_cpp14_mutable_visitor(variant_type& test_var)
-{
-    std::cout << "Testing lvalue visitable for c++14 with inline mutable lambda\n";
-
-    BOOST_TEST(boost::apply_visitor([](auto& v) mutable -> auto { return lvalue_rvalue_detector()(v); }, test_var) == "lvalue reference");
-}
-
-void test_cpp14_visitor(variant_type& test_var, variant_type& test_var2)
-{
-    std::cout << "Testing lvalue visitable for c++14\n";
-
-    BOOST_TEST(boost::apply_visitor([](auto& v, auto& vv) { return lvalue_rvalue_detector()(v, vv); }, test_var, test_var2)
-            == "lvalue reference, lvalue reference");
-}
-
-void test_cpp14_visitor(variant_type& test_var, variant_type& test_var2, variant_type& test_var3)
-{
-    std::cout << "Testing lvalue visitable for c++14\n";
-
-    auto result = boost::apply_visitor([](auto& v, auto& t, auto& p) { return lvalue_rvalue_detector()(v, t, p); },
-                test_var, test_var2, test_var3);
-    std::cout << "result: " << result << std::endl;
-    BOOST_TEST(result == "lvalue reference, lvalue reference, lvalue reference");
-}
-
-void test_cpp14_visitor(variant_type&& test_var)
-{
-    std::cout << "Testing rvalue visitable for c++14\n";
-
-    BOOST_TEST(boost::apply_visitor([](auto&& v) { return lvalue_rvalue_detector()(FORWARD(v)); }, std::move(test_var)) == "rvalue reference");
-}
-
-void test_cpp14_visitor(variant_type&& test_var, variant_type&& test_var2)
-{
-    std::cout << "Testing rvalue visitable for c++14\n";
-
-    BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& vv) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(vv)); }, std::move(test_var), std::move(test_var2))
-            == "rvalue reference, rvalue reference");
-}
-
-void test_cpp14_visitor(variant_type&& test_var, variant_type&& test_var2, variant_type&& test_var3)
-{
-    std::cout << "Testing rvalue visitable for c++14\n";
-
-    auto result = boost::apply_visitor([](auto&& v, auto&& t, auto&& p) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t), FORWARD(p)); },
-                std::move(test_var), std::move(test_var2), std::move(test_var3));
-    std::cout << "result: " << result << std::endl;
-    BOOST_TEST(result == "rvalue reference, rvalue reference, rvalue reference");
-}
-
-#endif  // #ifndef BOOST_NO_CXX14_DECLTYPE_AUTO
-
-void run_const_lvalue_ref_tests()
-{
-    const variant_type v1(1), v2(2), v3(3), v4(4);
-    test_const_ref_parameter(v1);
-    test_const_ref_parameter2(v1, v2);
-    test_const_ref_parameter4(v1, v2, v3, v4);
-}
-
-void run_rvalue_ref_tests()
-{
-    variant_type v1(10), v2(20), v3(30);
-    test_rvalue_parameter(std::move(v1));
-    test_rvalue_parameter2(std::move(v2), std::move(v3));
-
-    variant_type vv1(100), vv2(200), vv3(300), vv4(400);
-    test_rvalue_parameter4(std::move(vv1), std::move(vv2), std::move(vv3), std::move(vv4));
-}
-
-void run_mixed_tests()
-{
-    variant_type v1(1), v2(2);
-
-    std::cout << "Testing lvalue + rvalue visitable\n";
-    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), v1, variant_type(10)) == "lvalue reference, rvalue reference");
-
-    std::cout << "Testing rvalue + lvalue visitable\n";
-    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), variant_type(10), v1) == "rvalue reference, lvalue reference");
-
-    std::cout << "Testing rvalue + lvalue + rvalue visitable\n";
-    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), variant_type(10), v1, variant_type(20)) == "rvalue reference, lvalue reference, rvalue reference");
-
-    std::cout << "Testing lvalue + rvalue + lvalue + rvalue visitable\n";
-    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), v1, variant_type(10), v2, variant_type(20)) == "lvalue reference, rvalue reference, lvalue reference, rvalue reference");
-}
-
-void run_cpp14_mixed_tests()
-{
-#ifndef BOOST_NO_CXX14_DECLTYPE_AUTO
-    variant_type v1(1), v2(2);
-
-    std::cout << "Testing lvalue + rvalue visitable\n";
-    BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& t) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t)); },
-                v1, variant_type(10)) == "lvalue reference, rvalue reference");
-
-    std::cout << "Testing rvalue + lvalue visitable\n";
-    BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& t) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t)); },
-                variant_type(10), v1) == "rvalue reference, lvalue reference");
-
-    std::cout << "Testing rvalue + lvalue + lvalue visitable\n";
-    BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& t, auto&& p) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t), FORWARD(p)); },
-                variant_type(10), v1, v2) == "rvalue reference, lvalue reference, lvalue reference");
-
-    std::cout << "Testing lvalue + rvalue + lvalue visitable\n";
-    BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& t, auto&& p) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t), FORWARD(p)); },
-                v1, variant_type(10), v2) == "lvalue reference, rvalue reference, lvalue reference");
-#endif  // #ifndef BOOST_NO_CXX14_DECLTYPE_AUTO
-}
-
-void run_cpp14_tests()
-{
-#ifndef BOOST_NO_CXX14_DECLTYPE_AUTO
-    variant_type const c1(10), c2(20), c3(30);
-    variant_type v1(10), v2(20), v3(30);
-
-    test_cpp14_visitor(c1);
-    test_cpp14_mutable_visitor(c1);
-    test_cpp14_visitor(c2, c3);
-    test_cpp14_visitor(c1, c2, c3);
-
-    test_cpp14_visitor(v1);
-    test_cpp14_mutable_visitor(v1);
-    test_cpp14_visitor(v2, v3);
-    test_cpp14_visitor(v1, v2, v3);
-
-    test_cpp14_visitor(std::move(v1));
-    test_cpp14_visitor(std::move(v2), std::move(v3));
-
-    variant_type vv1(100), vv2(200), vv3(300);
-    test_cpp14_visitor(std::move(vv1), std::move(vv2), std::move(vv3));
-#endif
-}
-
-
-
-int main()
-{
-    run_const_lvalue_ref_tests();
-    run_rvalue_ref_tests();
-    run_mixed_tests();
-    run_cpp14_mixed_tests();
-    run_cpp14_tests();
-
-    return boost::report_errors();
-}

test/fusion_interop.cpp

@@ -1,29 +0,0 @@
-// Copyright (c) 2021-2026 Antony Polukhin
-//
-// 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)
-
-// Test case from https://svn.boost.org/trac10/ticket/8721
-
-#include <boost/variant.hpp>
-
-#include <boost/fusion/include/vector.hpp>
-
-struct emptyList {};
-
-typedef boost::make_recursive_variant
-  < emptyList
-  , boost::fusion::vector
-      < int
-      , boost::recursive_variant_
-      >
-  >::type IntList;
-
-const emptyList el = emptyList();
-const IntList nil( el );
-
-IntList cons( int head, IntList tail )
-{
-  return IntList( boost::fusion::vector<int, IntList>( head, tail ) );
-}

test/hash_recursive_variant_test.cpp

@@ -1,73 +0,0 @@
-// Copyright (c) 2016
-// Mikhail Maximov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#include "boost/config.hpp"
-#include "boost/core/lightweight_test.hpp"
-
-#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_CXX11_HDR_UNORDERED_SET)
-// Test is based on reported issues:
-// https://svn.boost.org/trac/boost/ticket/12508
-// https://svn.boost.org/trac/boost/ticket/12645
-// Following hash function was not found at compile time,
-// because boost::variant construction from boost::recursive_variant_
-// was forbidden.
-
-#include <unordered_set>
-
-#include "boost/variant.hpp"
-
-struct hash;
-
-using int_t = int;
-
-template <typename T>
-using basic_set_t = std::unordered_set<T, hash>;
-
-using value_t = boost::make_recursive_variant<
-    int_t,
-    basic_set_t<boost::recursive_variant_>
->::type;
-
-using set_t = basic_set_t<value_t>;
-
-struct hash
-{
-    size_t operator()(const value_t&) const
-    {
-      return 0;
-    }
-};
-
-void run()
-{
-    set_t s;
-    int_t i = 3;
-    value_t v = i;
-    auto emplace_result = s.emplace(v); // raises error above
-    BOOST_TEST(emplace_result.second);
-    v = s;
-    const set_t& check_set = boost::get<set_t>(v);
-    BOOST_TEST(!check_set.empty());
-    for (const auto& check_v : check_set) {
-      BOOST_TEST(s.find(check_v) != s.end());
-    }
-    for (const auto& check_v : s) {
-      BOOST_TEST(check_set.find(check_v) != check_set.end());
-    }
-}
-
-#else // !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_CXX11_HDR_UNORDERED_SET)
-// if no unordered_set and template aliases - does nothing
-void run() {}
-#endif
-
-int main()
-{
-   run();
-   return boost::report_errors();
-}
-

test/hash_variant_test.cpp

@@ -1,54 +1,34 @@
-// Copyright (c) 2011-2026 Antony Polukhin
+// Copyright (c) 2011
+// Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#include "boost/core/lightweight_test.hpp"
-
-#include "boost/config.hpp"
+#include "boost/test/minimal.hpp"
+#include "boost/variant/detail/hash_variant.hpp"
 #include "boost/variant.hpp"
 #include "boost/functional/hash/hash.hpp"
 
-#if !defined(BOOST_NO_CXX11_HDR_UNORDERED_SET) && !defined(BOOST_VARIANT_DO_NOT_SPECIALIZE_STD_HASH)
+void run()
+{
+    typedef boost::variant<bool, int, unsigned int, double> variant_type;
+		boost::hash<variant_type> hasher;
+		
+		variant_type bool_variant1 = true;
+		variant_type bool_variant2 = false;
+		variant_type int_variant = 1;
+		variant_type float_variant = 1.0;
+		variant_type uint_variant = static_cast<unsigned int>(1);
 
-#include <unordered_set>
-
-void test_std_hash() {
-    std::unordered_set<boost::variant<int, bool> > us;
-    us.insert(1);
-    us.insert(true);
-    BOOST_TEST(us.size() == 2);
+    BOOST_CHECK(hasher(bool_variant1) != hasher(bool_variant2));
+    BOOST_CHECK(hasher(bool_variant1) == hasher(bool_variant1));
+    BOOST_CHECK(hasher(int_variant) != hasher(uint_variant));
+    BOOST_CHECK(hasher(float_variant) != hasher(uint_variant));
 }
 
-#else
-void test_std_hash() {}
-#endif
-
-
-void run() {
-    typedef boost::variant<bool, int, unsigned int, char> variant_type;
-    boost::hash<variant_type> hasher;
-
-    variant_type bool_variant1 = true;
-    variant_type bool_variant2 = false;
-    variant_type int_variant = 1;
-    variant_type char_variant1 = '\1';
-    variant_type char_variant2 = '\2';
-    variant_type uint_variant = static_cast<unsigned int>(1);
-
-    BOOST_TEST(hasher(bool_variant1) != hasher(bool_variant2));
-    BOOST_TEST(hasher(bool_variant1) == hasher(bool_variant1));
-    BOOST_TEST(hasher(int_variant) != hasher(uint_variant));
-    BOOST_TEST(hasher(char_variant1) != hasher(uint_variant));
-    BOOST_TEST(hasher(char_variant1) != hasher(char_variant2));
-    BOOST_TEST(hasher(char_variant1) == hasher(char_variant1));
-    BOOST_TEST(hasher(char_variant2) == hasher(char_variant2));
+int test_main(int , char* [])
+{
+   run();
+   return 0;
 }
-
-int main() {
-    run();
-    test_std_hash();
-    return boost::report_errors();
-}
-

test/issue42.cpp

@@ -1,61 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost-libs variant/test/issue42.cpp source file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2018-2026 Antony Polukhin
-//
-// 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)
-
-// Test case from https://github.com/boostorg/variant/issues/42
-
-#include <boost/variant.hpp>
-#include <map>
-#include <memory>
-#include <vector>
-
-
-
-#ifdef BOOST_NO_CXX11_SMART_PTR
-    template <class T> struct shared_ptr_like {};
-    typedef shared_ptr_like<boost::recursive_variant_> ptr_t;
-#else
-    typedef std::shared_ptr<boost::recursive_variant_> ptr_t;
-#endif
-
-template <class F>
-class func{};
-
-int main() {
-    typedef boost::make_recursive_variant<
-        int,
-        ptr_t
-    >::type node;
-
-    node x = 1;
-    (void)x;
-
-
-    typedef boost::make_recursive_variant<
-        std::string, int, double, bool,
-        ptr_t,
-        std::map<const std::string, boost::recursive_variant_>,
-        std::vector<boost::recursive_variant_>
-    >::type node2;
-
-    node2 x2 = 1;
-    (void)x2;
-
-
-    typedef boost::make_recursive_variant<
-        int,
-        func<boost::recursive_variant_(*)(boost::recursive_variant_&, const boost::recursive_variant_&)>,
-        boost::recursive_variant_&(*)(boost::recursive_variant_, boost::recursive_variant_*),
-        ptr_t
-    >::type node3;
-
-    node3 x3 = func<node3(*)(node3&, const node3&)>();
-    (void)x3;
-}

test/issue53.cpp

@@ -1,58 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost-libs variant/test/issue53.cpp source file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2019-2026 Antony Polukhin
-//
-// 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)
-
-// Test case from https://github.com/boostorg/variant/issues/53
-
-#include <boost/variant.hpp>
-#include <boost/thread/lock_guard.hpp> // this line was causing problems on MSVC
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-struct spanac {};
-
-struct ceapa{
-    double a,b;
-};
-
-typedef boost::variant<spanac, ceapa> var_t;
-
-struct visitor_t : public boost::static_visitor<bool> {
-    bool operator() (const spanac&) const {
-        return true;
-    }
-
-    bool operator() (const ceapa&) const {
-        return false;
-    }
-
-private:
-    double a, b;
-};
-
-var_t get(int k) {
-    if (k)
-        return spanac();
-    else
-        return ceapa();
-}
-
-int main(int argc, const char** argv) {
-    visitor_t v;
-
-    bool result = boost::apply_visitor(v, get(argc - 1));
-    (void)result;
-}
-
-#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-int main() {}
-
-#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES

test/jobs.h

@@ -25,9 +25,8 @@
 #include "boost/variant/apply_visitor.hpp"
 #include "boost/variant/static_visitor.hpp"
 
-#include "boost/type_index.hpp"
 #include "boost/detail/workaround.hpp"
-#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x0551))
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))
 #    pragma warn -lvc
 #endif
 
@@ -244,14 +243,16 @@ inline void verify(VariantType& var, spec<S>, std::string str = "")
 {
    const VariantType& cvar = var;
 
-   BOOST_TEST(boost::apply_visitor(total_sizeof(), cvar) == sizeof(S));
-   BOOST_TEST(cvar.type() == boost::typeindex::type_id<S>());
+   BOOST_CHECK(boost::apply_visitor(total_sizeof(), cvar) == sizeof(S));
+#if !defined(BOOST_NO_TYPEID)
+   BOOST_CHECK(cvar.type() == typeid(S));
+#endif
 
    //
    // Check get<>()
    //
-   BOOST_TEST(boost::get<S>(&var));
-   BOOST_TEST(boost::get<S>(&cvar));
+   BOOST_CHECK(boost::get<S>(&var));
+   BOOST_CHECK(boost::get<S>(&cvar));
 
    const S* ptr1 = 0;
    const S* ptr2 = 0;
@@ -260,7 +261,7 @@ inline void verify(VariantType& var, spec<S>, std::string str = "")
       S& r = boost::get<S>(var);
       ptr1 = &r;
    }
-   catch(const boost::bad_get& )
+   catch(boost::bad_get& )
    {
       BOOST_ERROR( "get<S> failed unexpectedly" );
    }
@@ -270,12 +271,12 @@ inline void verify(VariantType& var, spec<S>, std::string str = "")
       const S& cr = boost::get<S>(cvar);
       ptr2 = &cr;
    }
-   catch(const boost::bad_get& )
+   catch(boost::bad_get& )
    {
       BOOST_ERROR( "get<S> const failed unexpectedly" );
    }
 
-   BOOST_TEST(ptr1 != 0 && ptr2 == ptr1);
+   BOOST_CHECK(ptr1 != 0 && ptr2 == ptr1);
 
    //
    // Check string content
@@ -284,7 +285,7 @@ inline void verify(VariantType& var, spec<S>, std::string str = "")
    {
       std::string temp = boost::apply_visitor(to_text(), cvar);
       std::cout << "temp = " << temp << ", str = " << str << std::endl;
-      BOOST_TEST(temp == str);
+      BOOST_CHECK(temp == str);         
    }
 }
 
@@ -294,13 +295,15 @@ inline void verify_not(VariantType& var, spec<S>)
 {
    const VariantType& cvar = var;
 
-   BOOST_TEST(cvar.type() != boost::typeindex::type_id<S>());
+#if !defined(BOOST_NO_TYPEID)
+   BOOST_CHECK(cvar.type() != typeid(S));
+#endif
 
    //
    // Check get<>()
    //
-   BOOST_TEST(!boost::get<S>(&var));
-   BOOST_TEST(!boost::get<S>(&cvar));
+   BOOST_CHECK(!boost::get<S>(&var));
+   BOOST_CHECK(!boost::get<S>(&cvar));
 
    const S* ptr1 = 0;
    const S* ptr2 = 0;
@@ -311,7 +314,7 @@ inline void verify_not(VariantType& var, spec<S>)
 
       ptr1 = &r;
    }
-   catch(const boost::bad_get& )
+   catch(boost::bad_get& )
    {
       // do nothing except pass-through
    }
@@ -323,12 +326,12 @@ inline void verify_not(VariantType& var, spec<S>)
 
       ptr2 = &cr;
    }
-   catch(const boost::bad_get& )
+   catch(boost::bad_get& )
    {
       // do nothing except pass-through
    }
 
-   BOOST_TEST(ptr1 == 0 && ptr2 == 0);
+   BOOST_CHECK(ptr1 == 0 && ptr2 == 0);   
 }
 
 

test/no_rvalue_to_nonconst_visitation.cpp

@@ -1,32 +0,0 @@
-// Copyright (c) 2017-2026 Antony Polukhin
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#include "boost/config.hpp"
-#include "boost/variant.hpp"
-
-struct foo {};
-
-struct some_user_provided_visitor_for_lvalues: boost::static_visitor<void> {
-    void operator()(foo& ) const {}
-    void operator()(int ) const {}
-};
-
-int main() {
-    boost::apply_visitor(
-        some_user_provided_visitor_for_lvalues(),
-        boost::variant<int, foo>(foo())
-    );
-
-#ifdef __GNUC__
-#   if __GNUC__ < 5 && __GNUC_MINOR__ < 8
-#       error This test does not pass on GCC < 4.8 because of the incomplete C++11 support
-#   endif
-#endif
-
-#ifdef BOOST_MSVC
-#   error Temporaries/rvalues could bind to non-const lvalues on MSVC compilers
-#endif
-}

test/overload_selection.cpp

@@ -1,215 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost-libs variant/test/variant_get_test.cpp source file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2016-2026 Antony Polukhin
-//
-// 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)
-
-
-// This test suite was created to cover issues reported in:
-//      https://svn.boost.org/trac/boost/ticket/5871
-//      https://svn.boost.org/trac/boost/ticket/11602
-
-#include "boost/variant/variant.hpp"
-#include "boost/variant/recursive_variant.hpp"
-#include "boost/core/lightweight_test.hpp"
-
-#include <string>
-#include <list>
-
-struct A{};
-struct B{};
-struct C{};
-struct D{};
-
-
-bool foo(const boost::variant<A, B>& ) {
-    return false;
-}
-
-bool foo(const boost::variant<C, D>& ) {
-    return true;
-}
-
-void test_overload_selection_variant_constructor() {
-    D d;
-    BOOST_TEST(foo(d));
-
-    boost::variant<B, A> v;
-    BOOST_TEST(!foo(v));
-}
-
-// Pre msvc-14.0 could not dustinguish between multiple assignment operators:
-//      warning C4522: 'assignment_tester' : multiple assignment operators specified
-//      error C2666: variant::operator =' : 3 overloads have similar conversions
-// Old versions of GCC have same issue:
-//      error: variant::operator=(const T&) cannot be overloaded
-#if (defined(__GNUC__) && (__GNUC__ < 4)) || (defined(_MSC_VER) && _MSC_VER < 1900)
-
-void test_overload_selection_variant_assignment() {
-    BOOST_TEST(true);
-}
-
-#else
-
-struct assignment_tester: boost::variant<C, D>, boost::variant<B, A> {
-    using boost::variant<B, A>::operator=;
-    using boost::variant<C, D>::operator=;
-};
-
-void test_overload_selection_variant_assignment() {
-    A a;
-    assignment_tester tester;
-    tester = a;
-    const int which0 = static_cast< boost::variant<B, A>& >(tester).which();
-    BOOST_TEST(which0 == 1);
-
-    boost::variant<A, B> b;
-    b = B();
-    tester = b;
-    const int which1 = static_cast< boost::variant<B, A>& >(tester).which();
-    BOOST_TEST(which1 == 0);
-}
-
-#endif
-
-typedef boost::variant<int> my_variant;
-
-struct convertible {
-    operator my_variant() const {
-        return my_variant();
-    }
-};
-
-void test_implicit_conversion_operator() {
-    // https://svn.boost.org/trac/boost/ticket/8555
-    my_variant y = convertible();
-    BOOST_TEST(y.which() == 0);
-}
-
-struct X: boost::variant< int > {};
-class V1: public boost::variant<float,double> {};
-
-struct AB: boost::variant<A, B> {};
-
-void test_derived_from_variant_construction() {
-    // https://svn.boost.org/trac/boost/ticket/7120
-    X x;
-    boost::variant<X> y(x);
-    BOOST_TEST(y.which() == 0);
-
-    // https://svn.boost.org/trac/boost/ticket/10278
-    boost::variant<V1, std::string> v2 = V1();
-    BOOST_TEST(v2.which() == 0);
-
-    // https://svn.boost.org/trac/boost/ticket/12155
-    AB ab;
-    boost::variant<AB, C> ab_c(ab);
-    BOOST_TEST(ab_c.which() == 0);
-
-    boost::variant<A, B> a_b(ab);
-    BOOST_TEST(a_b.which() == 0);
-
-    boost::variant<B, C, A> b_c_a1(static_cast<boost::variant<A, B>& >(ab));
-    BOOST_TEST(b_c_a1.which() == 2);
-
-
-//  Following conversion seems harmful as it may lead to slicing:
-//  boost::variant<B, C, A> b_c_a(ab);
-//  BOOST_TEST(b_c_a.which() == 2);
-}
-
-void test_derived_from_variant_assignment() {
-    // https://svn.boost.org/trac/boost/ticket/7120
-    X x;
-    boost::variant<X> y;
-    y = x;
-    BOOST_TEST(y.which() == 0);
-
-    // https://svn.boost.org/trac/boost/ticket/10278
-    boost::variant<V1, std::string> v2;
-    v2 = V1();
-    BOOST_TEST(v2.which() == 0);
-
-    // https://svn.boost.org/trac/boost/ticket/12155
-    AB ab;
-    boost::variant<AB, C> ab_c;
-    ab_c = ab;
-    BOOST_TEST(ab_c.which() == 0);
-
-    boost::variant<A, B> a_b;
-    a_b = ab;
-    BOOST_TEST(a_b.which() == 0);
-
-    boost::variant<B, C, A> b_c_a1;
-    b_c_a1 = static_cast<boost::variant<A, B>& >(ab);
-    BOOST_TEST(b_c_a1.which() == 2);
-
-
-//  Following conversion seems harmful as it may lead to slicing:
-//  boost::variant<B, C, A> b_c_a;
-//  b_c_a = ab;
-//  BOOST_TEST(b_c_a.which() == 2);
-}
-
-
-// http://thread.gmane.org/gmane.comp.lib.boost.devel/267757
-struct info {
-    struct nil_ {};
-
-    typedef
-        boost::variant<
-            nil_
-          , std::string
-          , boost::recursive_wrapper<info>
-          , boost::recursive_wrapper<std::pair<info, info> >
-          , boost::recursive_wrapper<std::list<info> >
-        >
-    value_type;
-    value_type v;
-
-    inline void test_on_incomplete_types() {
-        info i0;
-        i0.v = "Hello";
-        BOOST_TEST(i0.v.which() == 1);
-
-        info::value_type v0 = "Hello";
-        BOOST_TEST(v0.which() == 1);
-
-        info::value_type v1("Hello");
-        BOOST_TEST(v1.which() == 1);
-
-        info::value_type v2 = i0;
-        BOOST_TEST(v2.which() == 2);
-
-        info::value_type v3(i0);
-        BOOST_TEST(v3.which() == 2);
-
-        v0 = v3;
-        BOOST_TEST(v0.which() == 2);
-
-        v3 = v1;
-        BOOST_TEST(v3.which() == 1);
-
-        v3 = nil_();
-        BOOST_TEST(v3.which() == 0);
-    }
-};
-
-
-
-int main()
-{
-    test_overload_selection_variant_constructor();
-    test_overload_selection_variant_assignment();
-    test_implicit_conversion_operator();
-    test_derived_from_variant_construction();
-    test_derived_from_variant_assignment();
-    info().test_on_incomplete_types();
-
-    return boost::report_errors();
-}

test/recursive_variant_test.cpp

@@ -4,7 +4,7 @@
 //-----------------------------------------------------------------------------
 //
 // Copyright (c) 2003 Eric Friedman, Itay Maman
-// Copyright (c) 2013-2026 Antony Polukhin
+// Copyright (c) 2013 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -18,8 +18,27 @@
 // 2) variant_noexcept_test that tests Boost.Variant ability to compile 
 // and work with disabled exceptions
 
+#ifdef BOOST_NO_EXCEPTIONS
+// `boost/test/minimal.hpp` cannot work with exceptions disabled,
+// so we need the following workarounds for that case:
+namespace boost {
+    int exit_success = 0;
+}
+
+int test_main(int , char* []);
+
+int main( int argc, char* argv[] )
+{
+    return test_main(argc, argv);
+}
+
+#include <stdlib.h>
+#define BOOST_CHECK(exp) if (!(exp)) exit(EXIT_FAILURE)
+
+#else // BOOST_NO_EXCEPTIONS
+#   include "boost/test/minimal.hpp"
+#endif // BOOST_NO_EXCEPTIONS
 
-#include "boost/core/lightweight_test.hpp"
 
 #include "boost/variant.hpp"
 #include "boost/mpl/vector.hpp"
@@ -29,20 +48,10 @@
 #include <sstream>
 #include <vector>
 #include <map>
-#include <tuple>
 
-struct Nil {};
-
-struct printer
+struct vector_printer
     : boost::static_visitor<std::string>
 {
-    template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
-    std::string operator()(
-            const boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> &var) const
-    {
-        return boost::apply_visitor( printer(), var );
-    }
-
     template <typename T>
     std::string operator()(const std::vector<T>& vec) const
     {
@@ -52,35 +61,13 @@ struct printer
 
         typename std::vector<T>::const_iterator it = vec.begin();
         for (; it != vec.end(); ++it)
-            ost << printer()( *it );
+            ost << boost::apply_visitor( vector_printer(), *it );
 
         ost << ") ";
 
         return ost.str();
     }
 
-    template <int...> struct indices {};
-    template <typename... Ts, int... Is>
-    std::string operator()(const std::tuple<Ts...>& tup, indices<Is...>) const
-    {
-        std::ostringstream ost;
-        ost << "( ";
-        int a[] = {0, (ost << printer()( std::get<Is>(tup) ), 0)... };
-        (void)a;
-        ost << ") ";
-        return ost.str();
-    }
-
-    template <int N, int... Is>
-        struct make_indices : make_indices<N-1, N-1, Is...> {};
-    template <int... Is>
-        struct make_indices<0, Is...> : indices<Is...> {};
-    template <typename... Ts>
-    std::string operator()(const std::tuple<Ts...>& tup) const
-    {
-        return printer()(tup, make_indices<sizeof...(Ts)>());
-    }
-
     template <typename T>
     std::string operator()(const T& operand) const
     {
@@ -104,47 +91,10 @@ void test_recursive_variant()
     vec1.push_back(7);
 
     var1_t var1(vec1);
-    std::string result1( printer()(var1) );
+    std::string result1( boost::apply_visitor( vector_printer(), var1 ) );
 
     std::cout << "result1: " << result1 << '\n';
-    BOOST_TEST(result1 == "( 3 5 ( 3 5 ) 7 ) ");
-
-    std::vector<var1_t> vec1_copy = vec1;
-    vec1_copy.erase(vec1_copy.begin() + 2);
-    vec1_copy.insert(vec1_copy.begin() + 2, vec1_copy);
-    var1 = vec1_copy;
-    result1 = printer()(var1);
-    std::cout << "result1+: " << result1 << '\n';
-    BOOST_TEST(result1 == "( 3 5 ( 3 5 7 ) 7 ) ");
-
-    // Uses move construction on compilers with rvalue references support
-    result1 = printer()(
-        var1_t(
-            std::vector<var1_t>(vec1_copy)
-        )
-    );
-    std::cout << "result1++: " << result1 << '\n';
-    BOOST_TEST(result1 == "( 3 5 ( 3 5 7 ) 7 ) ");
-
-
-    var1_t vec1_another_copy(vec1_copy);
-    vec1_copy[2].swap(vec1_another_copy);
-    result1 = printer()(
-        var1_t(vec1_copy)
-    );
-    std::cout << "result1+++1: " << result1 << '\n';
-    BOOST_TEST(result1 == "( 3 5 ( 3 5 ( 3 5 7 ) 7 ) 7 ) ");
-
-    result1 = printer()(vec1_another_copy);
-    std::cout << "result1++2: " << result1 << '\n';
-    BOOST_TEST(result1 == "( 3 5 7 ) ");
-
-    vec1_copy[2].swap(vec1_copy[2]);
-    result1 = printer()(
-        var1_t(vec1_copy)
-    );
-    std::cout << "result1.2: " << result1 << '\n';
-    BOOST_TEST(result1 == "( 3 5 ( 3 5 ( 3 5 7 ) 7 ) 7 ) ");
+    BOOST_CHECK(result1 == "( 3 5 ( 3 5 ) 7 ) ");
 
     typedef boost::make_recursive_variant<
           boost::variant<int, double>
@@ -158,10 +108,10 @@ void test_recursive_variant()
     vec2.push_back(boost::variant<int, double>(7));
 
     var2_t var2(vec2);
-    std::string result2( printer()(var2) );
+    std::string result2( boost::apply_visitor( vector_printer(), var2 ) );
 
     std::cout << "result2: " << result2 << '\n';
-    BOOST_TEST(result2 == "( 3 3.5 ( 3 3.5 ) 7 ) ");
+    BOOST_CHECK(result2 == "( 3 3.5 ( 3 3.5 ) 7 ) ");
     
     typedef boost::make_recursive_variant<
           int
@@ -185,10 +135,10 @@ void test_recursive_variant()
     vec3.push_back(7);
 
     var4_t var4(vec3);
-    std::string result3( printer()(var4) );
+    std::string result3( boost::apply_visitor( vector_printer(), var4 ) );
 
     std::cout << "result2: " << result3 << '\n';
-    BOOST_TEST(result3 == "( 3 5 ( 3.5 ( 3 5 ) ) 7 ) ");
+    BOOST_CHECK(result3 == "( 3 5 ( 3.5 ( 3 5 ) ) 7 ) ");
 
     typedef boost::make_recursive_variant<
           double,
@@ -200,29 +150,16 @@ void test_recursive_variant()
     vec5.push_back(vec1);
     vec5.push_back(17.25);
 
-    std::string result5( printer()(vec5) );
+    std::string result5( vector_printer()(vec5) );
 
     std::cout << "result5: " << result5 << '\n';
-    BOOST_TEST(result5 == "( 3.5 ( 3 5 ( 3 5 ) 7 ) 17.25 ) ");
+    BOOST_CHECK(result5 == "( 3.5 ( 3 5 ( 3 5 ) 7 ) 17.25 ) ");
 
     typedef boost::make_recursive_variant<
           int,
           std::map<int, boost::recursive_variant_>
         >::type var6_t;
     var6_t var6;
-
-    typedef boost::make_recursive_variant<
-          int,
-          std::tuple<int, boost::recursive_variant_>
-        >::type var7_t;
-    var7_t var7 = 0;    // !!! Do not replace with `var7_t var7{0}` or `var7_t var7(0)` !!!
-    var7 = std::tuple<int, var7_t>(1, var7);
-    var7 = std::tuple<int, var7_t>(2, var7);
-
-    std::string result7( printer()(var7) );
-
-    std::cout << "result7: " << result7 << '\n';
-    BOOST_TEST(result7 == "( 2 ( 1 0 ) ) ");
 }
 
 void test_recursive_variant_over()
@@ -241,40 +178,10 @@ void test_recursive_variant_over()
     vec1.push_back(7);
 
     var1_t var1(vec1);
-    std::string result1( printer()(var1) );
+    std::string result1( boost::apply_visitor( vector_printer(), var1 ) );
 
     std::cout << "result1: " << result1 << '\n';
-    BOOST_TEST(result1 == "( 3 5 ( 3 5 ) 7 ) ");
-
-    std::vector<var1_t> vec1_copy = vec1;
-    vec1_copy.erase(vec1_copy.begin() + 2);
-    vec1_copy.insert(vec1_copy.begin() + 2, vec1_copy);
-    var1 = vec1_copy;
-    result1 = printer()(var1);
-    std::cout << "result1+: " << result1 << '\n';
-    BOOST_TEST(result1 == "( 3 5 ( 3 5 7 ) 7 ) ");
-
-    // Uses move construction on compilers with rvalue references support
-    result1 = printer()(
-        var1_t(
-            std::vector<var1_t>(vec1_copy)
-        )
-    );
-    std::cout << "result1++: " << result1 << '\n';
-    BOOST_TEST(result1 == "( 3 5 ( 3 5 7 ) 7 ) ");
-
-
-    var1_t vec1_another_copy(vec1_copy);
-    vec1_copy[2].swap(vec1_another_copy);
-    result1 = printer()(
-        var1_t(vec1_copy)
-    );
-    std::cout << "result1+++1: " << result1 << '\n';
-    BOOST_TEST(result1 == "( 3 5 ( 3 5 ( 3 5 7 ) 7 ) 7 ) ");
-
-    result1 = printer()(vec1_another_copy);
-    std::cout << "result1++2: " << result1 << '\n';
-    BOOST_TEST(result1 == "( 3 5 7 ) ");
+    BOOST_CHECK(result1 == "( 3 5 ( 3 5 ) 7 ) ");
 
     typedef boost::make_recursive_variant_over<
           boost::mpl::vector<
@@ -290,10 +197,10 @@ void test_recursive_variant_over()
     vec2.push_back(boost::variant<int, double>(7));
 
     var2_t var2(vec2);
-    std::string result2( printer()(var2) );
+    std::string result2( boost::apply_visitor( vector_printer(), var2 ) );
 
     std::cout << "result2: " << result2 << '\n';
-    BOOST_TEST(result2 == "( 3 3.5 ( 3 3.5 ) 7 ) ");
+    BOOST_CHECK(result2 == "( 3 3.5 ( 3 3.5 ) 7 ) ");
     
     typedef boost::make_recursive_variant_over<
           boost::mpl::vector<
@@ -328,10 +235,10 @@ void test_recursive_variant_over()
     vec3.push_back(7);
 
     var4_t var3(vec3);
-    std::string result3( printer()(var3) );
+    std::string result3( boost::apply_visitor( vector_printer(), var3 ) );
 
     std::cout << "result2: " << result3 << '\n';
-    BOOST_TEST(result3 == "( 3 5 ( 3.5 ( 3 5 ) ) 7 ) ");
+    BOOST_CHECK(result3 == "( 3 5 ( 3.5 ( 3 5 ) ) 7 ) ");
     
     typedef boost::make_recursive_variant_over<
           boost::mpl::vector<
@@ -345,27 +252,16 @@ void test_recursive_variant_over()
     vec5.push_back(vec1);
     vec5.push_back(17.25);
 
-    std::string result5( printer()(vec5) );
+    std::string result5( vector_printer()(vec5) );
 
     std::cout << "result5: " << result5 << '\n';
-    BOOST_TEST(result5 == "( 3.5 ( 3 5 ( 3 5 ) 7 ) 17.25 ) ");
+    BOOST_CHECK(result5 == "( 3.5 ( 3 5 ( 3 5 ) 7 ) 17.25 ) ");
 }
 
-void test_recursive_variant_from_variant()
-{
-    // See https://github.com/boostorg/variant/issues/100
-    typedef boost::variant<Nil, double> Atom;
-    typedef boost::variant<Nil, boost::recursive_wrapper<Atom> > Variant;
-
-    BOOST_STATIC_ASSERT(!boost::is_constructible<Variant, Atom>::value);
-    BOOST_STATIC_ASSERT(boost::is_constructible<boost::variant<Nil, Atom>, Atom>::value);
-}
-
-int main()
+int test_main(int , char* [])
 {
     test_recursive_variant();
     test_recursive_variant_over();
-    test_recursive_variant_from_variant();
 
-    return boost::report_errors();
+    return boost::exit_success;
 }

test/recursive_wrapper_move_test.cpp

@@ -1,77 +0,0 @@
-// Copyright (c) 2017
-// Mikhail Maximov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#include "boost/config.hpp"
-#include "boost/core/lightweight_test.hpp"
-
-#ifdef __cpp_inheriting_constructors
-// Test is based on reported issue:
-// https://svn.boost.org/trac/boost/ticket/12680
-// GCC 6 crashed, trying to determine is boost::recursive_wrapper<Node>
-// is_noexcept_move_constructible
-
-#include <string>
-
-#include <boost/variant.hpp>
-#include <boost/array.hpp>
-
-struct Leaf { };
-struct Node;
-
-typedef boost::variant<Leaf, boost::recursive_wrapper<Node>> TreeBase;
-
-struct Tree : TreeBase {
-  using TreeBase::TreeBase;
-
-  template <typename Iter>
-  static Tree Create(Iter /*first*/, Iter /*last*/) { return Leaf{}; }
-};
-
-struct Node {
-  Tree left, right;
-};
-
-
-// Test from https://svn.boost.org/trac/boost/ticket/7120
-template<class Node>
-struct node1_type;
-
-struct var_type;
-
-using var_base = boost::variant<int,
-  boost::recursive_wrapper<node1_type<var_type>>
->;
-
-template<class Node>
-struct node1_type {
-  boost::array<Node, 1> children;
-};
-
-struct var_type : var_base {
-  using var_base::var_base;
-};
-
-void run() {
-  std::string input{"abracadabra"};
-  const Tree root = Tree::Create(input.begin(), input.end());
-  (void)root; // prevents unused variable warning
-
-  var_type v1 = 1;
-  (void)v1;
-}
-
-#else // #!ifdef __cpp_inheriting_constructors
-// if compiler does not support inheriting constructors - does nothing
-void run() {}
-#endif
-
-int main()
-{
-    run();
-    return boost::report_errors();
-}
-

test/rvalue_test.cpp

@@ -3,7 +3,7 @@
 // See http://www.boost.org for updates, documentation, and revision history.
 //-----------------------------------------------------------------------------
 //
-// Copyright (c) 2012-2026 Antony Polukhin
+// Copyright (c) 2012-2013 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -11,38 +11,24 @@
 
 #include "boost/config.hpp"
 
-#include "boost/core/lightweight_test.hpp"
+#include "boost/test/minimal.hpp"
 #include "boost/variant.hpp"
 #include "boost/type_traits/is_nothrow_move_assignable.hpp"
-#include "boost/mpl/bool.hpp"
-
-#include <boost/blank.hpp>
-
-namespace swap_ambiguouty_test_ns {
-    struct A {};
-    struct B {};
-
-    void swap_ambiguouty_test() {
-        // If boost::blank is not used, then it compiles.
-        typedef boost::variant<boost::blank, A, B> Variant;
-        Variant v1, v2;
-        swap(v1, v2);
-    }
-} // namespace swap_ambiguouty_test_ns
 
 // Most part of tests from this file require rvalue references support
 
+
 class move_copy_conting_class {
 public:
     static unsigned int moves_count;
     static unsigned int copy_count;
 
     move_copy_conting_class(){}
-    move_copy_conting_class(move_copy_conting_class&& ) {
+    move_copy_conting_class(BOOST_RV_REF(move_copy_conting_class) ) {
         ++ moves_count;
     }
 
-    move_copy_conting_class& operator=(move_copy_conting_class&& ) {
+    move_copy_conting_class& operator=(BOOST_RV_REF(move_copy_conting_class) ) {
         ++ moves_count;
         return *this;
     }
@@ -50,7 +36,7 @@ public:
     move_copy_conting_class(const move_copy_conting_class&) {
         ++ copy_count;
     }
-    move_copy_conting_class& operator=(const move_copy_conting_class& ) {
+    move_copy_conting_class& operator=(BOOST_COPY_ASSIGN_REF(move_copy_conting_class) ) {
         ++ copy_count;
         return *this;
     }
@@ -59,18 +45,65 @@ public:
 unsigned int move_copy_conting_class::moves_count = 0;
 unsigned int move_copy_conting_class::copy_count = 0;
 
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+void run()
+{
+    // Making sure that internals of Boost.Move do not interfere with
+    // internals of Boost.Variant and in case of C++03 or C++98 compilation 
+    // is still possible.
+    typedef boost::variant<int, move_copy_conting_class> variant_I_type;
+    variant_I_type v1, v2;
+    v1 = move_copy_conting_class();
+    v2 = v1; 
+    v2 = boost::move(v1);
+    v1.swap(v2);
+
+    move_copy_conting_class val;
+    v2 = boost::move(val);
+    v2 = 10;
+
+    variant_I_type v3(boost::move(val));
+    variant_I_type v4(boost::move(v1));
+}
+
+void run1()
+{
+    BOOST_CHECK(true);
+}
+
+void run_move_only()
+{
+    BOOST_CHECK(true);
+}
+
+void run_moves_are_noexcept()
+{
+    BOOST_CHECK(true);
+}
+
+
+void run_const_rvalues()
+{
+    BOOST_CHECK(true);
+}
+
+
+#else 
+
+
 void run()
 {
     typedef boost::variant<int, move_copy_conting_class> variant_I_type;
     variant_I_type v1, v2;
     
     // Assuring that `move_copy_conting_class` was not created
-    BOOST_TEST(move_copy_conting_class::copy_count == 0);
-    BOOST_TEST(move_copy_conting_class::moves_count == 0);
+    BOOST_CHECK(move_copy_conting_class::copy_count == 0);
+    BOOST_CHECK(move_copy_conting_class::moves_count == 0);
     
     v1 = move_copy_conting_class();
     // Assuring that `move_copy_conting_class` was moved at least once
-    BOOST_TEST(move_copy_conting_class::moves_count != 0);
+    BOOST_CHECK(move_copy_conting_class::moves_count != 0);
     
     unsigned int total_count = move_copy_conting_class::moves_count + move_copy_conting_class::copy_count;
     move_copy_conting_class var;
@@ -79,57 +112,57 @@ void run()
     move_copy_conting_class::copy_count = 0;
     v1 = var;
     // Assuring that move assignment operator moves/copyes value not more times than copy assignment operator
-    BOOST_TEST(total_count <= move_copy_conting_class::moves_count + move_copy_conting_class::copy_count);
+    BOOST_CHECK(total_count <= move_copy_conting_class::moves_count + move_copy_conting_class::copy_count);
 
     move_copy_conting_class::moves_count = 0;
     move_copy_conting_class::copy_count = 0;
-    v2 = std::move(v1);
+    v2 = boost::move(v1);
     // Assuring that `move_copy_conting_class` in v1 was moved at least once and was not copied
-    BOOST_TEST(move_copy_conting_class::moves_count != 0);
-    BOOST_TEST(move_copy_conting_class::copy_count == 0);
+    BOOST_CHECK(move_copy_conting_class::moves_count != 0);
+    BOOST_CHECK(move_copy_conting_class::copy_count == 0);
 
     v1 = move_copy_conting_class();
     move_copy_conting_class::moves_count = 0;
     move_copy_conting_class::copy_count = 0;
-    v2 = std::move(v1);
+    v2 = boost::move(v1);
     // Assuring that `move_copy_conting_class` in v1 was moved at least once and was not copied
-    BOOST_TEST(move_copy_conting_class::moves_count != 0);
-    BOOST_TEST(move_copy_conting_class::copy_count == 0);
+    BOOST_CHECK(move_copy_conting_class::moves_count != 0);
+    BOOST_CHECK(move_copy_conting_class::copy_count == 0);
     total_count = move_copy_conting_class::moves_count + move_copy_conting_class::copy_count;
     move_copy_conting_class::moves_count = 0;
     move_copy_conting_class::copy_count = 0;
     v1 = v2;
     // Assuring that move assignment operator moves/copyes value not more times than copy assignment operator
-    BOOST_TEST(total_count <= move_copy_conting_class::moves_count + move_copy_conting_class::copy_count);
+    BOOST_CHECK(total_count <= move_copy_conting_class::moves_count + move_copy_conting_class::copy_count);
 
 
     typedef boost::variant<move_copy_conting_class, int> variant_II_type;
     variant_II_type v3;
     move_copy_conting_class::moves_count = 0;
     move_copy_conting_class::copy_count = 0;
-    v1 = std::move(v3);
+    v1 = boost::move(v3);
     // Assuring that `move_copy_conting_class` in v3 was moved at least once (v1 and v3 have different types)
-    BOOST_TEST(move_copy_conting_class::moves_count != 0);
+    BOOST_CHECK(move_copy_conting_class::moves_count != 0);
 
     move_copy_conting_class::moves_count = 0;
     move_copy_conting_class::copy_count = 0;
-    v2 = std::move(v1);
+    v2 = boost::move(v1);
     // Assuring that `move_copy_conting_class` in v1 was moved at least once (v1 and v3 have different types)
-    BOOST_TEST(move_copy_conting_class::moves_count != 0);
+    BOOST_CHECK(move_copy_conting_class::moves_count != 0);
 
     move_copy_conting_class::moves_count = 0;
     move_copy_conting_class::copy_count = 0;
-    variant_I_type v5(std::move(v1));
+    variant_I_type v5(boost::move(v1));
     // Assuring that `move_copy_conting_class` in v1 was moved at least once and was not copied
-    BOOST_TEST(move_copy_conting_class::moves_count != 0);
-    BOOST_TEST(move_copy_conting_class::copy_count == 0);
+    BOOST_CHECK(move_copy_conting_class::moves_count != 0);
+    BOOST_CHECK(move_copy_conting_class::copy_count == 0);
 
     total_count = move_copy_conting_class::moves_count + move_copy_conting_class::copy_count;
     move_copy_conting_class::moves_count = 0;
     move_copy_conting_class::copy_count = 0;
     variant_I_type v6(v1);
     // Assuring that move constructor moves/copyes value not more times than copy constructor
-    BOOST_TEST(total_count <= move_copy_conting_class::moves_count + move_copy_conting_class::copy_count);
+    BOOST_CHECK(total_count <= move_copy_conting_class::moves_count + move_copy_conting_class::copy_count);
 }
 
 void run1()
@@ -139,11 +172,11 @@ void run1()
 
     move_copy_conting_class c1;
     typedef boost::variant<int, move_copy_conting_class> variant_I_type;
-    variant_I_type v1(std::move(c1));
+    variant_I_type v1(boost::move(c1));
     
     // Assuring that `move_copy_conting_class` was not copyied
-    BOOST_TEST(move_copy_conting_class::copy_count == 0);
-    BOOST_TEST(move_copy_conting_class::moves_count > 0);
+    BOOST_CHECK(move_copy_conting_class::copy_count == 0);
+    BOOST_CHECK(move_copy_conting_class::moves_count > 0);
 }
 
 struct move_only_structure {
@@ -156,51 +189,32 @@ private:
     move_only_structure& operator=(const move_only_structure&);
 };
 
-struct visitor_returning_move_only_type: boost::static_visitor<move_only_structure> {
-    template <class T>
-    move_only_structure operator()(const T&) const {
-        return move_only_structure();
-    }
-};
-
 void run_move_only()
 {
     move_only_structure mo;
     boost::variant<int, move_only_structure > vi, vi2(static_cast<move_only_structure&&>(mo));
-    BOOST_TEST(vi.which() == 0);
-    BOOST_TEST(vi2.which() == 1);
+    BOOST_CHECK(vi.which() == 0);
+    BOOST_CHECK(vi2.which() == 1);
 
     vi = 10;
     vi2 = 10;
-    BOOST_TEST(vi.which() == 0);
-    BOOST_TEST(vi2.which() == 0);
+    BOOST_CHECK(vi.which() == 0);
+    BOOST_CHECK(vi2.which() == 0);
 
     vi = static_cast<move_only_structure&&>(mo);
     vi2 = static_cast<move_only_structure&&>(mo);
-    BOOST_TEST(vi.which() == 1);
-
-    boost::variant<move_only_structure, int > rvi (1);
-    BOOST_TEST(rvi.which() == 1);
-    rvi = static_cast<move_only_structure&&>(mo);
-    BOOST_TEST(rvi.which() == 0);
-    rvi = 1;
-    BOOST_TEST(rvi.which() == 1);
-    rvi = static_cast<boost::variant<int, move_only_structure >&&>(vi2);
-    BOOST_TEST(rvi.which() == 0);
-
-    move_only_structure from_visitor = boost::apply_visitor(visitor_returning_move_only_type(), vi);
-    (void)from_visitor;
+    BOOST_CHECK(vi.which() == 1);
 }
 
 void run_moves_are_noexcept() {
-#if !defined(BOOST_NO_CXX11_NOEXCEPT) && (!defined(__GNUC__) || defined(__clang__) || __GNUC__ > 4 || __GNUC_MINOR__ >= 8)
+#ifndef BOOST_NO_CXX11_NOEXCEPT
     typedef boost::variant<int, short, double> variant_noexcept_t;
-    BOOST_TEST(boost::is_nothrow_move_assignable<variant_noexcept_t>::value);
-    BOOST_TEST(boost::is_nothrow_move_constructible<variant_noexcept_t>::value);
+    //BOOST_CHECK(boost::is_nothrow_move_assignable<variant_noexcept_t>::value);
+    BOOST_CHECK(boost::is_nothrow_move_constructible<variant_noexcept_t>::value);
 
     typedef boost::variant<int, short, double, move_only_structure> variant_except_t;
-    BOOST_TEST(!boost::is_nothrow_move_assignable<variant_except_t>::value);
-    BOOST_TEST(!boost::is_nothrow_move_constructible<variant_except_t>::value);
+    //BOOST_CHECK(!boost::is_nothrow_move_assignable<variant_except_t>::value);
+    BOOST_CHECK(!boost::is_nothrow_move_constructible<variant_except_t>::value);
 #endif
 }
 
@@ -219,16 +233,19 @@ void run_const_rvalues()
     v4 = get_string();
     v5 = get_variant();
     v6 = get_variant2();
-    v7 = std::move(v1);
+    v7 = boost::move(v1);
 }
 
+#endif
+
 struct nothrow_copyable_throw_movable {
     nothrow_copyable_throw_movable(){}
     nothrow_copyable_throw_movable(const nothrow_copyable_throw_movable&) BOOST_NOEXCEPT {}
     nothrow_copyable_throw_movable& operator=(const nothrow_copyable_throw_movable&) BOOST_NOEXCEPT { return *this; }
-
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
     nothrow_copyable_throw_movable(nothrow_copyable_throw_movable&&) BOOST_NOEXCEPT_IF(false) {}
     nothrow_copyable_throw_movable& operator=(nothrow_copyable_throw_movable&&) BOOST_NOEXCEPT_IF(false) { return *this; }
+#endif
 };
 
 // This test is created to cover the following situation:
@@ -239,35 +256,13 @@ void run_tricky_compilation_test()
     v = nothrow_copyable_throw_movable();
 }
 
-template <typename T>
-struct is_container : boost::mpl::false_ {};
-
-template <typename T>
-struct is_container<boost::variant<T> > : is_container<T> {};
-
-template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
-struct is_container<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
-  : boost::mpl::bool_<is_container<T0>::value
-     || is_container<boost::variant<BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)> >::value>
-{};
-
-void run_is_container_compilation_test()
+int test_main(int , char* [])
 {
-    BOOST_TEST((!is_container<boost::variant<double, int> >::value));
-    BOOST_TEST((!is_container<boost::variant<double, int, char> >::value));
-    BOOST_TEST((!is_container<boost::variant<double, int, char, float> >::value));
-}
-
-int main()
-{
-   swap_ambiguouty_test_ns::swap_ambiguouty_test();
    run();
    run1();
    run_move_only();
    run_moves_are_noexcept();
    run_tricky_compilation_test();
    run_const_rvalues();
-   run_is_container_compilation_test();
-
-   return boost::report_errors();
+   return 0;
 }

test/test1.cpp

@@ -16,7 +16,7 @@
 #pragma warning(disable:4244) // conversion from const int to const short
 #endif
 
-#include "boost/core/lightweight_test.hpp"
+#include "boost/test/minimal.hpp"
 #include "boost/variant.hpp"
 
 #include "class_a.h"
@@ -121,11 +121,11 @@ void run()
    v1 = 3.4f;
    apply_visitor(ts, v1);
 
-   BOOST_TEST(ts.result() == sizeof(int) + sizeof(double)*2);
+   BOOST_CHECK(ts.result() == sizeof(int) + sizeof(double)*2);
 
    v11 = 5;
    string res_s = apply_visitor(int_printer(), v11);
-   BOOST_TEST(res_s == "5");
+   BOOST_CHECK(res_s == "5");
 
    //
    // A variant object holding an std::vector 
@@ -138,13 +138,13 @@ void run()
 
    v11 = int_vec_1;
    res_s = apply_visitor(int_printer(), v11);
-   BOOST_TEST(res_s == ",512,256,128,64");
+   BOOST_CHECK(res_s == ",512,256,128,64");
 }
 
 
 
-int main()
+int test_main(int , char* [])
 {
-    run();
-    return boost::report_errors();
+   run();
+   return 0;
 }

test/test2.cpp

@@ -16,7 +16,7 @@
 #pragma warning(disable:4244) // conversion from 'const int' to 'const short'
 #endif
 
-#include "boost/core/lightweight_test.hpp"
+#include "boost/test/minimal.hpp"
 #include "boost/variant.hpp"
 
 #include "jobs.h"
@@ -141,9 +141,9 @@ void run()
 }
 
 
-int main()
+int test_main(int , char* [])
 {
-    run();
-    return boost::report_errors();
+   run();
+   return 0;
 }
 

test/test3.cpp

@@ -10,7 +10,7 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#include "boost/core/lightweight_test.hpp"
+#include "boost/test/minimal.hpp"
 #include "boost/variant.hpp"
 
 #include <iostream>
@@ -113,7 +113,7 @@ struct Calculator : boost::static_visitor<int>
 /////////////////////////////////////////////////////////////////////
 
 
-int main()
+int test_main(int, char* [])
 {
 
    int n = 13;
@@ -122,13 +122,15 @@ int main()
    std::ostringstream e1_str;
    e1_str << e1;
 
-   BOOST_TEST(e1.type() == boost::typeindex::type_id<Add>());
-   BOOST_TEST(e1_str.str() == "(13+((40+2)-(10+4)))");
+#if !defined(BOOST_NO_TYPEID)
+   BOOST_CHECK(e1.type() == typeid(Add));
+#endif
+   BOOST_CHECK(e1_str.str() == "(13+((40+2)-(10+4)))");
 
    //Evaluate expression
    int res = boost::apply_visitor(Calculator(), e1);
-   BOOST_TEST(res == n + 28);
+   BOOST_CHECK(res == n + 28);
 
-   return boost::report_errors();
+   return 0;
 }
 

test/test4.cpp

@@ -16,7 +16,7 @@
 #pragma warning(disable:4244) // conversion from 'const int' to 'const short'
 #endif
 
-#include "boost/core/lightweight_test.hpp"
+#include "boost/test/minimal.hpp"
 #include "boost/variant.hpp"
 
 #include "jobs.h"
@@ -32,7 +32,7 @@ typedef variant<std::string, class_a, short> var_type_2;
 
 #include "class_a.h"
 
-int main()
+int test_main(int , char* [])
 {
    using namespace boost;
 
@@ -53,5 +53,5 @@ int main()
    v2 = 5;
    v1 = v2;
 
-   return boost::report_errors();
+   return boost::exit_success;
 }

test/test5.cpp

@@ -10,7 +10,7 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#include "boost/core/lightweight_test.hpp"
+#include "boost/test/minimal.hpp"
 #include "boost/variant.hpp"
 
 #include "jobs.h"
@@ -58,14 +58,14 @@ void run()
    verify(v3, spec<int>());
 
 
-   BOOST_TEST(apply_visitor(sum_int(), v2) == c0);
-   BOOST_TEST(apply_visitor(sum_int(), v3) == c0);
+   BOOST_CHECK(apply_visitor(sum_int(), v2) == c0);
+   BOOST_CHECK(apply_visitor(sum_int(), v3) == c0);
 
    sum_int adder;
    apply_visitor(adder, v2);
    apply_visitor(adder, v3);
 
-   BOOST_TEST(adder.result() == 2*c0);
+   BOOST_CHECK(adder.result() == 2*c0);
 
    //
    // A variant holding a variant
@@ -82,9 +82,9 @@ void run()
 
 
 
-int main()
+int test_main(int , char* [])
 {
    run();
-   return boost::report_errors();
+   return 0;
 }
 

test/test6.cpp

@@ -10,7 +10,7 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#include "boost/core/lightweight_test.hpp"
+#include "boost/test/minimal.hpp"
 #include "boost/variant.hpp"
 
 #include <iostream>
@@ -66,9 +66,9 @@ void run()
 
 
 
-int main()
+int test_main(int , char* [])
 {
    run();
-   return boost::report_errors();
+   return 0;
 }
 

test/test7.cpp

@@ -16,7 +16,7 @@
 #pragma warning(disable:4244) // conversion from 'const int' to 'const short'
 #endif
 
-#include "boost/core/lightweight_test.hpp"
+#include "boost/test/minimal.hpp"
 #include "boost/variant.hpp"
 
 #include "jobs.h"
@@ -69,8 +69,8 @@ struct Tracker
    static void remove(const jas& j)
    {
       iterator_type iter = s_this_to_sn_.find(&j);
-      BOOST_TEST(iter != s_this_to_sn_.end());
-      BOOST_TEST( ((*iter).second) == j.sn_);
+      BOOST_CHECK(iter != s_this_to_sn_.end());
+      BOOST_CHECK( ((*iter).second) == j.sn_);
 
       int sn = (*iter).second;
       if(sn != j.sn_)
@@ -79,7 +79,7 @@ struct Tracker
             << ", other: this = " << &j << ", j.sn_ = " << j.sn_ << endl;
       }
 
-      BOOST_TEST(sn == j.sn_);
+      BOOST_CHECK(sn == j.sn_);
 
    
 
@@ -91,7 +91,7 @@ struct Tracker
 
    static void check()
    {
-      BOOST_TEST(s_this_to_sn_.empty());      
+      BOOST_CHECK(s_this_to_sn_.empty());      
    }
 };
 
@@ -214,13 +214,13 @@ void var_compare(const VariantType& v, ExpectedType expected)
    compare_helper<ExpectedType> ch(expected);
 
    bool checks = boost::apply_visitor(ch, v);
-   BOOST_TEST(checks);
+   BOOST_CHECK(checks);
 }
 
 
 void run()
 {   
-   boost::variant<string, short> v0;
+   variant<string, short> v0;
 
    var_compare(v0, string(""));
 
@@ -230,7 +230,7 @@ void run()
    v0 = "penny lane";
    var_compare(v0, string("penny lane"));
 
-   boost::variant<jas, string, int> v1, v2 = jas(195);
+   variant<jas, string, int> v1, v2 = jas(195);
    var_compare(v1, jas(364));
 
    v1 = jas(500);
@@ -240,16 +240,16 @@ void run()
    var_compare(v2, jas(500));
 
 
-   boost::variant<string, int> v3;
+   variant<string, int> v3;
    var_compare(v3, string(""));
 }
 
 
-int main()
+int test_main(int , char* [])
 {
    run();
    Tracker::check();
 
-   return boost::report_errors();
+   return 0;
 }
 

test/test8.cpp

@@ -10,13 +10,14 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#include "boost/core/lightweight_test.hpp"
+#include "boost/test/minimal.hpp"
 #include "boost/variant.hpp"
 
 #include <iostream>
 #include <vector>
 #include <string>
 
+using namespace std;
 using namespace boost;
 
 typedef variant<float, std::string, int, std::vector<std::string> > t_var1;
@@ -40,12 +41,12 @@ struct int_sum : static_visitor<>
 template <typename T, typename Variant>
 T& check_pass(Variant& v, T value)
 {
-    BOOST_TEST(get<T>(&v));
+    BOOST_CHECK(get<T>(&v));
 
     try
     {
         T& r = get<T>(v);
-        BOOST_TEST(r == value);
+        BOOST_CHECK(r == value);
         return r;
     }
     catch(boost::bad_get&)
@@ -57,21 +58,21 @@ T& check_pass(Variant& v, T value)
 template <typename T, typename Variant>
 void check_fail(Variant& v)
 {
-    BOOST_TEST(!relaxed_get<T>(&v));
+    BOOST_CHECK(!get<T>(&v));
 
     try
     {
-        T& r = relaxed_get<T>(v);
+        T& r = get<T>(v);
         (void)r; // suppress warning about r not being used
-        BOOST_TEST(false && relaxed_get<T>(&v)); // should never reach
+        BOOST_CHECK(false && &r); // should never reach
     }
-    catch(const boost::bad_get& e)
+    catch(boost::bad_get&)
     {
-        BOOST_TEST(!!e.what()); // make sure that what() is const qualified and returnes something
+        // (do nothing here)
     }
 }
 
-int main()
+int test_main(int , char* [])
 {
    int_sum acc;
    t_var1 v1 = 800;
@@ -87,12 +88,12 @@ int main()
       check_fail<const short>(v1);
 
       apply_visitor(acc, v1);
-      BOOST_TEST(acc.result_ == 800);
+      BOOST_CHECK(acc.result_ == 800);
 
       r1 = 920; // NOTE: modifies content of v1
       apply_visitor(acc, v1);
-      BOOST_TEST(cr1 == 920);
-      BOOST_TEST(acc.result_ == 800 + 920);
+      BOOST_CHECK(cr1 == 920);
+      BOOST_CHECK(acc.result_ == 800 + 920);
    }
 
    // check const correctness:
@@ -108,6 +109,6 @@ int main()
       //check_fail<short>(c);
    }
 
-   return boost::report_errors();
+   return boost::exit_success;
 }
 

test/test9.cpp

@@ -1,22 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost-libs variant/test/test9.cpp source file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2016-2026 Antony Polukhin
-//
-// 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)
-
-
-// Test from https://github.com/boostorg/variant/pull/21
-
-#include <boost/fusion/container/vector.hpp>
-#include <boost/fusion/mpl.hpp>
-#include <boost/variant/variant.hpp>
-
-int main() {
-    boost::make_variant_over<boost::fusion::vector<int, char> >::type t;
-    (void)t;
-}

test/variant_comparison_test.cpp

@@ -3,15 +3,15 @@
 // See http://www.boost.org for updates, documentation, and revision history.
 //-----------------------------------------------------------------------------
 //
-// Copyright (c) 2003 Eric Friedman, Itay Maman
-// Copyright (c) 2014-2026 Antony Polukhin
+// Copyright (c) 2003
+// Eric Friedman, Itay Maman
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include "boost/variant/variant.hpp"
-#include "boost/core/lightweight_test.hpp"
+#include "boost/test/minimal.hpp"
 
 #include <iostream>
 #include <sstream>
@@ -21,7 +21,7 @@
 #include <vector>
 
 #include "boost/detail/workaround.hpp"
-#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x0551))
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))
 #    pragma warn -lvc // temporary used for parameter warning
 #endif
 
@@ -31,38 +31,29 @@ void assert_equality_comparable(
     )
 {
     // identity check
-    BOOST_TEST( !(&x == &y) || (x == y) );
-    BOOST_TEST( !(&x == &z) || (x == z) );
-    BOOST_TEST( !(&y == &z) || (y == z) );
-    BOOST_TEST( !(&x == &y) || !(x != y) );
-    BOOST_TEST( !(&x == &z) || !(x != z) );
-    BOOST_TEST( !(&y == &z) || !(y != z) );
+    BOOST_CHECK( !(&x == &y) || (x == y) );
+    BOOST_CHECK( !(&x == &z) || (x == z) );
+    BOOST_CHECK( !(&y == &z) || (y == z) );
 
     // reflexivity check
-    BOOST_TEST( (x == x) );
-    BOOST_TEST( (y == y) );
-    BOOST_TEST( (z == z) );
+    BOOST_CHECK( (x == x) );
+    BOOST_CHECK( (y == y) );
+    BOOST_CHECK( (z == z) );
 
     // symmetry check
-    BOOST_TEST( !(x == y) || (y == x) );
-    BOOST_TEST( !(y == x) || (x == y) );
-    BOOST_TEST( (x != y) || (y == x) );
-    BOOST_TEST( (y != x) || (x == y) );
+    BOOST_CHECK( !(x == y) || (y == x) );
+    BOOST_CHECK( !(y == x) || (x == y) );
 
-    BOOST_TEST( !(x == z) || (z == x) );
-    BOOST_TEST( !(z == x) || (x == z) );
-    BOOST_TEST( (x != z) || (z == x) );
-    BOOST_TEST( (z != x) || (x == z) );
+    BOOST_CHECK( !(x == z) || (z == x) );
+    BOOST_CHECK( !(z == x) || (x == z) );
 
-    BOOST_TEST( !(y == z) || (z == y) );
-    BOOST_TEST( !(z == y) || (y == z) );
-    BOOST_TEST( (y != z) || (z == y) );
-    BOOST_TEST( (z != y) || (y == z) );
+    BOOST_CHECK( !(y == z) || (z == y) );
+    BOOST_CHECK( !(z == y) || (y == z) );
 
     // transitivity check
-    BOOST_TEST( !(x == y && y == z) || (x == z) );
-    BOOST_TEST( !(x == z && z == y) || (x == y) );
-    BOOST_TEST( !(y == z && z == x) || (y == x) );
+    BOOST_CHECK( !(x == y && y == z) || (x == z) );
+    BOOST_CHECK( !(x == z && z == y) || (x == y) );
+    BOOST_CHECK( !(y == z && z == x) || (y == x) );
 }
 
 template <typename T>
@@ -71,41 +62,19 @@ void assert_less_than_comparable(
     )
 {
     // irreflexivity check
-    BOOST_TEST( !(x < x) );
-    BOOST_TEST( !(y < y) );
-    BOOST_TEST( !(z < z) );
-    BOOST_TEST( !(x > x) );
-    BOOST_TEST( !(y > y) );
-    BOOST_TEST( !(z > z) );
-
-    BOOST_TEST( (x <= x) );
-    BOOST_TEST( (y <= y) );
-    BOOST_TEST( (z <= z) );
-    BOOST_TEST( (x >= x) );
-    BOOST_TEST( (y >= y) );
-    BOOST_TEST( (z >= z) );
+    BOOST_CHECK( !(x < x) );
+    BOOST_CHECK( !(y < y) );
+    BOOST_CHECK( !(z < z) );
 
     // transitivity check
-    BOOST_TEST( (x < y) );
-    BOOST_TEST( (y < z) );
-    BOOST_TEST( (x < z) );
-
-    BOOST_TEST( (x <= y) );
-    BOOST_TEST( (y <= z) );
-    BOOST_TEST( (x <= z) );
-
-    BOOST_TEST( (z > y) );
-    BOOST_TEST( (y > x) );
-    BOOST_TEST( (z > x) );
-
-    BOOST_TEST( (z >= y) );
-    BOOST_TEST( (y >= x) );
-    BOOST_TEST( (z >= x) );
+    BOOST_CHECK( (x < y) );
+    BOOST_CHECK( (y < z) );
+    BOOST_CHECK( (x < z) );
 
     // antisymmetry check
-    BOOST_TEST( !(y < x) );
-    BOOST_TEST( !(z < y) );
-    BOOST_TEST( !(z < x) );
+    BOOST_CHECK( !(y < x) );
+    BOOST_CHECK( !(z < y) );
+    BOOST_CHECK( !(z < x) );
 }
 
 template <typename It>
@@ -122,7 +91,7 @@ std::string print_range(It first, It last)
     return result.str();
 }
 
-int main()
+int test_main(int , char* [])
 {
     typedef boost::variant<int, std::string> var_t;
     
@@ -146,13 +115,7 @@ int main()
     std::sort(vec.begin(), vec.end());
 
     std::string sort_result( print_range(vec.begin(), vec.end()) );
-    BOOST_TEST( sort_result == "3 5 goodbye hello " );
+    BOOST_CHECK( sort_result == "3 5 goodbye hello " );
 
-    // https://svn.boost.org/trac/boost/ticket/11751
-    int a = 0, b = 0;
-
-    boost::variant< int& > v (a), u (b);
-    BOOST_TEST(v == u);
-
-    return boost::report_errors();
+    return boost::exit_success;
 }

test/variant_get_test.cpp

@@ -1,417 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost-libs variant/test/variant_get_test.cpp source file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2014-2026 Antony Polukhin
-//
-// 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)
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4127) // conditional expression is constant
-#pragma warning(disable: 4181) // qualifier applied to reference type; ignored
-#endif
-
-#include "boost/variant/get.hpp"
-#include "boost/variant/variant.hpp"
-#include "boost/variant/polymorphic_get.hpp"
-#include "boost/variant/recursive_wrapper.hpp"
-#include "boost/core/lightweight_test.hpp"
-
-struct base {
-    int trash;
-
-    base() : trash(123) {}
-    base(const base& b) : trash(b.trash) { int i = 100; (void)i; }
-    const base& operator=(const base& b) {
-        trash = b.trash;
-        int i = 100; (void)i;
-
-        return *this;
-    }
-
-    virtual ~base(){}
-};
-
-struct derived1 : base{};
-struct derived2 : base{};
-
-struct vbase { short trash; virtual ~vbase(){} virtual int foo() const { return 0; }  };
-struct vderived1 : virtual vbase{ virtual int foo() const { return 1; } };
-struct vderived2 : virtual vbase{ virtual int foo() const { return 3; } };
-struct vderived3 : vderived1, vderived2 { virtual int foo() const { return 3; } };
-
-typedef boost::variant<int, base, derived1, derived2, std::string> var_t;
-typedef boost::variant<int, derived1, derived2, std::string> var_t_shortened;
-typedef boost::variant<base, derived1, derived2> var_t_no_fallback;
-typedef boost::variant<int&, base&, derived1&, derived2&, std::string&> var_ref_t;
-typedef boost::variant<const int&, const base&, const derived1&, const derived2&, const std::string&> var_cref_t;
-
-struct recursive_structure;
-typedef boost::variant<
-    int, base, derived1, derived2, std::string, boost::recursive_wrapper<recursive_structure>
-> var_req_t;
-struct recursive_structure { var_req_t var; };
-
-template <class TypeInVariant, class V, class TestType>
-inline void check_polymorphic_get_on_types_impl_single_type(V* v)
-{
-    typedef typename boost::add_reference<TestType>::type ref_test_t;
-    typedef typename boost::add_reference<const TestType>::type cref_test_t;
-    const bool exact_same = !!boost::is_same<TypeInVariant, TestType>::value;
-    const bool ref_same = !!boost::is_same<TypeInVariant, ref_test_t>::value;
-
-    if (exact_same || ref_same) {
-        BOOST_TEST(boost::polymorphic_get<TestType>(v));
-        BOOST_TEST(boost::polymorphic_get<const TestType>(v));
-        BOOST_TEST(boost::polymorphic_strict_get<TestType>(v));
-        BOOST_TEST(boost::polymorphic_strict_get<const TestType>(v));
-        BOOST_TEST(boost::polymorphic_relaxed_get<TestType>(v));
-        BOOST_TEST(boost::polymorphic_relaxed_get<const TestType>(v));
-
-        BOOST_TEST(boost::polymorphic_get<cref_test_t>(v));
-        BOOST_TEST(boost::polymorphic_strict_get<cref_test_t>(v));
-        BOOST_TEST(boost::polymorphic_relaxed_get<cref_test_t>(v));
-
-        if (ref_same) {
-            BOOST_TEST(boost::polymorphic_get<ref_test_t>(v));
-            BOOST_TEST(boost::polymorphic_get<cref_test_t>(v));
-            BOOST_TEST(boost::polymorphic_strict_get<ref_test_t>(v));
-            BOOST_TEST(boost::polymorphic_strict_get<cref_test_t>(v));
-            BOOST_TEST(boost::polymorphic_relaxed_get<ref_test_t>(v));
-            BOOST_TEST(boost::polymorphic_relaxed_get<cref_test_t>(v));
-        }
-    } else {
-        BOOST_TEST(!boost::polymorphic_get<TestType>(v));
-        BOOST_TEST(!boost::polymorphic_get<const TestType>(v));
-        BOOST_TEST(!boost::polymorphic_strict_get<TestType>(v));
-        BOOST_TEST(!boost::polymorphic_strict_get<const TestType>(v));
-        BOOST_TEST(!boost::polymorphic_relaxed_get<TestType>(v));
-        BOOST_TEST(!boost::polymorphic_relaxed_get<const TestType>(v));
-    }
-}
-
-template <class T, class V, class TestType>
-inline void check_get_on_types_impl_single_type(V* v)
-{
-    typedef typename boost::add_reference<TestType>::type ref_test_t;
-    typedef typename boost::add_reference<const TestType>::type cref_test_t;
-    const bool exact_same = !!boost::is_same<T, TestType>::value;
-    const bool ref_same = !!boost::is_same<T, ref_test_t>::value;
-
-    if (exact_same || ref_same) {
-        BOOST_TEST(boost::get<TestType>(v));
-        BOOST_TEST(boost::get<const TestType>(v));
-        BOOST_TEST(boost::strict_get<TestType>(v));
-        BOOST_TEST(boost::strict_get<const TestType>(v));
-        BOOST_TEST(boost::relaxed_get<TestType>(v));
-        BOOST_TEST(boost::relaxed_get<const TestType>(v));
-
-        BOOST_TEST(boost::get<cref_test_t>(v));
-        BOOST_TEST(boost::strict_get<cref_test_t>(v));
-        BOOST_TEST(boost::relaxed_get<cref_test_t>(v));
-
-        if (ref_same) {
-            BOOST_TEST(boost::get<ref_test_t>(v));
-            BOOST_TEST(boost::get<cref_test_t>(v));
-            BOOST_TEST(boost::strict_get<ref_test_t>(v));
-            BOOST_TEST(boost::strict_get<cref_test_t>(v));
-            BOOST_TEST(boost::relaxed_get<ref_test_t>(v));
-            BOOST_TEST(boost::relaxed_get<cref_test_t>(v));
-        }
-    } else {
-        BOOST_TEST(!boost::get<TestType>(v));
-        BOOST_TEST(!boost::get<const TestType>(v));
-        BOOST_TEST(!boost::strict_get<TestType>(v));
-        BOOST_TEST(!boost::strict_get<const TestType>(v));
-        BOOST_TEST(!boost::relaxed_get<TestType>(v));
-        BOOST_TEST(!boost::relaxed_get<const TestType>(v));
-    }
-}
-
-template <class T, class V>
-inline void check_get_on_types_impl(V* v)
-{
-    check_get_on_types_impl_single_type<T, V, int>(v);
-    check_polymorphic_get_on_types_impl_single_type<T, V, int>(v);
-
-    check_get_on_types_impl_single_type<T, V, base>(v);
-
-    check_get_on_types_impl_single_type<T, V, derived1>(v);
-    check_polymorphic_get_on_types_impl_single_type<T, V, derived1>(v);
-
-    check_get_on_types_impl_single_type<T, V, derived2>(v);
-    check_polymorphic_get_on_types_impl_single_type<T, V, derived2>(v);
-
-    check_get_on_types_impl_single_type<T, V, std::string>(v);
-    check_polymorphic_get_on_types_impl_single_type<T, V, std::string>(v);
-
-    // Never exist in here
-    BOOST_TEST(!boost::relaxed_get<short>(v));
-    BOOST_TEST(!boost::relaxed_get<const short>(v));
-    BOOST_TEST(!boost::relaxed_get<char>(v));
-    BOOST_TEST(!boost::relaxed_get<char*>(v));
-    BOOST_TEST(!boost::relaxed_get<bool>(v));
-    BOOST_TEST(!boost::relaxed_get<const bool>(v));
-
-    BOOST_TEST(!boost::polymorphic_relaxed_get<short>(v));
-    BOOST_TEST(!boost::polymorphic_relaxed_get<const short>(v));
-    BOOST_TEST(!boost::polymorphic_relaxed_get<char>(v));
-    BOOST_TEST(!boost::polymorphic_relaxed_get<char*>(v));
-    BOOST_TEST(!boost::polymorphic_relaxed_get<bool>(v));
-    BOOST_TEST(!boost::polymorphic_relaxed_get<const bool>(v));
-
-    boost::get<T>(*v);              // Must compile
-    boost::get<const T>(*v);        // Must compile
-    boost::strict_get<T>(*v);         // Must compile
-    boost::strict_get<const T>(*v);   // Must compile
-
-    bool is_ref = boost::is_lvalue_reference<T>::value;
-    (void)is_ref;
-    if (!is_ref) {
-        boost::polymorphic_get<T>(*v);              // Must compile
-        boost::polymorphic_get<const T>(*v);        // Must compile
-        boost::polymorphic_strict_get<T>(*v);         // Must compile
-        boost::polymorphic_strict_get<const T>(*v);   // Must compile
-    }
-}
-
-template <class T, class V>
-inline void check_get_on_types(V* v)
-{
-    check_get_on_types_impl<T, V>(v);
-    check_get_on_types_impl<T, const V>(v);
-}
-
-inline void get_test()
-{
-    var_t v;
-    check_get_on_types<int>(&v);
-
-    var_t(base()).swap(v);
-    check_get_on_types<base>(&v);
-
-    var_t(derived1()).swap(v);
-    check_get_on_types<derived1>(&v);
-
-    var_t(derived2()).swap(v);
-    check_get_on_types<derived2>(&v);
-
-    var_t(std::string("Hello")).swap(v);
-    check_get_on_types<std::string>(&v);
-
-    var_t_shortened vs = derived2();
-    check_polymorphic_get_on_types_impl_single_type<derived2, var_t_shortened, int>(&vs);
-    check_polymorphic_get_on_types_impl_single_type<derived2, const var_t_shortened, int>(&vs);
-    // Checking that Base is really determinated
-    check_polymorphic_get_on_types_impl_single_type<base, var_t_shortened, base>(&vs);
-    check_polymorphic_get_on_types_impl_single_type<base, const var_t_shortened, base>(&vs);
-
-    vs = derived1();
-    check_polymorphic_get_on_types_impl_single_type<derived2, var_t_shortened, int>(&vs);
-    check_polymorphic_get_on_types_impl_single_type<derived2, const var_t_shortened, int>(&vs);
-    // Checking that Base is really determinated
-    check_polymorphic_get_on_types_impl_single_type<base, var_t_shortened, base>(&vs);
-    check_polymorphic_get_on_types_impl_single_type<base, const var_t_shortened, base>(&vs);
-}
-
-inline void get_test_no_fallback()
-{
-    var_t_no_fallback v;
-    var_t_no_fallback(base()).swap(v);
-    check_polymorphic_get_on_types_impl_single_type<base, var_t_no_fallback, base>(&v);
-    check_polymorphic_get_on_types_impl_single_type<base, const var_t_no_fallback, base>(&v);
-    check_get_on_types_impl_single_type<base, var_t_no_fallback, base>(&v);
-    check_get_on_types_impl_single_type<base, const var_t_no_fallback, base>(&v);
-
-    var_t_no_fallback(derived1()).swap(v);
-    check_polymorphic_get_on_types_impl_single_type<base, var_t_no_fallback, base>(&v);
-    check_polymorphic_get_on_types_impl_single_type<base, const var_t_no_fallback, base>(&v);
-    check_get_on_types_impl_single_type<derived1, var_t_no_fallback, derived1>(&v);
-    check_get_on_types_impl_single_type<derived1, const var_t_no_fallback, derived1>(&v);
-
-    var_t_no_fallback(derived2()).swap(v);
-    check_polymorphic_get_on_types_impl_single_type<base, var_t_no_fallback, base>(&v);
-    check_polymorphic_get_on_types_impl_single_type<base, const var_t_no_fallback, base>(&v);
-    check_get_on_types_impl_single_type<derived2, var_t_no_fallback, derived2>(&v);
-    check_get_on_types_impl_single_type<derived2, const var_t_no_fallback, derived2>(&v);
-}
-
-inline void get_ref_test()
-{
-    int i = 0;
-    var_ref_t v(i);
-    check_get_on_types<int>(&v);
-    check_get_on_types<int&>(&v);
-
-    base b;
-    var_ref_t v1(b);
-    check_get_on_types<base>(&v1);
-    check_get_on_types<base&>(&v1);
-
-    derived1 d1;
-    var_ref_t v2(d1);
-    check_get_on_types<derived1>(&v2);
-    check_get_on_types<derived1&>(&v2);
-
-    derived2 d2;
-    var_ref_t v3(d2);
-    check_get_on_types<derived2>(&v3);
-    check_get_on_types<derived2&>(&v3);
-
-    std::string s("Hello");
-    var_ref_t v4(s);
-    check_get_on_types<std::string>(&v4);
-    check_get_on_types<std::string&>(&v4);
-}
-
-
-inline void get_cref_test()
-{
-    int i = 0;
-    var_cref_t v(i);
-    BOOST_TEST(boost::get<const int>(&v));
-    BOOST_TEST(boost::get<const int&>(&v));
-    BOOST_TEST(!boost::get<const base>(&v));
-
-    base b;
-    var_cref_t v1(b);
-    BOOST_TEST(boost::get<const base>(&v1));
-    BOOST_TEST(!boost::get<const derived1>(&v1));
-    BOOST_TEST(!boost::get<const int>(&v1));
-
-    std::string s("Hello");
-    const var_cref_t v4 = s;
-    BOOST_TEST(boost::get<const std::string>(&v4));
-    BOOST_TEST(!boost::get<const int>(&v4));
-}
-
-inline void get_recursive_test()
-{
-    var_req_t v;
-    check_get_on_types<int>(&v);
-
-    var_req_t(base()).swap(v);
-    check_get_on_types<base>(&v);
-
-    var_req_t(derived1()).swap(v);
-    check_get_on_types<derived1>(&v);
-
-    var_req_t(derived2()).swap(v);
-    check_get_on_types<derived2>(&v);
-
-    var_req_t(std::string("Hello")).swap(v);
-    check_get_on_types<std::string>(&v);
-
-    recursive_structure s = { v }; // copying "v"
-    v = s;
-    check_get_on_types<recursive_structure>(&v);
-}
-
-template <class T>
-inline void check_that_does_not_exist_impl()
-{
-    using namespace boost::detail::variant;
-
-    BOOST_TEST((holds_element<T, const int>::value));
-    BOOST_TEST((!holds_element<T, short>::value));
-    BOOST_TEST((!holds_element<T, short>::value));
-    BOOST_TEST((!holds_element<T, const short>::value));
-    BOOST_TEST((!holds_element<T, char*>::value));
-    BOOST_TEST((!holds_element<T, const char*>::value));
-    BOOST_TEST((!holds_element<T, char[5]>::value));
-    BOOST_TEST((!holds_element<T, const char[5]>::value));
-    BOOST_TEST((!holds_element<T, bool>::value));
-    BOOST_TEST((!holds_element<T, const bool>::value));
-
-    BOOST_TEST((!holds_element<T, boost::recursive_wrapper<int> >::value));
-    BOOST_TEST((!holds_element<T, boost::recursive_wrapper<short> >::value));
-    BOOST_TEST((!holds_element<T, boost::detail::reference_content<short> >::value));
-
-
-    BOOST_TEST((holds_element_polymorphic<T, const int>::value));
-    BOOST_TEST((!holds_element_polymorphic<T, short>::value));
-    BOOST_TEST((!holds_element_polymorphic<T, short>::value));
-    BOOST_TEST((!holds_element_polymorphic<T, const short>::value));
-    BOOST_TEST((!holds_element_polymorphic<T, char*>::value));
-    BOOST_TEST((!holds_element_polymorphic<T, const char*>::value));
-    BOOST_TEST((!holds_element_polymorphic<T, char[5]>::value));
-    BOOST_TEST((!holds_element_polymorphic<T, const char[5]>::value));
-    BOOST_TEST((!holds_element_polymorphic<T, bool>::value));
-    BOOST_TEST((!holds_element_polymorphic<T, const bool>::value));
-
-    BOOST_TEST((!holds_element_polymorphic<T, boost::recursive_wrapper<int> >::value));
-    BOOST_TEST((!holds_element_polymorphic<T, boost::recursive_wrapper<short> >::value));
-    BOOST_TEST((!holds_element_polymorphic<T, boost::detail::reference_content<short> >::value));
-}
-
-inline void check_that_does_not_exist()
-{
-    using namespace boost::detail::variant;
-
-    BOOST_TEST((holds_element<var_t, int>::value));
-    BOOST_TEST((holds_element<var_ref_t, int>::value));
-    BOOST_TEST((!holds_element<var_cref_t, int>::value));
-
-    check_that_does_not_exist_impl<var_t>();
-    check_that_does_not_exist_impl<var_ref_t>();
-    check_that_does_not_exist_impl<var_cref_t>();
-    check_that_does_not_exist_impl<var_req_t>();
-}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-class MoveonlyType {
-public:
-    MoveonlyType() {}
-    ~MoveonlyType() {}
-
-    MoveonlyType(MoveonlyType&&) {}
-    void operator=(MoveonlyType&&) {}
-
-private:
-    MoveonlyType(const MoveonlyType&);
-    void operator=(const MoveonlyType&);
-};
-
-const boost::variant<int, std::string> foo1() { return ""; }
-boost::variant<int, std::string> foo2() { return ""; }
-
-inline void get_rvref_test()
-{
-  boost::get<std::string>(foo1());
-  boost::get<std::string>(foo2());
-
-  boost::variant<MoveonlyType, int> v;
-
-  v = MoveonlyType();
-  boost::get<MoveonlyType>(std::move(v));
-
-  v = 3;
-
-  v = MoveonlyType();
-  boost::get<MoveonlyType>(v);
-
-  boost::relaxed_get<MoveonlyType&>(boost::variant<MoveonlyType, int>());
-
-  v = MoveonlyType();
-  MoveonlyType moved_from_variant(boost::get<MoveonlyType>(std::move(v)));
-}
-#endif  // BOOST_NO_CXX11_RVALUE_REFERENCES
-
-int main()
-{
-    get_test();
-    get_test_no_fallback();
-    get_ref_test();
-    get_cref_test();
-    get_recursive_test();
-    check_that_does_not_exist();
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    get_rvref_test();
-#endif
-
-    return boost::report_errors();
-}

test/variant_multivisit_test.cpp

@@ -3,88 +3,64 @@
 // See http://www.boost.org for updates, documentation, and revision history.
 //-----------------------------------------------------------------------------
 //
-// Copyright (c) 2013-2026 Antony Polukhin
+// Copyright (c) 2013
+// Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include "boost/config.hpp"
-#include "boost/noncopyable.hpp"
 #define BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS 5
 #include "boost/variant/multivisitors.hpp"
-#include "boost/variant.hpp"
 
-#include "boost/core/lightweight_test.hpp"
+#include "boost/test/minimal.hpp"
 
-struct my_noncopyable : boost::noncopyable {
-    my_noncopyable(){}
-    ~my_noncopyable(){}
-};
-
-typedef boost::variant<my_noncopyable, int>         variant_noncopy_t;
-
-
-typedef boost::variant<char, unsigned char, signed char, unsigned short, int>         variant5_t;
+typedef boost::variant<char, unsigned char, signed char, unsigned short, int, unsigned int>         variant6_t;
 
 struct test_visitor: boost::static_visitor<> {
     // operators that shall not be called
     template <class  T1, class  T2, class  T3>
-    void operator()(T1&, T2&, T3&) const 
+    void operator()(T1, T2, T3) const 
     {
-        BOOST_TEST(false);
+        BOOST_CHECK(false);
     }
 
     template <class  T1, class  T2, class  T3, class  T4>
-    void operator()(T1&, T2&, T3&, T4&) const 
+    void operator()(T1, T2, T3, T4) const 
     {
-        BOOST_TEST(false);
+        BOOST_CHECK(false);
     }
 
     template <class  T1, class  T2, class  T3, class  T4, class  T5>
-    void operator()(T1&, T2&, T3&, T4&, T5&) const 
+    void operator()(T1, T2, T3, T4, T5) const 
     {
-        BOOST_TEST(false);
+        BOOST_CHECK(false);
     }
 
     // operators that are OK to call
     void operator()(char v0, unsigned char v1, signed char v2) const 
     {
-        BOOST_TEST(v0 == 0);
-        BOOST_TEST(v1 == 1);
-        BOOST_TEST(v2 == 2);
+        BOOST_CHECK(v0 == 0);
+        BOOST_CHECK(v1 == 1);
+        BOOST_CHECK(v2 == 2);
     }
 
     void operator()(char v0, unsigned char v1, signed char v2, unsigned short v3) const 
     {
-        BOOST_TEST(v0 == 0);
-        BOOST_TEST(v1 == 1);
-        BOOST_TEST(v2 == 2);
-        BOOST_TEST(v3 == 3);
+        BOOST_CHECK(v0 == 0);
+        BOOST_CHECK(v1 == 1);
+        BOOST_CHECK(v2 == 2);
+        BOOST_CHECK(v3 == 3);
     }
 
     void operator()(char v0, unsigned char v1, signed char v2, unsigned short v3, int v4) const 
     {
-        BOOST_TEST(v0 == 0);
-        BOOST_TEST(v1 == 1);
-        BOOST_TEST(v2 == 2);
-        BOOST_TEST(v3 == 3);
-        BOOST_TEST(v4 == 4);
-    }
-
-
-    // Noncopyables
-    void operator()(my_noncopyable&, my_noncopyable&, my_noncopyable&) const {
-        BOOST_TEST(true);
-    }
-    void operator()(my_noncopyable&, my_noncopyable&, my_noncopyable&, my_noncopyable&) const {
-        BOOST_TEST(true);
-    }
-    void operator()(my_noncopyable&, my_noncopyable&, my_noncopyable&, my_noncopyable&, my_noncopyable&) const {
-        BOOST_TEST(true);
-    }
-    void operator()(my_noncopyable&, my_noncopyable&, my_noncopyable&, my_noncopyable&, my_noncopyable&, my_noncopyable&) const {
-        BOOST_TEST(true);
+        BOOST_CHECK(v0 == 0);
+        BOOST_CHECK(v1 == 1);
+        BOOST_CHECK(v2 == 2);
+        BOOST_CHECK(v3 == 3);
+        BOOST_CHECK(v4 == 4);
     }
 };
 
@@ -92,9 +68,9 @@ typedef boost::variant<int, double, bool> bool_like_t;
 typedef boost::variant<int, double> arithmetics_t;
 
 struct if_visitor: public boost::static_visitor<arithmetics_t> {
-    template <class T0, class T1, class T2>
-    arithmetics_t operator()(T0 b, T1 v1, T2 v2) const {
-        if (!!b) {
+    template <class T1, class T2>
+    arithmetics_t operator()(bool b, T1 v1, T2 v2) const {
+        if (b) {
             return v1;
         } else {
             return v2;
@@ -103,54 +79,46 @@ struct if_visitor: public boost::static_visitor<arithmetics_t> {
 };
 
 
-int main()
+int test_main(int , char* [])
 {
     test_visitor v;
 
-    variant5_t v_array5[5];
-    v_array5[0] = char(0);
-    v_array5[1] = static_cast<unsigned char>(1);
-    v_array5[2] = static_cast<signed char>(2);
-    v_array5[3] = static_cast<unsigned short>(3);
-    v_array5[4] = static_cast<int>(4);
+    variant6_t v_array6[6];
+    v_array6[0] = char(0);
+    v_array6[1] = static_cast<unsigned char>(1);
+    v_array6[2] = static_cast<signed char>(2);
+    v_array6[3] = static_cast<unsigned short>(3);
+    v_array6[4] = static_cast<int>(4);
+    v_array6[5] = static_cast<unsigned int>(5);
 
-    boost::apply_visitor(v, v_array5[0], v_array5[1], v_array5[2]);
-    boost::apply_visitor(test_visitor(), v_array5[0], v_array5[1], v_array5[2]);
+    boost::apply_visitor(v, v_array6[0], v_array6[1], v_array6[2]);
+    boost::apply_visitor(test_visitor(), v_array6[0], v_array6[1], v_array6[2]);
 
 // Following test also pass, but requires many Gigabytes of RAM for compilation and compile for about 15 minutes
 //#define BOOST_VARIANT_MULTIVISITORS_TEST_VERY_EXTREME
 #ifdef BOOST_VARIANT_MULTIVISITORS_TEST_VERY_EXTREME    
-    boost::apply_visitor(v, v_array5[0], v_array5[1], v_array5[2], v_array5[3]);
-    boost::apply_visitor(test_visitor(), v_array5[0], v_array5[1], v_array5[2], v_array5[3]);
+    boost::apply_visitor(v, v_array6[0], v_array6[1], v_array6[2], v_array6[3]);
+    boost::apply_visitor(test_visitor(), v_array6[0], v_array6[1], v_array6[2], v_array6[3]);
 
-    boost::apply_visitor(v, v_array5[0], v_array5[1], v_array5[2], v_array5[3], v_array5[4]);
-    boost::apply_visitor(test_visitor(), v_array5[0], v_array5[1], v_array5[2], v_array5[3], v_array5[4]);
+    boost::apply_visitor(v, v_array6[0], v_array6[1], v_array6[2], v_array6[3], v_array6[4]);
+    boost::apply_visitor(test_visitor(), v_array6[0], v_array6[1], v_array6[2], v_array6[3], v_array6[4]);
 #endif
 
     bool_like_t v0(1), v1(true), v2(1.0);
 
-    BOOST_TEST(
+    BOOST_CHECK(
         boost::apply_visitor(if_visitor(), v0, v1, v2)
         ==
         arithmetics_t(true)
     );
 
+    /* Delayed multi visitation is not implemented
     if_visitor if_vis;
-    BOOST_TEST(
+    BOOST_CHECK(
         boost::apply_visitor(if_vis)(v0, v1, v2)
         ==
         arithmetics_t(true)
     );
-
-
-    variant_noncopy_t vnonc[6];
-    boost::apply_visitor(v, vnonc[0], vnonc[1], vnonc[2]);
-    boost::apply_visitor(test_visitor(), vnonc[0], vnonc[1], vnonc[2], vnonc[3]);
-
-#ifdef BOOST_VARIANT_MULTIVISITORS_TEST_VERY_EXTREME
-    boost::apply_visitor(v, vnonc[0], vnonc[1], vnonc[2], vnonc[3], vnonc[4]);
-    boost::apply_visitor(test_visitor(), vnonc[0], vnonc[1], vnonc[2], vnonc[3], vnonc[4], vnonc[5]);
-#endif
-
-    return boost::report_errors();
+    */
+    return boost::exit_success;
 }

test/variant_nonempty_check.cpp

@@ -1,474 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost-libs variant/test/variant_nonempty_check.cpp source file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2014-2026 Antony Polukhin
-//
-// 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)
-
-
-// In this file we are making tests to ensure that variant guarantees nonemptiness.
-//
-// For that purpose we create a `throwing_class`, that throws exception at a specified
-// assignment attempt. If exception was thrown during move/assignemnt operation we make sure
-// that data in variant is same as before move/assignemnt operation or that a fallback type is
-// stored in variant.
-//
-// Different nonthrowing_class'es are used to tests different variant internal policies:
-// with/without fallback type + throw/nothrow copyable + throw/nothrow movable
-
-
-#include "boost/variant/variant.hpp"
-#include "boost/variant/get.hpp"
-#include "boost/core/lightweight_test.hpp"
-#include <stdexcept>
-
-struct exception_on_assignment : std::exception {};
-struct exception_on_move_assignment : exception_on_assignment {};
-
-void prevent_compiler_noexcept_detection() {
-    char* p = new char;
-    *p = '\0';
-    delete p;
-}
-
-
-struct throwing_class {
-    int trash;
-    enum helper_enum {
-        do_not_throw = 780,
-        throw_after_5,
-        throw_after_4,
-        throw_after_3,
-        throw_after_2,
-        throw_after_1
-    };
-
-    bool is_throw() {
-        if (trash < do_not_throw) {
-            return true;
-        }
-
-        if (trash > do_not_throw && trash <= throw_after_1) {
-            ++ trash;
-            return false;
-        }
-
-        return trash != do_not_throw;
-    }
-
-    throwing_class(int value = 123) BOOST_NOEXCEPT_IF(false) : trash(value) {
-        prevent_compiler_noexcept_detection();
-    }
-
-    throwing_class(const throwing_class& b) BOOST_NOEXCEPT_IF(false) : trash(b.trash) {
-        if (is_throw()) {
-            throw exception_on_assignment();
-        }
-    }
-
-    const throwing_class& operator=(const throwing_class& b) BOOST_NOEXCEPT_IF(false) {
-        trash = b.trash;
-        if (is_throw()) {
-            throw exception_on_assignment();
-        }
-
-        return *this;
-    }
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    throwing_class(throwing_class&& b) BOOST_NOEXCEPT_IF(false) : trash(b.trash) {
-        if (is_throw()) {
-            throw exception_on_move_assignment();
-        }
-    }
-
-    const throwing_class& operator=(throwing_class&& b) BOOST_NOEXCEPT_IF(false) {
-        trash = b.trash;
-        if (is_throw()) {
-            throw exception_on_move_assignment();
-        }
-
-        return *this;
-    }
-#endif
-
-    virtual ~throwing_class() {}
-};
-
-struct nonthrowing_class {
-    int trash;
-
-    nonthrowing_class() BOOST_NOEXCEPT_IF(false) : trash(123) {
-        prevent_compiler_noexcept_detection();
-    }
-
-    nonthrowing_class(const nonthrowing_class&) BOOST_NOEXCEPT_IF(false) {
-        prevent_compiler_noexcept_detection();
-    }
-
-    const nonthrowing_class& operator=(const nonthrowing_class&) BOOST_NOEXCEPT_IF(false) {
-        prevent_compiler_noexcept_detection();
-        return *this;
-    }
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    nonthrowing_class(nonthrowing_class&&) BOOST_NOEXCEPT_IF(false) {
-        prevent_compiler_noexcept_detection();
-    }
-
-    const nonthrowing_class& operator=(nonthrowing_class&&) BOOST_NOEXCEPT_IF(false) {
-        prevent_compiler_noexcept_detection();
-        return *this;
-    }
-#endif
-};
-
-struct nonthrowing_class2 {
-    int trash;
-
-    nonthrowing_class2() BOOST_NOEXCEPT_IF(false) : trash(123) {
-        prevent_compiler_noexcept_detection();
-    }
-};
-
-struct nonthrowing_class3 {
-    int trash;
-
-    nonthrowing_class3() BOOST_NOEXCEPT_IF(true) : trash(123) {}
-
-    nonthrowing_class3(const nonthrowing_class3&) BOOST_NOEXCEPT_IF(false) {
-        prevent_compiler_noexcept_detection();
-    }
-
-    const nonthrowing_class3& operator=(const nonthrowing_class3&) BOOST_NOEXCEPT_IF(false) {
-        prevent_compiler_noexcept_detection();
-        return *this;
-    }
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    nonthrowing_class3(nonthrowing_class3&&) BOOST_NOEXCEPT_IF(false) {
-        prevent_compiler_noexcept_detection();
-    }
-
-    const nonthrowing_class3& operator=(nonthrowing_class3&&) BOOST_NOEXCEPT_IF(false) {
-        prevent_compiler_noexcept_detection();
-        return *this;
-    }
-#endif
-};
-
-struct nonthrowing_class4 {
-    int trash;
-
-    nonthrowing_class4() BOOST_NOEXCEPT_IF(false) : trash(123) {
-        prevent_compiler_noexcept_detection();
-    }
-
-    nonthrowing_class4(const nonthrowing_class4&) BOOST_NOEXCEPT_IF(false) {
-        prevent_compiler_noexcept_detection();
-    }
-
-    const nonthrowing_class4& operator=(const nonthrowing_class4&) BOOST_NOEXCEPT_IF(false) {
-        prevent_compiler_noexcept_detection();
-        return *this;
-    }
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    nonthrowing_class4(nonthrowing_class4&&) BOOST_NOEXCEPT_IF(true) {
-    }
-
-    const nonthrowing_class4& operator=(nonthrowing_class4&&) BOOST_NOEXCEPT_IF(true) {
-        return *this;
-    }
-#endif
-};
-
-
-// Tests /////////////////////////////////////////////////////////////////////////////////////
-
-
-template <class Nonthrowing>
-inline void check_1_impl(int helper)
-{
-    boost::variant<throwing_class, Nonthrowing> v;
-    try {
-        v = throwing_class(helper);
-        BOOST_TEST(!v.which());
-        BOOST_TEST(boost::get<throwing_class>(&v));
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(!v.which());
-        BOOST_TEST(boost::get<throwing_class>(&v));
-    }
-
-    try {
-        throwing_class tc(helper);
-        v = tc;
-        BOOST_TEST(!v.which());
-        BOOST_TEST(boost::get<throwing_class>(&v));
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(!v.which());
-        BOOST_TEST(boost::get<throwing_class>(&v));
-    }
-}
-
-inline void check_1(int helper = 1)
-{
-    check_1_impl<nonthrowing_class>(helper);
-    check_1_impl<nonthrowing_class2>(helper);
-    check_1_impl<nonthrowing_class3>(helper);
-    check_1_impl<nonthrowing_class4>(helper);
-    check_1_impl<boost::blank>(helper);
-}
-
-template <class Nonthrowing>
-inline void check_2_impl(int helper)
-{
-    boost::variant<Nonthrowing, throwing_class> v;
-    try {
-        v = throwing_class(helper);
-        BOOST_TEST(v.which() == 1);
-        BOOST_TEST(boost::get<throwing_class>(&v));
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(!v.which());
-        BOOST_TEST(boost::get<Nonthrowing>(&v));
-    }
-
-    try {
-        throwing_class cl(helper);
-        v = cl;
-        BOOST_TEST(v.which() == 1);
-        BOOST_TEST(boost::get<throwing_class>(&v));
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(!v.which());
-        BOOST_TEST(boost::get<Nonthrowing>(&v));
-    }
-}
-
-inline void check_2(int helper = 1)
-{
-    check_2_impl<nonthrowing_class>(helper);
-    check_2_impl<nonthrowing_class2>(helper);
-    check_2_impl<nonthrowing_class3>(helper);
-    check_2_impl<nonthrowing_class4>(helper);
-    check_2_impl<boost::blank>(helper);
-}
-
-template <class Nonthrowing>
-inline void check_3_impl(int helper)
-{
-    boost::variant<Nonthrowing, throwing_class> v1, v2;
-
-    swap(v1, v2);
-    try {
-        v1 = throwing_class(helper);
-        BOOST_TEST(v1.which() == 1);
-        BOOST_TEST(boost::get<throwing_class>(&v1));
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(!v1.which());
-        BOOST_TEST(boost::get<Nonthrowing>(&v1));
-    }
-
-
-    try {
-        v2 = throwing_class(helper);
-        BOOST_TEST(v2.which() == 1);
-        BOOST_TEST(boost::get<throwing_class>(&v2));
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(!v2.which());
-        BOOST_TEST(boost::get<Nonthrowing>(&v2));
-    }
-
-
-    if (!v1.which() && !v2.which()) {
-        swap(v1, v2); // Make sure that two backup holders swap well
-        BOOST_TEST(!v1.which());
-        BOOST_TEST(boost::get<Nonthrowing>(&v1));
-        BOOST_TEST(!v2.which());
-        BOOST_TEST(boost::get<Nonthrowing>(&v2));
-
-        v1 = v2;
-    }
-}
-
-inline void check_3(int helper = 1)
-{
-    check_3_impl<nonthrowing_class>(helper);
-    check_3_impl<nonthrowing_class2>(helper);
-    check_3_impl<nonthrowing_class3>(helper);
-    check_3_impl<nonthrowing_class4>(helper);
-    check_3_impl<boost::blank>(helper);
-}
-
-inline void check_4(int helper = 1)
-{
-    // This one has a fallback
-    boost::variant<int, throwing_class> v1, v2;
-
-    swap(v1, v2);
-    try {
-        v1 = throwing_class(helper);
-        BOOST_TEST(v1.which() == 1);
-        BOOST_TEST(boost::get<throwing_class>(&v1));
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(!v1.which());
-        BOOST_TEST(boost::get<int>(&v1));
-    }
-
-
-    try {
-        v2 = throwing_class(helper);
-        BOOST_TEST(v2.which() == 1);
-        BOOST_TEST(boost::get<throwing_class>(&v2));
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(!v2.which());
-        BOOST_TEST(boost::get<int>(&v2));
-    }
-
-    if (!v1.which() && !v2.which()) {
-        swap(v1, v2);
-        BOOST_TEST(!v1.which());
-        BOOST_TEST(boost::get<int>(&v1));
-        BOOST_TEST(!v2.which());
-        BOOST_TEST(boost::get<int>(&v2));
-
-        v1 = v2;
-    }
-}
-
-template <class Nonthrowing>
-inline void check_5_impl(int helper)
-{
-    boost::variant<Nonthrowing, throwing_class> v1, v2;
-    throwing_class throw_not_now;
-    throw_not_now.trash = throwing_class::do_not_throw;
-    v1 = throw_not_now;
-    v2 = throw_not_now;
-
-    boost::get<throwing_class>(v1).trash = 1;
-    boost::get<throwing_class>(v2).trash = 1;
-
-    try {
-        v1 = throwing_class(helper);
-        BOOST_TEST(v1.which() == 1);
-        BOOST_TEST(boost::get<throwing_class>(&v1));
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(v1.which() == 1);
-        BOOST_TEST(boost::get<throwing_class>(&v1));
-    }
-
-    boost::get<throwing_class>(v1).trash = throwing_class::do_not_throw;
-    boost::get<throwing_class>(v2).trash = throwing_class::do_not_throw;
-    v1 = Nonthrowing();
-    v2 = Nonthrowing();
-    try {
-        v1 = throwing_class(helper);
-        BOOST_TEST(v1.which() == 1);
-        BOOST_TEST(boost::get<throwing_class>(&v1));
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(v1.which() == 0);
-        BOOST_TEST(boost::get<Nonthrowing>(&v1));
-    }
-
-    int v1_type = v1.which();
-    int v2_type = v2.which();
-    try {
-        swap(v1, v2); // Make sure that backup holders swap well
-        BOOST_TEST(v1.which() == v2_type);
-        BOOST_TEST(v2.which() == v1_type);
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(v1.which() == v1_type);
-        BOOST_TEST(v2.which() == v2_type);
-    }
-}
-
-
-inline void check_5(int helper = 1)
-{
-    check_5_impl<nonthrowing_class>(helper);
-    check_5_impl<nonthrowing_class2>(helper);
-    check_5_impl<nonthrowing_class3>(helper);
-    check_5_impl<nonthrowing_class4>(helper);
-    check_5_impl<boost::blank>(helper);
-}
-
-template <class Nonthrowing>
-inline void check_6_impl(int helper)
-{
-    boost::variant<Nonthrowing, throwing_class> v1, v2;
-    throwing_class throw_not_now;
-    throw_not_now.trash = throwing_class::do_not_throw;
-    v1 = throw_not_now;
-    v2 = throw_not_now;
-
-    v1 = throw_not_now;
-    v2 = throw_not_now;
-    swap(v1, v2);
-    boost::get<throwing_class>(v1).trash = 1;
-    boost::get<throwing_class>(v2).trash = 1;
-
-    v1 = throwing_class(throw_not_now);
-    v2 = v1;
-
-    v1 = Nonthrowing();
-    try {
-        throwing_class tc;
-        tc.trash = helper;
-        v1 = tc;
-        BOOST_TEST(v1.which() == 1);
-        BOOST_TEST(boost::get<throwing_class>(&v1));
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(v1.which() == 0);
-    }
-
-    v2 = Nonthrowing();
-    try {
-        v2 = 2;
-        BOOST_TEST(false);
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(v2.which() == 0);
-    }
-
-    // Probably the most significant test:
-    // unsuccessful swap must preserve old values of variant
-    v1 = throw_not_now;
-    boost::get<throwing_class>(v1).trash = helper;
-    try {
-        swap(v1, v2);
-    } catch (const exception_on_assignment& /*e*/) {
-        BOOST_TEST(v1.which() == 1);
-        BOOST_TEST(v2.which() == 0);
-        BOOST_TEST(boost::get<throwing_class>(v1).trash == helper);
-    }
-}
-
-
-inline void check_6(int helper = 1)
-{
-    check_6_impl<nonthrowing_class>(helper);
-    check_6_impl<nonthrowing_class2>(helper);
-    check_6_impl<nonthrowing_class3>(helper);
-    check_6_impl<nonthrowing_class4>(helper);
-    check_6_impl<boost::blank>(helper);
-}
-
-int main()
-{
-    // throwing_class::throw_after_1 + 1  => throw on first assignment/construction
-    // throwing_class::throw_after_1  => throw on second assignment/construction
-    // throwing_class::throw_after_2  => throw on third assignment/construction
-    // ...
-    for (int i = throwing_class::throw_after_1 + 1; i != throwing_class::do_not_throw; --i) {
-        check_1(i);
-        check_2(i);
-        check_3(i);
-        check_4(i);
-        check_5(i);
-        check_6(i);
-    }
-
-    return boost::report_errors();
-}

test/variant_over_joint_view_test.cpp

@@ -1,64 +0,0 @@
-// Copyright (c) 2017
-// Mikhail Maximov
-//
-// 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)
-
-// The test is base on https://svn.boost.org/trac/boost/ticket/8554 
-// variant was not able to extract types from mpl::joint_view
-
-#include <string>
-
-#include "boost/config.hpp"
-#include "boost/core/lightweight_test.hpp"
-
-#include "boost/variant.hpp"
-#include "boost/mpl/joint_view.hpp"
-#include "boost/mpl/insert_range.hpp"
-#include "boost/mpl/set.hpp"
-
-template<class T, class Variant>
-void check_exception_on_get(Variant& v) {
-    try {
-        boost::get<T>(v);
-        BOOST_ERROR("Expected exception boost::bad_get, but got nothing.");
-    } catch (boost::bad_get&) { //okay it is expected behaviour
-    } catch (...) { BOOST_ERROR("Expected exception boost::bad_get, but got something else."); }
-}
-
-void test_joint_view() {
-    typedef boost::variant<int> v1;
-    typedef boost::variant<std::string> v2;
-    typedef boost::make_variant_over<boost::mpl::joint_view<v1::types, v2::types>::type>::type v3;
-
-    v1 a = 1;
-    v2 b = "2";
-    v3 c = a;
-    BOOST_TEST(boost::get<int>(c) == 1);
-    BOOST_TEST(c.which() == 0);
-    v3 d = b;
-    BOOST_TEST(boost::get<std::string>(d) == "2");
-    BOOST_TEST(d.which() == 1);
-    check_exception_on_get<std::string>(c);
-    check_exception_on_get<int>(d);
-}
-
-void test_set() {
-    typedef boost::mpl::set2< std::string, int > types;
-    typedef boost::make_variant_over< types >::type v;
-
-    v a = 1;
-    BOOST_TEST(boost::get<int>(a) == 1);
-    check_exception_on_get<std::string>(a);
-    a = "2";
-    BOOST_TEST(boost::get<std::string>(a) == "2");
-    check_exception_on_get<int>(a);
-}
-
-int main()
-{
-    test_joint_view();
-    test_set();
-    return boost::report_errors();
-}