Refactor window management to use WindowRegistry

Introduces a thread-safe ObjectRegistry utility and a WindowRegistry singleton to centralize window instance tracking. Refactors platform-specific WindowManager implementations to use WindowRegistry for storing, retrieving, and enumerating windows, replacing internal unordered_map usage. Updates window_manager.h to remove the internal windows_ map and adds new window_registry.{h,cpp} files for registry logic.

Author: lijy91

src/foundation/object_registry.h

@@ -0,0 +1,114 @@
+/**
+ * @file object_registry.h
+ * @brief Thread-safe registry for mapping IDs to shared objects.
+ *
+ * This utility provides a minimal, lock-guarded container that stores
+ * `std::shared_ptr<TObject>` instances keyed by `TId`. It is intended for
+ * simple, centralized tracking of live objects (e.g., windows, menus) and
+ * supports lookup, enumeration, removal, and clearing operations.
+ *
+ * Thread-safety:
+ * - All public methods take a mutex to protect internal state.
+ * - Methods marked `const` still acquire the mutex (via a `mutable` mutex)
+ *   to ensure safe concurrent access while preserving the const interface.
+ *
+ * Requirements:
+ * - `TId` must be hashable and equality comparable (usable as an
+ *   `unordered_map` key).
+ * - Objects are stored as `std::shared_ptr<TObject>`. The registry does not
+ *   impose ownership semantics beyond holding shared references.
+ */
+#pragma once
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+#include <vector>
+
+namespace nativeapi {
+
+template <typename TObject, typename TId>
+class ObjectRegistry {
+ public:
+  /**
+   * @brief Add or replace an object for the given ID.
+   *
+   * If an entry for `id` already exists, it is replaced by `object`.
+   * This operation is O(1) average-case.
+   *
+   * @param id The identifier used as key in the registry.
+   * @param object The object to store; moved into the registry.
+   */
+  void Add(TId id, std::shared_ptr<TObject> object) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    objects_[id] = std::move(object);
+  }
+
+  /**
+   * @brief Get the object associated with an ID.
+   *
+   * This operation is O(1) average-case.
+   *
+   * @param id The identifier to look up.
+   * @return std::shared_ptr<TObject> The stored object if present,
+   *         otherwise `nullptr`.
+   */
+  std::shared_ptr<TObject> Get(TId id) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto it = objects_.find(id);
+    return it == objects_.end() ? nullptr : it->second;
+  }
+
+  /**
+   * @brief Get a snapshot vector of all stored objects.
+   *
+   * The returned vector contains strong references to the objects as they
+   * existed at the moment of the call. Subsequent mutations to the registry
+   * are not reflected in the returned vector.
+   *
+   * Complexity: O(N) to allocate and copy shared pointers.
+   *
+   * @return std::vector<std::shared_ptr<TObject>> Snapshot of all objects.
+   */
+  std::vector<std::shared_ptr<TObject>> GetAll() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    std::vector<std::shared_ptr<TObject>> result;
+    result.reserve(objects_.size());
+    for (const auto& kv : objects_) {
+      result.push_back(kv.second);
+    }
+    return result;
+  }
+
+  /**
+   * @brief Remove an object by ID.
+   *
+   * This operation is O(1) average-case.
+   *
+   * @param id The identifier to remove.
+   * @return true If an entry was found and removed.
+   * @return false If no entry existed for the given ID.
+   */
+  bool Remove(TId id) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return objects_.erase(id) > 0;
+  }
+
+  /**
+   * @brief Remove all entries from the registry.
+   *
+   * Complexity: O(N) to destroy or release stored shared pointers.
+   */
+  void Clear() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    objects_.clear();
+  }
+
+ private:
+  // Mutex is mutable to allow locking in logically-const operations.
+  mutable std::mutex mutex_;
+  std::unordered_map<TId, std::shared_ptr<TObject>> objects_;
+};
+
+}  // namespace nativeapi
+
+

src/platform/linux/window_manager_linux.cpp

@@ -7,6 +7,7 @@
 
 #include "../../window.h"
 #include "../../window_manager.h"
+#include "../../window_registry.h"
 
 // Import GTK headers
 #include <gdk/gdk.h>
@@ -255,9 +256,9 @@ void WindowManager::DispatchWindowEvent(const WindowEvent& event) {
 }
 
 std::shared_ptr<Window> WindowManager::Get(WindowId id) {
-  auto it = windows_.find(id);
-  if (it != windows_.end()) {
-    return it->second;
+  auto cached = WindowRegistry::GetInstance().Get(id);
+  if (cached) {
+    return cached;
   }
 
   // Try to find the window by ID in the current display
@@ -274,7 +275,7 @@ std::shared_ptr<Window> WindowManager::Get(WindowId id) {
 
     if (gdk_window && GetOrCreateWindowId(gdk_window) == id) {
       auto window = std::make_shared<Window>((void*)gdk_window);
-      windows_[id] = window;
+      WindowRegistry::GetInstance().Add(id, window);
       g_list_free(toplevels);
       return window;
     }
@@ -299,20 +300,16 @@ std::vector<std::shared_ptr<Window>> WindowManager::GetAll() {
 
     if (gdk_window) {
       WindowId window_id = GetOrCreateWindowId(gdk_window);
-      auto it = windows_.find(window_id);
-      if (it == windows_.end()) {
+      if (!WindowRegistry::GetInstance().Get(window_id)) {
         auto window = std::make_shared<Window>((void*)gdk_window);
-        windows_[window_id] = window;
+        WindowRegistry::GetInstance().Add(window_id, window);
       }
     }
   }
   g_list_free(toplevels);
 
   // Return all cached windows
-  for (auto& window : windows_) {
-    windows.push_back(window.second);
-  }
-  return windows;
+  return WindowRegistry::GetInstance().GetAll();
 }
 
 std::shared_ptr<Window> WindowManager::GetCurrent() {
@@ -417,7 +414,7 @@ std::shared_ptr<Window> WindowManager::Create(const WindowOptions& options) {
   // Create our Window wrapper and cache before showing
   auto window = std::make_shared<Window>((void*)gdk_window);
   WindowId window_id = GetOrCreateWindowId(gdk_window);
-  windows_[window_id] = window;
+  WindowRegistry::GetInstance().Add(window_id, window);
 
   // Invoke pre-show hook if set
   InvokeWillShowHook(window_id);
@@ -431,13 +428,13 @@ std::shared_ptr<Window> WindowManager::Create(const WindowOptions& options) {
 }
 
 bool WindowManager::Destroy(WindowId id) {
-  auto it = windows_.find(id);
-  if (it != windows_.end()) {
-    // TODO: Implement proper GTK window destruction
-    windows_.erase(it);
-    return true;
+  auto window = WindowRegistry::GetInstance().Get(id);
+  if (!window) {
+    return false;
   }
-  return false;
+  // TODO: Implement proper GTK window destruction
+  WindowRegistry::GetInstance().Remove(id);
+  return true;
 }
 
 void WindowManager::SetWillShowHook(std::optional<WindowWillShowHook> hook) {

src/platform/macos/window_manager_macos.mm

@@ -6,6 +6,7 @@
 
 #include "../../window.h"
 #include "../../window_manager.h"
+#include "../../window_registry.h"
 
 // Forward declaration for the delegate
 @class NativeAPIWindowManagerDelegate;
@@ -272,7 +273,7 @@ - (void)windowWillClose:(NSNotification*)notification {
   [ns_window makeMainWindow];
   WindowId window_id = [ns_window windowNumber];
   auto window = std::make_shared<Window>((__bridge void*)ns_window);
-  windows_[window_id] = window;
+  WindowRegistry::GetInstance().Add(window_id, window);
 
   // Dispatch window created event
   WindowCreatedEvent created_event(window_id);
@@ -283,33 +284,32 @@ - (void)windowWillClose:(NSNotification*)notification {
 
 // Destroy a window by its ID. Returns true if window was destroyed.
 bool WindowManager::Destroy(WindowId id) {
-  auto it = windows_.find(id);
-  if (it != windows_.end()) {
-    // Get the NSWindow to close it
-    NSArray* ns_windows = [[NSApplication sharedApplication] windows];
-    for (NSWindow* ns_window in ns_windows) {
-      if ([ns_window windowNumber] == id) {
-        [ns_window close];
-        windows_.erase(it);
-        return true;
-      }
+  auto window = WindowRegistry::GetInstance().Get(id);
+  if (!window) {
+    return false;
+  }
+  NSArray* ns_windows = [[NSApplication sharedApplication] windows];
+  for (NSWindow* ns_window in ns_windows) {
+    if ([ns_window windowNumber] == id) {
+      [ns_window close];
+      WindowRegistry::GetInstance().Remove(id);
+      return true;
     }
-    // Remove from our map even if we couldn't find the NSWindow
-    windows_.erase(it);
   }
+  WindowRegistry::GetInstance().Remove(id);
   return false;
 }
 
 std::shared_ptr<Window> WindowManager::Get(WindowId id) {
-  auto it = windows_.find(id);
-  if (it != windows_.end()) {
-    return it->second;
+  auto cached = WindowRegistry::GetInstance().Get(id);
+  if (cached) {
+    return cached;
   }
   NSArray* ns_windows = [[NSApplication sharedApplication] windows];
   for (NSWindow* ns_window in ns_windows) {
     if ([ns_window windowNumber] == id) {
       auto window = std::make_shared<Window>((__bridge void*)ns_window);
-      windows_[id] = window;
+      WindowRegistry::GetInstance().Add(id, window);
       return window;
     }
   }
@@ -321,14 +321,15 @@ - (void)windowWillClose:(NSNotification*)notification {
   NSArray* ns_windows = [[NSApplication sharedApplication] windows];
   for (NSWindow* ns_window in ns_windows) {
     WindowId window_id = [ns_window windowNumber];
-    auto it = windows_.find(window_id);
-    if (it == windows_.end()) {
+    if (!WindowRegistry::GetInstance().Get(window_id)) {
       auto window = std::make_shared<Window>((__bridge void*)ns_window);
-      windows_[window_id] = window;
+      WindowRegistry::GetInstance().Add(window_id, window);
     }
   }
-  for (auto& window : windows_) {
-    windows.push_back(window.second);
+  // Merge cached windows from registry to ensure consistency
+  auto cached = WindowRegistry::GetInstance().GetAll();
+  for (const auto& w : cached) {
+    windows.push_back(w);
   }
   return windows;
 }

src/platform/windows/window_manager_windows.cpp

@@ -5,6 +5,7 @@
 #include <psapi.h>
 #include "../../window.h"
 #include "../../window_event.h"
+#include "../../window_registry.h"
 #include "../../window_manager.h"
 #include "string_utils_windows.h"
 
@@ -421,7 +422,7 @@ std::shared_ptr<Window> WindowManager::Create(const WindowOptions& options) {
 
   auto window = std::make_shared<Window>(hwnd);
   WindowId window_id = window->GetId();
-  windows_[window_id] = window;
+  WindowRegistry::GetInstance().Add(window_id, window);
 
   // Dispatch window created event
   WindowCreatedEvent created_event(window_id);
@@ -432,45 +433,35 @@ std::shared_ptr<Window> WindowManager::Create(const WindowOptions& options) {
 
 // Destroy a window by its ID. Returns true if window was destroyed.
 bool WindowManager::Destroy(WindowId id) {
-  auto it = windows_.find(id);
-  if (it != windows_.end()) {
-    HWND hwnd = static_cast<HWND>(it->second->GetNativeObject());
-    if (IsWindow(hwnd)) {
-      DestroyWindow(hwnd);
-    }
-    windows_.erase(it);
-    return true;
+  auto window = WindowRegistry::GetInstance().Get(id);
+  if (!window) {
+    return false;
+  }
+  HWND hwnd = static_cast<HWND>(window->GetNativeObject());
+  if (IsWindow(hwnd)) {
+    DestroyWindow(hwnd);
   }
-  return false;
+  WindowRegistry::GetInstance().Remove(id);
+  return true;
 }
 
 std::shared_ptr<Window> WindowManager::Get(WindowId id) {
-  auto it = windows_.find(id);
-  if (it != windows_.end()) {
-    return it->second;
+  auto cached = WindowRegistry::GetInstance().Get(id);
+  if (cached) {
+    return cached;
   }
-
   // Check if the window still exists in the system
   HWND hwnd = reinterpret_cast<HWND>(id);
   if (IsWindow(hwnd)) {
     auto window = std::make_shared<Window>(hwnd);
-    windows_[id] = window;
+    WindowRegistry::GetInstance().Add(id, window);
     return window;
   }
-
   return nullptr;
 }
 
 std::vector<std::shared_ptr<Window>> WindowManager::GetAll() {
-  std::vector<std::shared_ptr<Window>> windows;
-
-  // Enumerate all windows and add them to our collection
-  // This is a simplified implementation
-  for (auto& window_pair : windows_) {
-    windows.push_back(window_pair.second);
-  }
-
-  return windows;
+  return WindowRegistry::GetInstance().GetAll();
 }
 
 std::shared_ptr<Window> WindowManager::GetCurrent() {

src/window_manager.h

@@ -205,13 +205,7 @@ class WindowManager : public EventEmitter<WindowEvent> {
   class Impl;
   std::unique_ptr<Impl> pimpl_;
 
-  /**
-   * @brief Internal registry of all managed windows
-   *
-   * Maps window IDs to their corresponding Window instances for fast lookup.
-   * This container is the authoritative source for all active windows.
-   */
-  std::unordered_map<WindowId, std::shared_ptr<Window>> windows_;
+  // Window instances are tracked by WindowRegistry (see window_registry.h)
 
   /**
    * @brief Set up platform-specific event monitoring