{"id":108458,"date":"2023-07-18T07:00:00","date_gmt":"2023-07-18T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=108458"},"modified":"2023-07-18T07:26:02","modified_gmt":"2023-07-18T14:26:02","slug":"20230718-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20230718-00\/?p=108458","title":{"rendered":"How to clone a Windows Runtime vector in the face of possible concurrent modification, part 4"},"content":{"rendered":"

So far, we’ve looked at cloning a Windows Runtime vector in the face of possible concurrent modification<\/a>, using C++\/WinRT as our projection. Let’s extend our solution to C++\/CX.<\/p>\n

The initial translation to C++\/CX is straightforward. It’s pretty much a literal translation. We can take advantage of the fact that the default constructor for hat pointers is a null pointer, so we don’t have to use winrt_empty_value()<\/code>.<\/p>\n

template<typename V>\r\nauto clone_as_vector(V const& v)\r\n-> std::vector<decltype(v->GetAt(0))>\r\n{\r\n    using T = decltype(v->GetAt(0));\r\n    std::conditional_t<\r\n        std::is_same_v<T, bool>,\r\n        std::unique_ptr<bool[]>,\r\n        std::vector<T>> temp;\r\n    unsigned expected;\r\n    unsigned actual;\r\n    do\r\n    {\r\n        expected = v->Size;\r\n        if constexpr (std::is_same_v<T, bool>) {\r\n            temp = std::make_unique<bool[]>(expected + 1);\r\n            actual = v->GetMany(0, Platform::\r\n                ArrayReference<T>(temp.get(), expected + 1));                \r\n        }\r\n        else {\r\n            temp.resize(expected + 1);\r\n            actual = v->GetMany(0, Platform::\r\n                ArrayReference<T>(temp.data(), expected + 1));\r\n        }\r\n        }\r\n    } while (actual > expected);\r\n    if constexpr (std::is_same_v<T, bool>) {\r\n        return std::vector(temp.get(), temp.get() + actual);\r\n    } else {\r\n        temp.resize(actual);\r\n        return temp;\r\n    }\r\n}\r\n\r\ntemplate<typename V>\r\nauto CloneVector(V const& v)\r\n-> Windows::Foundation::\r\n    Collections::IVector<decltype(v->GetAt(0))>^\r\n{\r\n    return ref new Platform::Collections::\r\n        Vector<decltype(v->GetAt(0))>(\r\n            clone_as_vector(v));\r\n}\r\n<\/pre>\n
Or if you prefer the total separation version:<\/p>\n
template<typename V>\r\nauto clone_as_vector(V const& v)\r\n-> std::vector<decltype(v->GetAt(0))>\r\n{\r\n    using T = decltype(v->GetAt(0));\r\n    unsigned expected;\r\n    unsigned actual;\r\n    if constexpr (std::is_same_v<T, bool>) {\r\n        std::unique_ptr<bool[]> temp;\r\n        do\r\n        {\r\n            expected = v->Size;\r\n            temp = std::make_unique<bool[]>(expected + 1);\r\n            actual = v->GetMany(0, Platform::\r\n                ArrayReference<T>(temp.get(), expected + 1));                \r\n        } while (actual > expected);\r\n        return std::vector(temp.get(), temp.get() + actual);\r\n    } else {\r\n        std::vector<T>> temp;\r\n        do\r\n        {\r\n            expected = v->Size;\r\n            temp.resize(expected + 1);\r\n            actual = v->GetMany(0, Platform::\r\n                ArrayReference<T>(temp.data(), expected + 1));\r\n        } while (actual > expected);\r\n        temp.erase(temp.begin() + actual, temp.end());\r\n        return temp;\r\n    }\r\n}\r\n<\/pre>\n
However, there’s an addition wrinkle to C++\/CX: C++\/WinRT uses the ==<\/code> operator to implement IndexOf<\/code>, but C++\/CX lets you pass a custom equality comparer. (The default comparer is std::equal_to<T><\/code>, which uses ==<\/code>.) Therefore, to capture the full generality of Vector<\/code>, we allow the caller of Clone\u00adVector<\/code> to specify an equality comparer.<\/p>\n
Since we want to let the V<\/code> be deduced, we resort to using  type deduction from the future<\/a>.\u00b9<\/p>\n
template<typename E = void, typename V>\r\nauto CloneVector(V const& v)\r\n-> Windows::Foundation::\r\n    Collections::IVector<decltype(v->GetAt(0))>^\r\n{\r\n    using T = decltype(v->GetAt(0));\r\n    using ActualE = std::conditional_t<\r\n        std::conditional_t<std::is_same_v<E, void>,\r\n            std::equal_to<T>, E>;\r\n    \r\n    return ref new Platform::Collections::\r\n        Vector<T, ActualE>(clone_as_vector(v));\r\n}\r\n<\/pre>\n
There’s another customization point that we haven’t bothered with: std::vector<\/code> lets you provide a custom allocator. I omitted that because custom allocators are rather esoteric, and besides, the Platform::Collections::Vector<\/code> requires the provided std::vector<\/code> to use the standard allocator.<\/p>\n
Bonus chatter<\/b>: You can see the implementation of the C++\/CX collection types in the header file collection.h<\/code> that comes with the Visual C++ compiler. Other parts of the C++\/CX implementation can be found in vccorlib.h<\/code>.<\/p>\n
I’m not smart. I just know how to read.<\/p>\n
\u00b9 An alternative to type deduction from the future is overloading:<\/p>\n
template<typename E, typename V>\r\nauto CloneVector(V const& v)\r\n-> Windows::Foundation::\r\n    Collections::IVector<decltype(v->GetAt(0))>^\r\n{\r\n    using T = decltype(v->GetAt(0));\r\n    return ref new Platform::Collections::\r\n        Vector<T, E>(clone_as_vector(v));\r\n}\r\n\r\ntemplate<typename V>\r\nauto CloneVector(V const& v)\r\n-> Windows::Foundation::\r\n    Collections::IVector<decltype(v->GetAt(0))>^\r\n{\r\n    using T = decltype(v->GetAt(0));\r\n    return CloneVector<std::equal_to<T>, V>(v);\r\n}\r\n<\/pre>\n
The risk here is that somebody might want E = V<\/code>.<\/p>\n
\/\/ Error: Ambiguous call to overloaded function.\r\nCloneVector<V>(v);\r\n<\/pre>\n
This is trying to create a clone whose equality comparer is V<\/code>, but the compiler reports this as an ambiguous call because it matches both templates.<\/p>\n
This could happen if V<\/code> is a tree-like structure, so each element is a collection of other instances of itself.<\/p>\n","protected":false},"excerpt":{"rendered":"
Translating to C++\/CX and dealing with some quirks of that language.<\/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-108458","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Translating to C++\/CX and dealing with some quirks of that language.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108458","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=108458"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/108458\/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=108458"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=108458"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=108458"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}