Add monitoring for registry changes

Author: Mike Grier

.gitignore

@@ -23,7 +23,7 @@ mono_crash.*
 [Rr]eleases/
 x64/
 x86/
-[Ww][Ii][Nn]32/
+# [Ww][Ii][Nn]32/
 [Aa][Rr][Mm]/
 [Aa][Rr][Mm]64/
 bld/

src/Linux/libraries/linux_strings/include/m/linux_strings/convert.h

@@ -16,6 +16,7 @@
 #include <m/utf/encode.h>
 #include <m/utf/transcode.h>
 #include <m/utility/make_span.h>
+#include <m/utility/pointers.h>
 
 namespace m
 {
@@ -139,6 +140,21 @@ namespace m
         return str;
     }
 
+    constexpr std::optional<std::wstring>
+    to_wstring(char16_t const* ptr)
+    {
+        if (ptr != nullptr)
+            return to_wstring(std::u16string_view(ptr));
+
+        return std::nullopt;
+    }
+
+    constexpr std::wstring
+    to_wstring(m::not_null<char16_t const*> ptr)
+    {
+        return to_wstring(std::u16string_view(ptr));
+    }
+
     constexpr void
     to_wstring(std::u32string_view view, std::wstring& str)
     {

src/Windows/libraries/CMakeLists.txt

@@ -3,6 +3,7 @@ cmake_minimum_required(VERSION 3.23)
 add_subdirectory(errors)
 add_subdirectory(formatters)
 add_subdirectory(multi_byte)
+add_subdirectory(win32)
 add_subdirectory(windows_strings)
 add_subdirectory(windows_wrappers)
 

src/Windows/libraries/multi_byte/include/m/multi_byte/convert_wchar.h

@@ -8,6 +8,7 @@
 #include <string_view>
 
 #include <m/utf/transcode.h>
+#include <m/utility/pointers.h>
 
 #include "convert.h"
 
@@ -73,6 +74,21 @@ namespace m
         utf::transcode(std::u8string_view{s}, str);
     }
 
+    constexpr std::wstring
+    to_wstring(m::not_null<char8_t const*> ptr)
+    {
+        return to_wstring(std::u8string_view(ptr));
+    }
+
+    constexpr std::optional<std::wstring>
+    to_wstring(char8_t const* ptr)
+    {
+        if (ptr)
+            return to_wstring(m::not_null<char8_t const*>(ptr));
+
+        return std::nullopt;
+    }
+
     constexpr std::wstring
     to_wstring(std::u16string_view v)
     {
@@ -127,6 +143,21 @@ namespace m
         utf::transcode(std::u16string_view{s}, str);
     }
 
+    constexpr std::wstring
+    to_wstring(m::not_null<char16_t const*> ptr)
+    {
+        return to_wstring(std::u16string_view(ptr));
+    }
+
+    constexpr std::optional<std::wstring>
+    to_wstring(char16_t const* ptr)
+    {
+        if (ptr)
+            return to_wstring(m::not_null<char16_t const*>(ptr));
+
+        return std::nullopt;
+    }
+
     constexpr std::wstring
     to_wstring(std::u32string_view v)
     {
@@ -181,6 +212,21 @@ namespace m
         utf::transcode(std::u32string_view{s}, str);
     }
 
+    constexpr std::wstring
+    to_wstring(m::not_null<char32_t const*> ptr)
+    {
+        return to_wstring(std::u32string_view(ptr));
+    }
+
+    constexpr std::optional<std::wstring>
+    to_wstring(char32_t const* ptr)
+    {
+        if (ptr)
+            return to_wstring(m::not_null<char32_t const*>(ptr));
+
+        return std::nullopt;
+    }
+
     constexpr void
     to_u8string(std::wstring_view v, std::u8string& str)
     {
@@ -195,6 +241,21 @@ namespace m
         return str;
     }
 
+    constexpr std::u8string
+    to_u8string(m::not_null<wchar_t const*> ptr)
+    {
+        return to_u8string(std::wstring_view(ptr));
+    }
+
+    constexpr std::optional<std::u8string>
+    to_u8string(wchar_t const* ptr)
+    {
+        if (ptr)
+            return to_u8string(m::not_null<wchar_t const*>(ptr));
+
+        return std::nullopt;
+    }
+
     constexpr void
     to_u16string(std::wstring_view v, std::u16string& str)
     {
@@ -209,6 +270,21 @@ namespace m
         return str;
     }
 
+    constexpr std::u16string
+    to_u16string(m::not_null<wchar_t const*> ptr)
+    {
+        return to_u16string(std::wstring_view(ptr));
+    }
+
+    constexpr std::optional<std::u16string>
+    to_u16string(wchar_t const* ptr)
+    {
+        if (ptr)
+            return to_u16string(m::not_null<wchar_t const*>(ptr));
+
+        return std::nullopt;
+    }
+
     //
     // to_u32string
     //
@@ -226,4 +302,19 @@ namespace m
         return str;
     }
 
+    constexpr std::u32string
+    to_u32string(m::not_null<wchar_t const*> ptr)
+    {
+        return to_u32string(std::wstring_view(ptr));
+    }
+
+    constexpr std::optional<std::u32string>
+    to_u32string(wchar_t const* ptr)
+    {
+        if (ptr)
+            return to_u32string(m::not_null<wchar_t const*>(ptr));
+
+        return std::nullopt;
+    }
+
 } // namespace m

src/Windows/libraries/win32/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.23)
+
+add_library(m_win32 STATIC)
+
+target_compile_features(m_win32 PUBLIC ${M_CXX_STD})
+
+add_subdirectory(include)
+add_subdirectory(src)
+add_subdirectory(test)
+
+list(APPEND m_installation_targets
+    m_win32
+)
+
+set(m_installation_targets ${m_installation_targets} PARENT_SCOPE)

src/Windows/libraries/win32/README.md

@@ -0,0 +1,70 @@
+# What is m/src/Windows/libraries/wrappers?
+
+The Win32 API has a lot of cases of use of primitive types like a DWORD which
+is a simple typedef / type alias of a 32 bit unsigned integer (whose type
+varies between platforms! oh my!) where in some contexts is it a holder of
+a certain set of bit flags, in another it is a millisecond count, and in
+another it is an error code with a specific range.
+
+The wrappers here are _intended_ to be very simple wrapper types that give
+some type-wise uniqueness around these primitive types so that they can be
+used in overloads and their use in parameter lists is "self documenting"
+to some degree.
+
+This is not _intended_ to be the beginning of yet another HANDLE-with-
+automatic-CloseHandle-semantics set of classes or such. These are useful
+and necessary. There is a set of these provided by the `wil` library, the
+Windows Implementation Library, freely and publicly available. `wil` has
+its ups and downs and trying to "compete" with it is well outside the
+scope of anything I would want to do here with "m".
+
+"m" is intended to move C++ forward, indeally in the context of Windows as
+well as other platforms, not move Windows forward in the context of C++.
+
+Unfortunately, it has proven difficult to compose `wil` with "m", so I have
+found myself building RAII classes that overlap but they are not part of
+the public API surface area of "m" and they are not intended to be for the
+foreseeable future.
+
+These types however, are innocuous structs around DWORDs and the like,
+just with explicit conversions in and out.
+
+The C++ Guidelines recommend use of a scoped enumeration for these sorts
+of things. The problem with scoped enumerations is that you cannot add
+some of the operators to them so my default stance is a struct with
+explicit constructor and explicit operator T to convert in and out
+which should get the basic type safety.
+
+Thus, the default "wrapper" for, for example, a DWORD type might look like:
+
+```
+struct dword_for_ms
+{
+    dword_for_ms() = default;
+    constexpr explicit dword_for_ms(DWORD v) noexcept : m_v(v) {}
+    constexpr dword_for_ms(dword_for_ms const& other) noexcept : m_v(other.m_v) {}
+    constexpr dword_for_ms(dword_for_ms&& other) noexcept : m_v(other.m_v) {}
+    ~dword_for_ms() = default;
+
+    constexpr dword_for_ms& operator=(dword_for_ms const& other) noexcept { m_v = other.m_v; return *this; }
+    constexpr dword_for_ms& operator=(dword_for_ms&& other) noexcept { m_v = other.m_v; return *this; }
+
+    constexpr void swap(dword_for_ms& other) noexcept {
+        using std::swap;
+        swap(m_v, other.m_v);
+    }
+
+    explicit constexpr operator DWORD() const { return m_v; }
+    constexpr bool operator==(dword_for_ms other) const { return m_v == other.m_v; }
+
+    constexpr auto operator<=>(dword_for_ms other) const { return operator<=>(m_v, other.m_v); }
+
+    DWORD m_v;
+};
+```
+
+Language experts can probably hone this to what really has to be implemented,
+for example, perhaps the move constructor should _not_ be implemented.
+
+Also note that this is prime real estate for a template.
+

src/Windows/libraries/win32/include/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.23)
+
+target_sources(m_win32 PUBLIC FILE_SET HEADERS FILES
+    m/win32/handle.h
+    m/win32/registry.h
+    m/win32/threadpool.h
+)
+
+set(m_installation_targets ${m_installation_targets} PARENT_SCOPE)

src/Windows/libraries/win32/include/m/win32/event.h

@@ -0,0 +1,100 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+#pragma once
+
+#include <system_error>
+#include <utility>
+
+#include <m/utility/enum_operations.h.h>
+#include <m/win32/handle.h>
+
+#undef NOMINMAX
+#define NOMINMAX
+
+#include <Windows.h>
+
+namespace m::win32
+{
+    enum class create_event_flags : uint32_t
+    {
+        initial_set  = 0x00000002, // CREATE_EVENT_INITIAL_SET
+        manual_reset = 0x00000001, // CREATE_EVENT_MANUAL_RESET
+    };
+
+    M_DEFINE_SCOPED_ENUM_BITFLAG_OPS(create_event_flags);
+
+    class event : protected handle
+    {
+        using base_type = handle;
+
+    public:
+        event() = default;
+
+        enum class event_kind
+        {
+            automatic,
+            manual,
+        };
+
+        event(create_event_flags flags, DWORD desired_access = SYNCHRONIZE | EVENT_MODIFY_STATE);
+
+        event(event_kind kind, DWORD desired_access = SYNCHRONIZE | EVENT_MODIFY_STATE);
+
+        constexpr event(HANDLE hdl, event_kind kind) noexcept: base_type(hdl), m_event_kind(kind) {}
+
+        constexpr event(event&& other) noexcept: m_event_kind{}
+        {
+            using std::swap;
+            swap(m_event_kind, other.m_event_kind);
+            swap(m_handle, other.m_handle);
+        }
+
+        event(event const& other) = delete;
+
+        constexpr event&
+        operator=(event&& other) noexcept
+        {
+            using std::swap;
+            swap(m_handle, other.m_handle);
+            return *this;
+        }
+
+        event&
+        operator=(event const&) = delete;
+
+        ~event() = default;
+
+        constexpr void
+        swap(event& other) noexcept
+        {
+            using std::swap;
+
+            swap(m_handle, other.m_handle);
+        }
+
+        using base_type::addressof;
+        using base_type::get;
+        using base_type::handle;
+        using base_type::is_valid;
+        using base_type::reset;
+
+        void
+        create(create_event_flags flags, DWORD desired_access = SYNCHRONIZE | EVENT_MODIFY_STATE);
+
+        [[nodiscard]] std::error_code
+        createq(create_event_flags flags, DWORD desired_access = SYNCHRONIZE | EVENT_MODIFY_STATE);
+
+        enum class event_state
+        {
+            reset,
+            set,
+        };
+
+        void
+        set_event_state(event_state state);
+
+    private:
+        event_kind m_event_kind;
+    };
+
+} // namespace m::win32