{"id":104230,"date":"2020-09-17T07:00:00","date_gmt":"2020-09-17T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=104230"},"modified":"2020-09-17T08:44:47","modified_gmt":"2020-09-17T15:44:47","slug":"20200917-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20200917-00\/?p=104230","title":{"rendered":"The C++\/WinRT “capture” function helps you interoperate with the COM ABI world"},"content":{"rendered":"

C++\/WinRT is a freestanding library that is not dependent upon any Windows operating system header files<\/a>. You are welcome to stay completely in the C++\/WinRT world, but it’s not uncommon to have to interact with objects outside that world from time to time.<\/p>\n

It is a common pattern for COM methods to return objects through a pair of parameters REFIID<\/code> and void**<\/code>. The first parameter describes how you would like to receive the object, and the second parameter is where the object is returned. (Some functions which don’t follow this pattern have come to regret the decision<\/a>.)<\/p>\n

If you are calling a COM ABI method that follows this pattern, you can put the result into a C++\/WinRT smart pointer object with the help of the capture<\/code> function.<\/p>\n

There are actually four flavors of capture<\/code>, and they fall neatly into a table.<\/p>\n\n\n\n\n\n
\u00a0<\/th>\nFunctor<\/th>\nMethod pointer<\/th>\n<\/tr>\n
Instance method<\/th>\nwinrt::com_ptr<I> p;
\np.capture(Functor, args...);<\/code><\/td>\n		winrt::com_ptr<I> p;
\np.capture(q, &I2::Method, args...);<\/code><\/td>\n<\/tr>\n
Free function<\/th>\nauto p =
\n\u00a0\u00a0winrt::capture<I>(Functor, args...);<\/code><\/td>\n		auto p =
\n\u00a0\u00a0winrt::capture<I>(q, &I2::Method, args...);<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

In all cases, capture<\/code> throws a winrt::hresult_error<\/code> exception if the call fails.<\/p>\n

Today, we’ll look at the first column: The functor.<\/p>\n

Functor<\/i> is C++-speak for “anything you can call as if it were a function.” The functor could be an actual function, like CoGetObjectContext<\/code>, or it could be something that has an overloaded operator()<\/code>, such as a lambda.<\/p>\n

After the functor comes an optional list of additional parameters.<\/p>\n

In the functor form, capture<\/code> invokes the functor by passing the additional parameters, followed by a REFIID<\/code> and void**<\/code>.<\/p>\n

The functor is expected to return in the void**<\/code> parameter a pointer to object whose type is specified by the REFIID<\/code> parameter, and that pointer shall have it reference count incremented by one, indicating ownership. Fortunately, this convention is standard in COM, so you’re already in good shape on that front.<\/p>\n

Here’s an example of the most basic case:<\/p>\n

\/\/ Capture into an existing variable.\r\nwinrt::com_ptr<IContextCallback> context;\r\ncontext.capture(CoGetObjectContext);\r\n\r\n\/\/ Create a variable and capture in one step.\r\nauto p = winrt::capture<IContextCallback>(CoGetObjectContext);\r\n<\/pre>\n
This calls the CoGetObjectContext<\/code> function and puts the result into an existing variable p<\/code> or returns the result directly, which we place into a new variable p<\/code>.<\/p>\n
If you pass additional parameters, those are passed to the functor as well, and the REFIID<\/code> and void**<\/code> parameters go at the end.<\/p>\n
\/\/ Capture into existing object.\r\nwinrt::com_ptr<IWidget> widget;\r\nwidget.capture(CoUnmarshalInterface, stream.get());\r\n\r\n\/\/ Capture into new object.\r\nauto widget = winrt::capture<IWidget>(CoUnmarshalInterface, stream.get());\r\n<\/pre>\n
This will perform a<\/p>\n
CoUnmarshalInterface(stream.get(), riid, ppv)\r\n<\/pre>\n
where the riid<\/code> and ppv<\/code> receive the object.<\/p>\n
If you use capture<\/code> as a free function, you aren’t required to store the result into a variable. You could just use the result right away:<\/p>\n
HRESULT hr = winrt::capture<IWidget>(CoUnmarshalInterface, stream.get())->Toggle();\r\nif (FAILED(hr)) throw_hresult(hr);\r\n\r\n\/\/ Or equivalently\r\nwinrt::check_hresult(winrt::capture<IWidget>(CoUnmarshalInterface, stream.get())->Toggle());\r\n<\/pre>\n
You can pass a lambda or other callable object if you want to do something that isn’t expressible as a simple function. For example, the OleCreate<\/code> function does not place both the riid<\/code> and void**<\/code> parameters at the end of the parameter list. It doesn’t fit the pattern required by capture<\/code>, but you can fix that with a lambda that rearranges the parameters.\u00b2<\/p>\n
o.capture(\r\n    [](auto&& a, auto&& b, auto&& c, auto&& d, auto&& e, REFIID riid, void** ppv)\r\n    { return OleCreate(a, riid, b, c, d, e, ppv); },\r\n    rclsid, renderopt, pFormatEtc, pClientSite, pStg);\r\n<\/pre>\n
If you’re going to be doing this a lot, you may want to factor the lambda into a helper function.<\/p>\n
inline HRESULT CapturableOleCreate(\r\n  IN REFCLSID        rclsid,\r\n  IN DWORD           renderopt,\r\n  IN LPFORMATETC     pFormatEtc,\r\n  IN LPOLECLIENTSITE pClientSite,\r\n  IN LPSTORAGE       pStg,\r\n  IN REFIID          riid,\r\n  OUT LPVOID         *ppvObj)\r\n{\r\n    return OleCreate(rclsid, riid, renderopt, pFormatEtc, pClientSite, pStg, riid, ppv);\r\n}\r\n\r\no.capture(CapturableOleCreate, rclsid, renderopt, pFormatEtc, pClientSite, pStg);\r\n<\/pre>\n
After all this discussion, the second column is going to sound anticlimactic.<\/p>\n
If you want to obtain the object from a method call on an existing object, you can use the method pointer version of the capture<\/code> function. For example, suppose you have a IGlobalInterfaceTable<\/code> and you want to call GetInterfaceFromGlobal<\/code> to obtain an object from the global interface table.<\/p>\n
auto git = winrt::create_instance<\r\n    IGlobalInterfaceTable>(CLSID_StdGlobalInterfaceTable);\r\n\r\n\/\/ Capture into existing object.\r\nwinrt::com_ptr<IWidget> widget;\r\nwidget.capture(git, &IGlobalInterfaceTable::GetInterfaceFromGlobal, dwCookie);\r\n\r\n\/\/ Capture into new object.\r\nauto widget = winrt::capture<IWidget>(\r\n    git, &IGlobalInterfaceTable::GetInterfaceFromGlobal, dwCookie);\r\n<\/pre>\n
Bonus chatter<\/b>: C++\/WinRT comes with a premade capture wrapper for CoCreateInstance<\/code>:<\/p>\n
template <typename Interface>\r\nauto create_instance(guid const& clsid, uint32_t context = 0x1 \/*CLSCTX_INPROC_SERVER*\/, void* outer = nullptr);\r\n{\r\n    return capture(WINRT_IMPL_CoCreateInstance\u00b9, clsid, outer, context);\r\n}\r\n<\/pre>\n
The default context is “in-process server”, and there is no aggregation by default. You can use it like this:<\/p>\n
auto shellWindows = winrt::create_instance<IShellWindows>(CLSID_ShellWindows, CLSCTX_ALL);\r\n<\/pre>\n
Bonus bonus chatter<\/b>: The definition of capture<\/code> is quite simple:<\/p>\n
template <typename T>\r\nstruct com_ptr\r\n{\r\n    ...\r\n\r\n    template <typename F, typename...Args>\r\n    void capture(F function, Args&&...args)\r\n    {\r\n        check_hresult(function(args..., guid_of<T>(), put_void()));        \r\n    }\r\n\r\n    template <typename O, typename M, typename...Args>\r\n    void capture(com_ptr<O> const& object, M method, Args&&...args)\r\n    {\r\n        check_hresult((object.get()->*(method))(args..., guid_of<T>(), put_void()));\r\n    }\r\n}\r\n\r\ntemplate <typename T, typename F, typename...Args>\r\nauto capture(F function, Args&&...args)\r\n{\r\n    impl::com_ref<T> result{ nullptr };\r\n    check_hresult(function(args..., guid_of<T>(), reinterpret_cast<void**>(put_abi(result))));\r\n    return result;\r\n}\r\n\r\ntemplate <typename T, typename O, typename M, typename...Args>\r\nauto capture(com_ptr<O> const& object, M method, Args&&...args)\r\n{\r\n    impl::com_ref<T> result{ nullptr };\r\n    check_hresult((object.get()->*(method))(args..., guid_of<T>(), reinterpret_cast<void**>(put_abi(result))));\r\n    return result;\r\n}\r\n<\/pre>\n
This entire series is based on me reverse-engineering these four functions.<\/p>\n
\u00b9 The C++\/WinRT library is freestanding, so it contains its own private redeclaration of the CoCreateInstance<\/code> function. This redeclared version is for internal use only. Don’t use it from your own code. Basically, anything named WINRT_IMPL<\/code> or in the winrt::impl<\/code> namespace is reserved for internal use.<\/p>\n
\u00b2 I guess you could also have captured the parameters into the lambda:<\/p>\n
o.capture(\r\n    [&](REFIID riid, void** ppv)\r\n    { return OleCreate(rclsid, riid, renderopt, pFormatEtc, pClientSite, pStg, ppv); });\r\n<\/pre>\n
This could be handy if you are creating the same object many times with the same parameters. For example, if you were creating five objects from the stream, you could do this:<\/p>\n
auto create = [&](REFIID riid, void** ppv)\r\n    { return OleCreate(rclsid, riid, renderopt, pFormatEtc, pClientSite, pStg, ppv); });\r\n\r\no1.capture(create);\r\no2.capture(create);\r\no3.capture(create);\r\no4.capture(create);\r\no5.capture(create);\r\n<\/pre>\n
Note that the lambda is passed by value<\/i> to capture<\/code>, so a copy is made each time you use it. This means that your lambda probably shouldn’t have any mutable state, because the mutations are made to a copy of the original. It also means that your lambda probably shouldn’t capture objects with nontrivial copy constructors or destructors, because they will be invoked each time you use it.<\/p>\n","protected":false},"excerpt":{"rendered":"
Simplifying a common COM pattern.<\/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-104230","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Simplifying a common COM pattern.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/104230","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=104230"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/104230\/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=104230"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=104230"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=104230"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}