VctrBase: Added toStdMap member function

Author: JanosGit

include/vctr/Containers/VctrBase.h

@@ -931,6 +931,23 @@ class VctrBase : private Config,
     /** Returns true if any real or imaginary part of an element is NaN. */
     constexpr bool anyElementIsNaN() requires is::complexFloatNumber<ElementType>;
 
+    //==============================================================================
+    // Conversion operators
+    //==============================================================================
+    /** If value_type is std::pair, this converts the content into a std::map with pair::first_type being the key and pair::second_type the value. */
+    constexpr auto toStdMap() &&
+    requires is::stdPair<value_type> && (! is::view<StorageType>)
+    {
+        return std::map<typename value_type::first_type, typename value_type::second_type> { std::make_move_iterator (begin()), std::make_move_iterator (end()) };
+    }
+
+    /** If value_type is std::pair, this converts the content into a std::map with pair::first_type being the key and pair::second_type the value. */
+    constexpr auto toStdMap() const &
+    requires is::stdPair<value_type>
+    {
+        return std::map<typename value_type::first_type, typename value_type::second_type> { begin(), end() };
+    }
+
 protected:
     //==============================================================================
     constexpr VctrBase()

include/vctr/TypeTraitsAndConcepts/GenericConcepts.h

@@ -66,12 +66,6 @@ struct IsStdUniquePtr : std::false_type {};
 
 template <class T, class D>
 struct IsStdUniquePtr<std::unique_ptr<T, D>> : std::true_type {};
-
-template <class T>
-struct IsStdTuple : std::false_type {};
-
-template <class... T>
-struct IsStdTuple<std::tuple<T...>> : std::true_type {};
 // clang-format on
 
 } // namespace vctr::detail
@@ -103,9 +97,13 @@ concept uniquePtr = detail::IsStdUniquePtr<T>::value;
 template <class T>
 concept lvalueReference = std::is_lvalue_reference_v<T>;
 
+/** Constrains the type to be any instance of std::pair */
+template <class T>
+concept stdPair = requires (T& t) { [] <class A, class B> (std::pair<A, B>&) {} (t); };
+
 /** Constrains the type to be any instance of std::tuple */
 template <class T>
-concept stdTuple = detail::IsStdTuple<T>::value;
+concept stdTuple = requires (T& t) { [] <class... Ts> (std::tuple<Ts...>&) {} (t); };
 
 template <class T, class... TupleTypes>
 concept stdTupleWithTypes = std::same_as<T, std::tuple<TupleTypes...>>;

include/vctr/vctr.h

@@ -46,6 +46,7 @@
 #include <vector>
 #include <array>
 #include <span>
+#include <map>
 #include <concepts>
 #include <cmath>
 #include <ostream>

test/TestCases/VctrBaseMemberFunctions.cpp

@@ -494,6 +494,41 @@ TEMPLATE_TEST_CASE ("anyElementIsNaN", "[VCTR][VctrBaseMemberFunctions]", float,
     REQUIRE (cplx.anyElementIsNaN());
 }
 
+TEST_CASE ("toStdMap", "[VCTR][VctrBaseMemberFunctions]")
+{
+    vctr::Vector<std::pair<int, std::string>> pairs { { 1, "one" }, { 2, "two" }, { 3, "three_appended_with_a_long_string_to_avoid_small_string_optimization" } };
+    auto pairsSub = pairs.subSpan<1>();
+
+    // Deliberately moving here to check if moving a view results in leaving the source intact
+    auto subMap = std::move (pairsSub).toStdMap();
+
+    // Check if the generated map is correct
+    REQUIRE_FALSE (subMap.contains (1));
+    REQUIRE (subMap.contains (2));
+    REQUIRE (subMap.contains (3));
+    REQUIRE (subMap[2] == "two");
+    REQUIRE (subMap[3] == "three_appended_with_a_long_string_to_avoid_small_string_optimization");
+    REQUIRE (subMap.size() == 2);
+
+    // Check if the original values stayed valid. There is no guarantee that a string is empty after
+    // moving but it's likely that this is at least the case after moving a long string, so this test
+    // tries to catch that kind of mistake
+    const auto& [key, value] = pairs.back();
+    REQUIRE (key == 3);
+    REQUIRE (value == "three_appended_with_a_long_string_to_avoid_small_string_optimization");
+
+    // This time we expect the move iterator to be used
+    auto map = std::move (pairs).toStdMap();
+
+    REQUIRE (map.contains (1));
+    REQUIRE (map.contains (2));
+    REQUIRE (map.contains (3));
+    REQUIRE (map[1] == "one");
+    REQUIRE (map[2] == "two");
+    REQUIRE (map[3] == "three_appended_with_a_long_string_to_avoid_small_string_optimization");
+    REQUIRE (map.size() == 3);
+}
+
 TEMPLATE_TEST_CASE ("operator==", "[VCTR][VctrBaseFreeFunctions]", float, uint64_t, std::string)
 {
     auto a = UnitTestValues<TestType>::template array<100, 0>();