Relax holds_alternative constraint to permit duplicate alternatives. Refs #33.

Author: pdimov

include/boost/variant2/variant.hpp

@@ -324,12 +324,41 @@ constexpr std::size_t variant_npos = ~static_cast<std::size_t>( 0 );
 
 // holds_alternative
 
+#if !defined(BOOST_MP11_HAS_CXX14_CONSTEXPR)
+
 template<class U, class... T> constexpr bool holds_alternative( variant<T...> const& v ) noexcept
 {
-    static_assert( mp11::mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );
-    return v.index() == mp11::mp_find<variant<T...>, U>::value;
+    static_assert( mp11::mp_contains<variant<T...>, U>::value, "The type must be present in the list of variant alternatives" );
+
+    using A = bool[];
+    return A{ std::is_same<U, T>::value... }[ v.index() ];
+}
+
+#else
+
+namespace detail
+{
+
+template<class U, class V> struct holds_alternative_L
+{
+    template<class I> constexpr bool operator()( I ) const noexcept
+    {
+        return std::is_same< U, mp11::mp_at<V, I> >::value;
+    }
+};
+
+} // namespace detail
+
+template<class U, class... T> constexpr bool holds_alternative( variant<T...> const& v ) noexcept
+{
+    using V = variant<T...>;
+    static_assert( mp11::mp_contains<V, U>::value, "The type must be present in the list of variant alternatives" );
+
+    return mp11::mp_with_index<sizeof...(T)>( v.index(), detail::holds_alternative_L<U, V>() );
 }
 
+#endif
+
 // get (index)
 
 template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>>& get(variant<T...>& v)

test/variant_holds_alternative.cpp

@@ -1,10 +1,6 @@
-
-// Copyright 2017 Peter Dimov.
-//
+// Copyright 2017, 2026 Peter Dimov.
 // 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
+// https://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/variant2/variant.hpp>
 #include <boost/core/lightweight_test.hpp>
@@ -34,13 +30,27 @@ int main()
     {
         variant<int, float, float> v;
         BOOST_TEST( holds_alternative<int>( v ) );
+        BOOST_TEST( !holds_alternative<float>( v ) );
     }
 
     {
         variant<int, int, float> v( 3.14f );
+        BOOST_TEST( !holds_alternative<int>( v ) );
         BOOST_TEST( holds_alternative<float>( v ) );
     }
 
+    {
+        variant<int, int, float> v( in_place_index_t<0>{} );
+        BOOST_TEST( holds_alternative<int>( v ) );
+        BOOST_TEST( !holds_alternative<float>( v ) );
+    }
+
+    {
+        variant<int, int, float> v( in_place_index_t<1>{} );
+        BOOST_TEST( holds_alternative<int>( v ) );
+        BOOST_TEST( !holds_alternative<float>( v ) );
+    }
+
     {
         variant<int, float, std::string> v;
         BOOST_TEST( holds_alternative<int>( v ) );
@@ -64,15 +74,31 @@ int main()
 
     {
         variant<int, int, float, std::string> v( 3.14f );
+        BOOST_TEST( !holds_alternative<int>( v ) );
         BOOST_TEST( holds_alternative<float>( v ) );
         BOOST_TEST( !holds_alternative<std::string>( v ) );
     }
 
     {
         variant<int, int, float, std::string> v( "text" );
+        BOOST_TEST( !holds_alternative<int>( v ) );
         BOOST_TEST( !holds_alternative<float>( v ) );
         BOOST_TEST( holds_alternative<std::string>( v ) );
     }
 
+    {
+        variant<int, int, float, std::string> v( in_place_index_t<0>{} );
+        BOOST_TEST( holds_alternative<int>( v ) );
+        BOOST_TEST( !holds_alternative<float>( v ) );
+        BOOST_TEST( !holds_alternative<std::string>( v ) );
+    }
+
+    {
+        variant<int, int, float, std::string> v( in_place_index_t<1>{} );
+        BOOST_TEST( holds_alternative<int>( v ) );
+        BOOST_TEST( !holds_alternative<float>( v ) );
+        BOOST_TEST( !holds_alternative<std::string>( v ) );
+    }
+
     return boost::report_errors();
 }

test/variant_holds_alternative_cx.cpp

@@ -39,12 +39,20 @@ int main()
     {
         constexpr variant<int, float, float> v;
         STATIC_ASSERT( holds_alternative<int>( v ) );
+        STATIC_ASSERT( !holds_alternative<float>( v ) );
     }
 
     {
         constexpr variant<int, int, float> v( 3.14f );
+        STATIC_ASSERT( !holds_alternative<int>( v ) );
         STATIC_ASSERT( holds_alternative<float>( v ) );
     }
+
+    {
+        constexpr variant<int, int, float> v;
+        STATIC_ASSERT( holds_alternative<int>( v ) );
+        STATIC_ASSERT( !holds_alternative<float>( v ) );
+    }
 }
 
 #endif