feat: add make_array_of_(uuid|guid)

include/wil/common.h

@@ -398,6 +398,15 @@ check fails as opposed to the invalid parameter handler that the STL invokes. Th
 // Until we'll have C++17 enabled in our code base, we're falling back to SAL
 #define WI_NODISCARD __WI_LIBCPP_NODISCARD_ATTRIBUTE
 
+#ifdef __has_cpp_attribute
+#if __has_cpp_attribute(nodiscard) >= 201907L
+#define WI_NODISCARD_REASON(x) [[nodiscard(x)]]
+#endif
+#endif
+#ifndef WI_NODISCARD_REASON
+#define WI_NODISCARD_REASON(x) WI_NODISCARD
+#endif
+
 #define __R_ENABLE_IF_IS_CLASS(ptrType) wistd::enable_if_t<wistd::is_class<ptrType>::value, void*> = nullptr
 #define __R_ENABLE_IF_IS_NOT_CLASS(ptrType) wistd::enable_if_t<!wistd::is_class<ptrType>::value, void*> = nullptr
 

include/wil/cppwinrt_authoring.h

@@ -111,6 +111,126 @@ struct single_threaded_rw_property : single_threaded_property<T>
 
 #endif // __WIL_CPPWINRT_AUTHORING_PROPERTIES_INCLUDED
 
+#if (!defined(__WIL_CPPWINRT_AUTHORING_INCLUDED_ICLASSFACTORY) && defined(__IClassFactory_INTERFACE_DEFINED__)) || \
+    defined(WIL_DOXYGEN) // class factory
+/// @cond
+#define __WIL_CPPWINRT_AUTHORING_INCLUDED_ICLASSFACTORY
+/// @endcond
+
+template <typename T, typename... Rest>
+struct class_factory : winrt::implements<class_factory<T, Rest...>, IClassFactory, winrt::no_weak_ref, Rest...>
+{
+    HRESULT __stdcall CreateInstance(IUnknown* outer, GUID const& iid, void** result) noexcept final
+    try
+    {
+        *result = nullptr;
+
+        if (!outer)
+        {
+            return winrt::make_self<T>().as(iid, result);
+        }
+        else
+        {
+            return CLASS_E_NOAGGREGATION;
+        }
+    }
+    CATCH_RETURN()
+
+    HRESULT __stdcall LockServer(BOOL lock) noexcept final
+    try
+    {
+        if (lock)
+        {
+            ++winrt::get_module_lock();
+        }
+        else
+        {
+            --winrt::get_module_lock();
+        }
+
+        return S_OK;
+    }
+    CATCH_RETURN()
+};
+
+#endif // !defined(__WIL_CPPWINRT_AUTHORING_INCLUDED_ICLASSFACTORY) && defined(__IClassFactory_INTERFACE_DEFINED__)
+
+#if (!defined(__WIL_CPPWINRT_AUTHORING_INCLUDED_COM_SERVER) && defined(__WIL_CPPWINRT_AUTHORING_INCLUDED_ICLASSFACTORY) && defined(_COMBASEAPI_H_)) || \
+    defined(WIL_DOXYGEN) // COM server
+/// @cond
+#define __WIL_CPPWINRT_AUTHORING_INCLUDED_COM_SERVER
+/// @endcond
+
+template <typename T>
+WI_NODISCARD_REASON("The class is unregistered when the returned value is destructed")
+unique_com_class_object_cookie
+    register_com_server(GUID const& guid, DWORD context = CLSCTX_LOCAL_SERVER, DWORD flags = REGCLS_MULTIPLEUSE)
+{
+    unique_com_class_object_cookie registration;
+    winrt::check_hresult(CoRegisterClassObject(
+        guid, winrt::make<class_factory<T, winrt::no_module_lock>>().get(), context, flags, registration.put()));
+    return registration;
+}
+
+template <typename... Types>
+struct clsid_array
+{
+    std::array<GUID, sizeof...(Types)> value;
+};
+
+template <typename... Ts>
+WI_NODISCARD_REASON("The classes are unregistered when the returned value is destructed")
+std::vector<unique_com_class_object_cookie> register_com_server(
+    wil::clsid_array<Ts...> const& clsids, DWORD context = CLSCTX_LOCAL_SERVER, DWORD flags = REGCLS_MULTIPLEUSE)
+{
+    std::vector<wil::unique_com_class_object_cookie> registrations;
+    registrations.reserve(sizeof...(Ts));
+
+    std::size_t i = 0;
+    (registrations.push_back(wil::register_com_server<Ts>(clsids.value[i++], context, flags | REGCLS_SUSPENDED)), ...);
+
+    // allow the user to keep class objects suspended if they've explicitly passed REGCLS_SUSPENDED.
+    if (!WI_IsFlagSet(flags, REGCLS_SUSPENDED))
+    {
+        winrt::check_hresult(CoResumeClassObjects());
+    }
+
+    return registrations;
+}
+
+namespace details
+{
+    template <typename T>
+    struct has_iid
+    {
+        template <typename U = T, std::enable_if_t<std::is_same_v<GUID, std::decay_t<decltype(__uuidof(U))>>, int> = 0>
+        static std::true_type invoke(int);
+
+        template <typename U = T>
+        static std::false_type invoke(float);
+
+        static constexpr bool value = decltype(invoke(0))::value;
+    };
+
+    template <typename T>
+    constexpr bool has_iid_v = has_iid<T>::value;
+}
+
+template <typename... Types>
+constexpr auto make_array_of_uuid()
+{
+    return clsid_array<Types...>{std::array<GUID, sizeof...(Types)>{__uuidof(Types)...}};
+}
+
+template <typename... Types>
+constexpr auto make_array_of_guid()
+{
+    static_assert(!(... && details::has_iid_v<Types>), "Use make_array_of_uuid for COM class instead");
+    return clsid_array<Types...>{std::array<GUID, sizeof...(Types)>{winrt::guid_of<Types>()...}};
+}
+
+#endif // (!defined(__WIL_CPPWINRT_AUTHORING_INCLUDED_COM_SERVER) && defined(__WIL_CPPWINRT_AUTHORING_INCLUDED_ICLASSFACTORY) && defined(_COMBASEAPI_H_))
+
 #if (!defined(__WIL_CPPWINRT_AUTHORING_INCLUDED_FOUNDATION) && defined(WINRT_Windows_Foundation_H)) || \
     defined(WIL_DOXYGEN) // WinRT / XAML helpers
 /// @cond

include/wil/cppwinrt_notifiable_server_lock.h

@@ -0,0 +1,81 @@
+//*********************************************************
+//
+//    Copyright (c) Microsoft. All rights reserved.
+//    This code is licensed under the MIT License.
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+//    ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+//    TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+//    PARTICULAR PURPOSE AND NONINFRINGEMENT.
+//
+//*********************************************************
+//! @file
+//! A server lock that runs a callback once all references are released.
+
+#ifndef __WIL_CPPWINRT_NOTIFIABLE_MODULE_LOCK_INCLUDED
+#define __WIL_CPPWINRT_NOTIFIABLE_MODULE_LOCK_INCLUDED
+
+#ifdef WINRT_BASE_H
+#error You must include this header before including any winrt header
+#endif
+
+#ifndef WINRT_CUSTOM_MODULE_LOCK
+#error You must define 'WINRT_CUSTOM_MODULE_LOCK' at the project level
+#endif
+
+#include <combaseapi.h>
+#include <cstdint>
+#include <functional>
+
+namespace wil
+{
+struct notifiable_server_lock
+{
+    uint32_t operator++() noexcept
+    {
+        return CoAddRefServerProcess();
+    }
+
+    uint32_t operator--()
+    {
+        const auto ref = CoReleaseServerProcess();
+        if (ref == 0 && notifier)
+        {
+            notifier();
+        }
+
+        return ref;
+    }
+
+    template <typename Func>
+    void set_notifier(Func&& func)
+    {
+        notifier = std::forward<Func>(func);
+    }
+
+    void set_notifier(std::nullptr_t) noexcept
+    {
+        notifier = nullptr;
+    }
+
+    static notifiable_server_lock& instance() noexcept
+    {
+        static notifiable_server_lock lock;
+        return lock;
+    }
+
+private:
+    notifiable_server_lock() = default;
+
+    std::function<void()> notifier;
+};
+} // namespace wil
+
+namespace winrt
+{
+auto& get_module_lock() noexcept
+{
+    return wil::notifiable_server_lock::instance();
+}
+} // namespace winrt
+
+#endif