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 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. Define this macro if you do not wish to have a std::hash specialization for boost::variant. 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.)