From 755bc60c2be8d65b61a3170fb8c28e950574f95f Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Wed, 31 May 2017 04:19:40 +0300
Subject: [PATCH] Add initializer list support

---
 include/boost/variant2/variant.hpp        | 22 +++++++++++++++++-----
 test/variant_emplace_index.cpp            |  8 ++++++++
 test/variant_emplace_type.cpp             |  8 ++++++++
 test/variant_in_place_index_construct.cpp | 18 ++++++++++++++++--
 test/variant_in_place_type_construct.cpp  | 18 ++++++++++++++++++
 5 files changed, 67 insertions(+), 7 deletions(-)

diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index 0155de9..c2f23a4 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -749,8 +749,10 @@ public:
     {
     }
 
-    template<class U, class V, class... A>
-    constexpr explicit variant( in_place_type_t<U>, std::initializer_list<V>, A&&... a );
+    template<class U, class V, class... A, class I = mp_find<variant<T...>, U>>
+    constexpr explicit variant( in_place_type_t<U>, std::initializer_list<V> il, A&&... a ): variant_base( I(), il, std::forward<A>(a)... )
+    {
+    }
 
     template<std::size_t I, class... A>
     constexpr explicit variant( in_place_index_t<I>, A&&... a ): variant_base( mp_size_t<I>(), std::forward<A>(a)... )
@@ -758,7 +760,9 @@ public:
     }
 
     template<std::size_t I, class V, class... A>
-    constexpr explicit variant( in_place_index_t<I>, std::initializer_list<V>, A&&... );
+    constexpr explicit variant( in_place_index_t<I>, std::initializer_list<V> il, A&&... a ): variant_base( mp_size_t<I>(), il, std::forward<A>(a)... )
+    {
+    }
 
     // assignment
     variant& operator=( variant const & r )
@@ -836,7 +840,11 @@ public:
         return _get_impl( I() );
     }
 
-    template<class U, class V, class... A> U& emplace( std::initializer_list<V> il, A&&... a );
+    template<class U, class V, class... A, class I = mp_find<variant<T...>, U>> U& emplace( std::initializer_list<V> il, A&&... a )
+    {
+        variant_base::template emplace<I::value>( il, std::forward<A>(a)... );
+        return _get_impl( I() );
+    }
 
     template<std::size_t I, class... A> variant_alternative_t<I, variant<T...>>& emplace( A&&... a )
     {
@@ -844,7 +852,11 @@ public:
         return _get_impl( mp_size_t<I>() );
     }
 
-    template<std::size_t I, class V, class... A> variant_alternative_t<I, variant<T...>>& emplace( std::initializer_list<V> il, A&&... a );
+    template<std::size_t I, class V, class... A> variant_alternative_t<I, variant<T...>>& emplace( std::initializer_list<V> il, A&&... a )
+    {
+        variant_base::template emplace<I>( il, std::forward<A>(a)... );
+        return _get_impl( mp_size_t<I>() );
+    }
 
     // value status
 
diff --git a/test/variant_emplace_index.cpp b/test/variant_emplace_index.cpp
index c8dc55e..7fa30b7 100644
--- a/test/variant_emplace_index.cpp
+++ b/test/variant_emplace_index.cpp
@@ -128,6 +128,14 @@ int main()
         v.emplace<3>();
         BOOST_TEST_EQ( v.index(), 3 );
         BOOST_TEST_EQ( get<3>(v), std::string() );
+
+        v.emplace<3>( { 'a', 'b' } );
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), (std::string{ 'a', 'b'}) );
+
+        v.emplace<3>( { 'c', 'd' }, std::allocator<char>() );
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), (std::string{ 'c', 'd'}) );
     }
 
     {
diff --git a/test/variant_emplace_type.cpp b/test/variant_emplace_type.cpp
index 37b3eff..4189bbb 100644
--- a/test/variant_emplace_type.cpp
+++ b/test/variant_emplace_type.cpp
@@ -116,6 +116,14 @@ int main()
         v.emplace<std::string>();
         BOOST_TEST_EQ( v.index(), 3 );
         BOOST_TEST_EQ( get<3>(v), std::string() );
+
+        v.emplace<std::string>( { 'a', 'b' } );
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), (std::string{ 'a', 'b' }) );
+
+        v.emplace<std::string>( { 'c', 'd' }, std::allocator<char>() );
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), (std::string{ 'c', 'd' }) );
     }
 
     {
diff --git a/test/variant_in_place_index_construct.cpp b/test/variant_in_place_index_construct.cpp
index 8f6c58f..4e87b3f 100644
--- a/test/variant_in_place_index_construct.cpp
+++ b/test/variant_in_place_index_construct.cpp
@@ -17,8 +17,8 @@ using namespace boost::variant2;
 
 struct X
 {
-	X() = default;
-	X( in_place_index_t<0> ) = delete;
+    X() = default;
+    X( in_place_index_t<0> ) = delete;
 };
 
 int main()
@@ -120,5 +120,19 @@ int main()
         BOOST_TEST_EQ( get<5>(v), std::string( 4, 'a' ) );
     }
 
+    {
+        variant<int, int, float, float, std::string, std::string> v( in_place_index<4>, { 'a', 'b', 'c' } );
+
+        BOOST_TEST_EQ( v.index(), 4 );
+        BOOST_TEST_EQ( get<4>(v), (std::string{ 'a', 'b', 'c' }) );
+    }
+
+    {
+        variant<int, int, float, float, std::string, std::string> v( in_place_index<5>, { 'a', 'b', 'c' }, std::allocator<char>() );
+
+        BOOST_TEST_EQ( v.index(), 5 );
+        BOOST_TEST_EQ( get<5>(v), (std::string{ 'a', 'b', 'c' }) );
+    }
+
     return boost::report_errors();
 }
diff --git a/test/variant_in_place_type_construct.cpp b/test/variant_in_place_type_construct.cpp
index 7a04cae..dc956eb 100644
--- a/test/variant_in_place_type_construct.cpp
+++ b/test/variant_in_place_type_construct.cpp
@@ -112,5 +112,23 @@ int main()
         BOOST_TEST( holds_alternative<std::string>(v) );
     }
 
+    {
+        variant<int, int, float, float, std::string> v( in_place_type<std::string>, { 'a', 'b', 'c' } );
+
+        BOOST_TEST_EQ( v.index(), 4 );
+        BOOST_TEST_EQ( get<4>(v), (std::string{ 'a', 'b', 'c' }) );
+
+        BOOST_TEST( holds_alternative<std::string>(v) );
+    }
+
+    {
+        variant<int, int, float, float, std::string> v( in_place_type<std::string>, { 'a', 'b', 'c' }, std::allocator<char>() );
+
+        BOOST_TEST_EQ( v.index(), 4 );
+        BOOST_TEST_EQ( get<4>(v), (std::string{ 'a', 'b', 'c' }) );
+
+        BOOST_TEST( holds_alternative<std::string>(v) );
+    }
+
     return boost::report_errors();
 }