Use granular mp11 includes

.github/workflows/ci.yml

@@ -147,10 +147,6 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - toolset: msvc-14.0
-            cxxstd: "14"
-            addrmd: 32,64
-            os: windows-2019
           - toolset: msvc-14.1
             cxxstd: "14,17,latest"
             addrmd: 32,64
@@ -159,10 +155,6 @@ jobs:
             cxxstd: "14,17,latest"
             addrmd: 32,64
             os: windows-2019
-          - toolset: msvc-14.3
-            cxxstd: "14,17,latest"
-            addrmd: 32,64
-            os: windows-2022
           - toolset: gcc
             cxxstd: "03,11,14,17,2a"
             addrmd: 64

doc/variant2.adoc

@@ -13,8 +13,6 @@ Peter Dimov
 :toclevels: 4
 :idprefix:
 :docinfo: private-footer
-:source-highlighter: rouge
-:source-language: c++
 
 :leveloffset: +1
 

include/boost/variant2/variant.hpp

@@ -13,7 +13,10 @@
 # pragma warning( disable: 4521 4522 ) // multiple copy operators
 #endif
 
-#include <boost/mp11.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/function.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
@@ -842,14 +845,14 @@ struct none {};
 // trivially destructible, single buffered
 template<class... T> struct variant_base_impl<true, true, T...>
 {
-    variant_storage<none, T...> st_;
     unsigned ix_;
+    variant_storage<none, T...> st_;
 
-    constexpr variant_base_impl(): st_( mp11::mp_size_t<0>() ), ix_( 0 )
+    constexpr variant_base_impl(): ix_( 0 ), st_( mp11::mp_size_t<0>() )
     {
     }
 
-    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): st_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... ), ix_( I::value + 1 )
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( I::value + 1 ), st_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... )
     {
     }
 
@@ -913,14 +916,14 @@ template<class... T> struct variant_base_impl<true, true, T...>
 // trivially destructible, double buffered
 template<class... T> struct variant_base_impl<true, false, T...>
 {
-    variant_storage<none, T...> st_[ 2 ];
     unsigned ix_;
+    variant_storage<none, T...> st_[ 2 ];
 
-    constexpr variant_base_impl(): st_{ { mp11::mp_size_t<0>() }, { mp11::mp_size_t<0>() } }, ix_( 0 )
+    constexpr variant_base_impl(): ix_( 0 ), st_{ { mp11::mp_size_t<0>() }, { mp11::mp_size_t<0>() } }
     {
     }
 
-    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): st_{ { mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... }, { mp11::mp_size_t<0>() } }, ix_( ( I::value + 1 ) * 2 )
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( ( I::value + 1 ) * 2 ), st_{ { mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... }, { mp11::mp_size_t<0>() } }
     {
     }
 
@@ -971,14 +974,14 @@ template<class... T> struct variant_base_impl<true, false, T...>
 // not trivially destructible, single buffered
 template<class... T> struct variant_base_impl<false, true, T...>
 {
-    variant_storage<none, T...> st_;
     unsigned ix_;
+    variant_storage<none, T...> st_;
 
-    constexpr variant_base_impl(): st_( mp11::mp_size_t<0>() ), ix_( 0 )
+    constexpr variant_base_impl(): ix_( 0 ), st_( mp11::mp_size_t<0>() )
     {
     }
 
-    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): st_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... ), ix_( I::value + 1 )
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( I::value + 1 ), st_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... )
     {
     }
 
@@ -1061,18 +1064,19 @@ template<class... T> struct variant_base_impl<false, true, T...>
 // not trivially destructible, double buffered
 template<class... T> struct variant_base_impl<false, false, T...>
 {
+    unsigned ix_;
+
 #if defined(__GNUC__) && __GNUC__ < 11 && !defined(__clang__) && !defined(__INTEL_COMPILER)
 
     // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63707 :-(
 
     variant_storage<none, T...> st1_, st2_;
-    unsigned ix_;
 
-    constexpr variant_base_impl(): st1_( mp11::mp_size_t<0>() ), st2_( mp11::mp_size_t<0>() ), ix_( 0 )
+    constexpr variant_base_impl(): ix_( 0 ), st1_( mp11::mp_size_t<0>() ), st2_( mp11::mp_size_t<0>() )
     {
     }
 
-    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): st1_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... ), st2_( mp11::mp_size_t<0>() ), ix_( ( I::value + 1 ) * 2 )
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( ( I::value + 1 ) * 2 ), st1_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... ), st2_( mp11::mp_size_t<0>() )
     {
     }
 
@@ -1089,13 +1093,12 @@ template<class... T> struct variant_base_impl<false, false, T...>
 #else
 
     variant_storage<none, T...> st_[ 2 ];
-    unsigned ix_;
 
-    constexpr variant_base_impl(): st_{ { mp11::mp_size_t<0>() }, { mp11::mp_size_t<0>() } }, ix_( 0 )
+    constexpr variant_base_impl(): ix_( 0 ), st_{ { mp11::mp_size_t<0>() }, { mp11::mp_size_t<0>() } }
     {
     }
 
-    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): st_{ { mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... }, { mp11::mp_size_t<0>() } }, ix_( ( I::value + 1 ) * 2 )
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( ( I::value + 1 ) * 2 ), st_{ { mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... }, { mp11::mp_size_t<0>() } }
     {
     }
 
@@ -2253,19 +2256,9 @@ template<class Ch, class Tr, class... T> struct ostream_insert_L
     }
 };
 
-template<class Os, class T, class E = void> struct is_output_streamable: std::false_type
-{
-};
-
-template<class Os, class T> struct is_output_streamable<Os, T, decltype( std::declval<Os&>() << std::declval<T const&>(), (void)0 )>: std::true_type
-{
-};
-
 } // namespace detail
 
-template<class Ch, class Tr, class T1, class... T,
-    class E = typename std::enable_if< mp11::mp_all< detail::is_output_streamable<std::basic_ostream<Ch, Tr>, T>... >::value >::type >
-std::basic_ostream<Ch, Tr>& operator<<( std::basic_ostream<Ch, Tr>& os, variant<T1, T...> const& v )
+template<class Ch, class Tr, class T1, class... T> std::basic_ostream<Ch, Tr>& operator<<( std::basic_ostream<Ch, Tr>& os, variant<T1, T...> const& v )
 {
     return mp11::mp_with_index<1 + sizeof...(T)>( v.index(),
         detail::ostream_insert_L<Ch, Tr, T1, T...>{ os, v } );

test/Jamfile

@@ -125,4 +125,3 @@ compile variant_derived_construct.cpp ;
 run variant_visit_by_index.cpp ;
 
 run variant_ostream_insert.cpp ;
-run is_output_streamable.cpp ;

test/is_output_streamable.cpp

@@ -1,38 +0,0 @@
-// Copyright 2021 Peter Dimov
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/variant2/variant.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-#include <ostream>
-#include <string>
-
-struct X
-{
-};
-
-struct Y
-{
-};
-
-std::ostream& operator<<( std::ostream& os, Y const& /*y*/ )
-{
-    os << "Y()";
-    return os;
-}
-
-int main()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::variant2::detail::is_output_streamable<std::ostream, int>));
-    BOOST_TEST_TRAIT_TRUE((boost::variant2::detail::is_output_streamable<std::ostream, float>));
-    BOOST_TEST_TRAIT_TRUE((boost::variant2::detail::is_output_streamable<std::ostream, std::string>));
-    BOOST_TEST_TRAIT_FALSE((boost::variant2::detail::is_output_streamable<std::ostream, void>));
-    BOOST_TEST_TRAIT_FALSE((boost::variant2::detail::is_output_streamable<std::ostream, X>));
-    BOOST_TEST_TRAIT_TRUE((boost::variant2::detail::is_output_streamable<std::ostream, Y>));
-
-    BOOST_TEST_TRAIT_TRUE((boost::variant2::detail::is_output_streamable<std::ostream, boost::variant2::variant<int, float, std::string>>));
-    BOOST_TEST_TRAIT_FALSE((boost::variant2::detail::is_output_streamable<std::ostream, boost::variant2::variant<int, float, X>>));
-    BOOST_TEST_TRAIT_TRUE((boost::variant2::detail::is_output_streamable<std::ostream, boost::variant2::variant<int, float, Y>>));
-
-    return boost::report_errors();
-}

test/variant_visit_derived.cpp

@@ -1,3 +1,4 @@
+
 // Copyright 2017, 2020 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
@@ -14,7 +15,7 @@
 
 struct X: boost::variant2::variant<int, float>
 {
-#if BOOST_WORKAROUND( BOOST_MSVC, < 1940 )
+#if BOOST_WORKAROUND( BOOST_MSVC, < 1930 )
 
     template<class T> explicit X( T&& t ): variant( std::forward<T>( t ) ) {};