{"id":108462,"date":"2023-07-19T07:00:00","date_gmt":"2023-07-19T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=108462"},"modified":"2023-07-19T06:49:57","modified_gmt":"2023-07-19T13:49:57","slug":"20230719-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20230719-00\/?p=108462","title":{"rendered":"How to clone a Windows Runtime map in the face of possible concurrent modification, part 1"},"content":{"rendered":"

So far, we’ve been looking at cloning a Windows Runtime vector in the face of possible concurrent modification. We can apply what we’ve learned to Windows Runtime maps.<\/p>\n

The idea is basically the same: Use GetMany<\/code> to capture the contents atomically. The wrinkle is that there is no GetMany<\/code> method on a Windows Runtime map. We’ll have to get the iterator and call the iterator’s GetMany<\/code> method. But going to the iterator means that we could get a hresult_changed_state<\/code> exception if the map mutates between the time we obtain the iterator and the time we try to read from it.\u00b9<\/p>\n

template<typename M>\r\nauto clone_as_map(M const& m)\r\n-> std::map<\r\n        decltype(m.First().Current().Key()),\r\n        decltype(m.First().Current().Value())>\r\n{\r\n    using KVP = decltype(m.First().Current());\r\n    std::vector<KVP> pairs;\r\n    using K = decltype(KVP().Key());\r\n    using V = decltype(KVP().Value());\r\n    uint32_t expected;\r\n    uint32_t actual;\r\n    do {\r\n        expected = m.Size();\r\n        pairs.resize(expected + 1);\r\n        try {\r\n            actual = m.First().GetMany(pairs);\r\n        } catch (winrt::hresult_changed_state const&) {\r\n            continue;\r\n        }\r\n    } while (actual > expected);\r\n    pairs.erase(pairs.begin() + actual, pairs.end());\r\n    std::map<K, V> map;\r\n    for (auto&& pair : pairs) {\r\n        map.emplace(pair.Key(), pair.Value());\r\n    }\r\n    return map;\r\n}\r\n\r\ntemplate<typename M>\r\nauto CloneMap(M const& m)\r\n-> winrt::Windows::Foundation::\r\n        Collections::IMap<\r\n            decltype(m.First().Current().Key()),\r\n            decltype(m.First().Current().Value())>\r\n{\r\n    return winrt::multi_threaded_map(\r\n        clone_as_map(m));\r\n}\r\n<\/pre>\n
Note that we don’t need to use winrt_empty_value<T>()<\/code> when resizing the pairs<\/code> vector because the value type of the vector is IKeyValuePair<K, V><\/code>, which is an interface type and therefore has a default constructor that creates an empty smart pointer.<\/p>\n
Note also that I provide an explicit trailing return type instead of allowing the compiler to infer it from the return<\/code> statement. This allows the return type to participate in SFINAE. Unfortunately, representing this trailing return type is rather cumbersome because we have to write it out without the assistance of the K<\/code> and V<\/code> types defined in the function body.<\/p>\n
The C++\/WinRT library allows you to create IMap<\/code> implementations that are based either on std::map<\/code> or std::unordered_map<\/code>. The version above always uses std::map<\/code> with the same key and value as the original. But maybe we want to let you choose a std::unordered_map<\/code> or tweak the key and value types.<\/p>\n
We can use  type deduction from the future to default to using a std::map<\/code> that matches the inbound parameter, but let you pick a different collection if you like.<\/p>\n
template<typename, typename = void>            <\/span>\r\nstruct has_reserve_member : std::false_type {};<\/span>\r\ntemplate<typename T>                           <\/span>\r\nstruct has_reserve_member<T,                   <\/span>\r\n    std::void_t<decltype(                      <\/span>\r\n        std::declval<T>().reserve(0))>>        <\/span>\r\n    : std::true_type {};                       <\/span>\r\n\r\ntemplate<typename R = void, typename M>\r\nauto clone_as_map(M const& m)\r\n-> using C = std::conditional_t<<\/span>\r\n    std::is_same_v<R, void>,    <\/span>\r\n    std::map<K, V>,             <\/span>\r\n    R>                          <\/span>\r\n{\r\n    using KVP = decltype(m.First().Current());\r\n    std::vector<KVP> pairs;\r\n    using K = decltype(KVP().Key());\r\n    using V = decltype(KVP().Value());\r\n    uint32_t expected;\r\n    uint32_t actual;\r\n    do {\r\n        expected = m.Size();\r\n        pairs.resize(expected + 1);\r\n        try {\r\n            actual = m.First().GetMany(pairs);\r\n        } catch (hresult_changed_state const&) {\r\n            continue;\r\n        }\r\n    } while (actual > expected);\r\n    pairs.resize(actual);\r\n    using C = std::conditional_t<                <\/span>\r\n        std::is_same_v<R, void>,                 <\/span>\r\n        std::map<K, V>,                          <\/span>\r\n        R>;                                      <\/span>\r\n    C map;                                       <\/span>\r\n    if constexpr (has_reserve_member<C>::value) {<\/span>\r\n        map.reserve(actual);                     <\/span>\r\n    }                                            <\/span>\r\n    for (auto&& pair : pairs) {\r\n        map.emplace(pair.Key(), pair.Value());\r\n    }\r\n    return map;\r\n}\r\n\r\ntemplate<typename R = void, typename M>\r\nauto CloneAsMap(M const& m)\r\n-> winrt::Windows::Foundation::\r\n        Collections::IMap<\r\n            decltype(m.First().Current().Key()),\r\n            decltype(m.First().Current().Value())>\r\n{\r\n    return winrt::multi_threaded_map(\r\n        clone_as_map<R>(m));\r\n}\r\n<\/pre>\n
We create a detector class to see whether the underlying type has a reserve<\/code> method (which unordered_map<\/code> has); if so, then we call it to allow the container to prepare for the incoming elements.<\/p>\n
An example usage of this new feature would be<\/p>\n
winrt::Windows::Foundation::Collections::\r\n    IMap<winrt::hstring, int32_t> v = \/* ... *\/;\r\nauto clone = CloneAsMap<\r\n    std::unordered_map<winrt::hstring, int64_t,\r\n        case_insensitive_hash, case_insensitive_equal>>\r\n    (v);\r\n<\/pre>\n
This takes the original IMap<\/code> and clones it into a new IMap<\/code> which uses int64_t<\/code> as its value type rather than int32_t<\/code> (said conversion occuring through integer promotion), and which uses a custom hash class and custom equality class which treat the string as a case-insensitive string. We changed the underlying container to an unordered_map<\/code>, changed the value type, and chose non-default hash and equality classes.<\/p>\n
Another thing we might do to this function is add a lambda that lets you convert the original key-value pair to an arbitrary std::pair<\/code>, but arguably that’s really a job for std::transform<\/code>.<\/p>\n
But maybe we’re working too hard. We’ll try another approach next time.<\/p>\n
\u00b9 Note, however, that the iterator is not required<\/i> to throw a state changed exception. So we cannot rely on the exception to tell us that a concurrent mutation has occurred.<\/p>\n","protected":false},"excerpt":{"rendered":"
Applying what we learned about vectors.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-108462","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Applying what we learned about vectors.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108462","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=108462"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108462\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=108462"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=108462"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=108462"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}