Provides forward declarations of the ``boost::variant``, ``boost::make_variant_over``, ``boost::make_recursive_variant``, and ``boost::make_recursive_variant_over`` class templates and the `boost::recursive_variant_` tag type. Also defines several preprocessor symbols, as described below.

Expands to the length of the template parameter list for ``variant``. Not used if `BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES` is not defined.

Note: Conforming implementations of `variant` must allow at least ten template arguments. That is, BOOST_VARIANT_LIMIT_TYPES must be greater or equal to `10`.

If this macro is defined, then library won't use C++11 variadic templates. Users may define this macro to make `BOOST_VARIANT_ENUM_PARAMS` and `BOOST_VARIANT_ENUM_SHIFTED_PARAMS` expand to a comma-separated sequence instead of variadic templates. Define this macro if your compiler has problems with compilation of variadic templates.

Enumerate parameters for use with ``variant``.

When variadic templates are available and `BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES` is not defined, expands to variadic template list in the following manner: ``

                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...

Otherwise expands to a comma-separated sequence of length `BOOST_VARIANT_LIMIT_TYPES`, where each element in the sequence consists of the concatenation of param with its zero-based index into the sequence. That is, `param ## 0, param ## 1, ..., param ## BOOST_VARIANT_LIMIT_TYPES - 1`.

Rationale: This macro greatly simplifies for the user the process of declaring ``variant`` types in function templates or explicit partial specializations of class templates, as shown in the tutorial.

Enumerate all but the first parameter for use with ``variant``.

When variadic templates are available and `BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES` is not defined, expands to variadic template list in the following manner: ``

                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...

Otherwise expands to a comma-separated sequence of length `BOOST_VARIANT_LIMIT_TYPES - 1`, where each element in the sequence consists of the concatenation of param with its one-based index into the sequence. That is, `param ## 1, ..., param ## BOOST_VARIANT_LIMIT_TYPES - 1`.

Note: This macro results in the same expansion as `BOOST_VARIANT_ENUM_PARAMS` -- but without the first term.

Indicates ``variant`` does not support references as bounded types.

Defined only if ``variant`` does not support references as bounded types.

Indicates absence of support for specifying the bounded types of a ``variant`` by the elements of a type sequence.

Defined only if ``make_variant_over`` and ``make_recursive_variant_over`` are not supported for some reason on the target compiler.

Indicates ``make_recursive_variant`` operates in an implementation-defined manner.

Defined only if ``make_recursive_variant`` does not operate as documented on the target compiler, but rather in an implementation-defined manner.

Implementation Note: If `BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT` is defined for the target compiler, the current implementation uses the MPL lambda mechanism to approximate the desired behavior. (In most cases, however, such compilers do not have full lambda support either.)