added transparent comparator to pmtv::map_t == std::map<std::string, …

…pmt, std::less<>>

Signed-off-by: Ralph J. Steinhagen <r.steinhagen@gsi.de>

bench/bm_pmt_dict_pack_unpack.cpp

@@ -16,7 +16,7 @@ bool run_test(const int32_t times, int32_t nitems)
     bool valid = true;
     for (int32_t i = 0; i < times; i++) {
         // Create the dictionary
-        std::map<std::string, pmt> starting_map;
+        pmtv::map_t starting_map;
 
 #if 1
         for (int32_t k = 0; k < nitems; k++) {

bench/bm_pmt_dict_ref.cpp

@@ -50,7 +50,7 @@ int main(int argc, char* argv[])
 
     {
         // Create the dictionary
-        std::map<std::string, pmt> starting_map;
+        pmtv::map_t starting_map;
         for (int32_t k = 0; k < items; k++) {
             // auto key = std::string("key" + std::to_string(k));
             // auto value = scalar(k);

include/pmtv/pmt.hpp

@@ -29,7 +29,7 @@
 namespace pmtv {
 
 using pmt = pmt_var_t;
-using map_t = std::map<std::string, pmt>;
+using map_t = std::map<std::string, pmt, std::less<>>;
 
 template <class T>
 inline constexpr std::in_place_type_t<std::vector<T>> vec_t{};
@@ -197,7 +197,7 @@ constexpr uint8_t pmtTypeIndex()
         return 5;
     else if constexpr (std::same_as<T, std::string>)
         return 6;
-    else if constexpr (std::same_as<T, std::map<std::string, pmt>>)
+    else if constexpr (std::same_as<T, std::map<std::string, pmt, std::less<>>>)
         return 7;
     else if constexpr (std::same_as<T, std::vector<std::string>>)
         return 8;
@@ -540,7 +540,7 @@ T cast(const P& value)
                 }
             }
             // else if constexpr (PmtMap<T> && PmtMap<U>) {
-            //     return std::get<std::map<std::string, pmt_var_t>>(arg);
+            //     return std::get<std::map<std::string, pmt_var_t, std::less<>>>(arg);
             // }
             else
                 throw std::runtime_error(fmt::format(

include/pmtv/type_helpers.hpp

@@ -23,7 +23,7 @@ struct as_pmt {
                              std::string,
                              std::vector<std::string>,
                              std::vector<rva::self_t>,
-                             std::map<std::string, rva::self_t>
+                             std::map<std::string, rva::self_t, std::less<>>
                              >;
 };
 
@@ -85,7 +85,7 @@ concept UniformStringVector =
     std::ranges::range<T> && std::same_as<typename T::value_type, std::string>;
 
 template <typename T>
-concept PmtMap = std::is_same_v<T, std::map<std::string, pmt_var_t>>;
+concept PmtMap = std::is_same_v<T, std::map<std::string, pmt_var_t, std::less<>>>;
 
 template <typename T>
 concept String = std::is_same_v<T, std::string>;

python/pmtv/bindings/pmt_python.cc

@@ -203,7 +203,7 @@ void bind_pmt(py::module& m)
         //     return pmtv::pmt(); }), py::arg{}.noconvert())
         // Map constructor
         .def(py::init(
-            [](const std::map<std::string, pmtv::pmt>& mm) { return pmtv::pmt(mm); }))
+            [](const pmtv::map_t& mm) { return pmtv::pmt(mm); }))
 
         // Fallback for types not directly mapped to pybind types
         // For supporting e.g. numpy.float32 scalar

test/qa_map.cpp

@@ -7,6 +7,8 @@
  */
 #include <gtest/gtest.h>
 #include <complex>
+#include <string>
+#include <string_view>
 
 #include <pmtv/pmt.hpp>
 
@@ -18,6 +20,23 @@ TEST(PmtMap, EmptyMap)
     auto v = get_map(empty);
     v["abc"] = pmt(uint64_t(4));
     v["xyz"] = pmt(std::vector<double>{ 1, 2, 3, 4, 5 });
+
+    using namespace std::literals;
+    using namespace std::string_literals;
+    using namespace std::string_view_literals;
+    auto keyStringLiteral = "abc";
+    std::string keyString = keyStringLiteral;
+    std::string_view keyStringView = keyStringLiteral;
+    EXPECT_TRUE(std::get<uint64_t>(v.at(keyString)) == uint64_t(4));
+    EXPECT_TRUE(std::get<uint64_t >(v.find(keyString)->second) == uint64_t(4));
+    EXPECT_TRUE(std::get<uint64_t>(v.find(keyStringView)->second) == uint64_t(4));
+    EXPECT_TRUE(std::get<uint64_t>(v.find(keyStringLiteral)->second) == uint64_t(4));
+    EXPECT_TRUE(std::get<uint64_t>(v.at("abc"s)) == uint64_t(4));
+    EXPECT_TRUE(std::get<uint64_t>(v.at(keyStringLiteral)) == uint64_t(4));
+    // EXPECT_TRUE(v.at("abc"sv) == pmt(uint64_t(4))) -- not allowed by the ISO-C++ standard
+    // map::at(T key) checks for exact key and its type 'T'
+    // wrapping of std::string_view with std::string is required by ISO-C++ design of map::at(..)
+    EXPECT_TRUE(v.at(std::string(keyStringView)) == pmt(uint64_t(4))); // <- this is OK
 }
 
 
@@ -27,7 +46,7 @@ TEST(PmtMap, PmtMapTests)
     std::vector<int32_t> val2{ 44, 34563, -255729, 4402 };
 
     // Create the PMT map
-    std::map<std::string, pmt> input_map({
+    pmtv::map_t input_map({
         { "key1", val1 },
         { "key2", val2 },
     });
@@ -72,13 +91,13 @@ TEST(PmtMap, get_as)
     std::vector<int32_t> val2{ 44, 34563, -255729, 4402 };
 
     // Create the PMT map
-    std::map<std::string, pmt> input_map({
+    pmtv::map_t input_map({
         { "key1", val1 },
         { "key2", val2 },
     });
     auto x = pmt(input_map);
     // Make sure that we can get the value back out
-    // auto y = std::map<std::string, pmt>(x);
+    // auto y = std::map<std::string, pmt, std::less<>>(x);
     auto y = get_map(x);
     EXPECT_EQ(x == y, true);
 
@@ -92,7 +111,7 @@ TEST(PmtMap, base64)
     std::vector<int32_t> val2{ 44, 34563, -255729, 4402 };
 
     // Create the PMT map
-    std::map<std::string, pmt> input_map({
+    pmtv::map_t input_map({
         { "key1", val1 },
         { "key2", val2 },
     });
@@ -111,7 +130,7 @@ TEST(PmtMap, fmt)
     std::vector<int32_t> val2{ 44, 34563, -255729, 4402 };
 
     // Create the PMT map
-    std::map<std::string, pmt> input_map({
+    pmtv::map_t input_map({
         { "key1", val1 },
         { "key2", val2 },
     });

test/qa_uniform_vector.cpp

@@ -221,7 +221,7 @@ TYPED_TEST(PmtVectorFixture, get_as)
     // else
     //     EXPECT_THROW(std::vector<int>(x), ConversionError);
 
-    // using mtype = std::map<std::string, pmt>;
+    // using mtype = std::map<std::string, pmt, std::less<>>;
     // EXPECT_THROW(mtype(x), ConversionError);
 }