From c375b1c69665ae7c16ffa3f17264386dfc257d8e Mon Sep 17 00:00:00 2001
From: Marcos Magueta <maguetamarcos@gmail.com>
Date: Sat, 9 May 2026 23:03:00 -0300
Subject: FOL VM with cursor mocked storage

---
 src/HandlerManager.cpp | 35 +++++++++++++++++++----------------
 1 file changed, 19 insertions(+), 16 deletions(-)

(limited to 'src/HandlerManager.cpp')

diff --git a/src/HandlerManager.cpp b/src/HandlerManager.cpp
index 7d7015d..8149ff2 100644
--- a/src/HandlerManager.cpp
+++ b/src/HandlerManager.cpp
@@ -11,18 +11,24 @@ namespace nt
         delete handle;
     }
 
+    HandlerManager::HandlerManager(ObjectManager& objects,
+                                       PermissionsManager& permissions,
+                                       IdentityManager& identities,
+                                       LifecycleManager& lifecycles)
+        : objects_(objects)
+        , permissions_(permissions)
+        , identities_(identities)
+        , lifecycles_(lifecycles)
+    {}
+
     struct HandlerManager::handle* HandlerManager::Open(std::vector<std::string> object_path, void* connection_context)
     {
-        ObjectManager objects;
-        PermissionsManager permissions;
-        IdentityManager identities;
-        LifecycleManager lifecycles;
-        ObjectManager::registry* retrieved_object = objects.Find((const std::vector<std::string>)object_path);
-        if (permissions.Access(retrieved_object, (const void*)connection_context)
-            && identities.CanOpen(retrieved_object)
-            && lifecycles.Contention(retrieved_object)) {
+        ObjectManager::registry* retrieved_object = objects_.Find((const std::vector<std::string>)object_path);
+        if (permissions_.Access(retrieved_object, (const void*)connection_context)
+            && identities_.CanOpen(retrieved_object)
+            && lifecycles_.Contention(retrieved_object)) {
             // Starts monitoring this guy
-            lifecycles.Monitor(retrieved_object);
+            lifecycles_.Monitor(retrieved_object);
             return new handle{ retrieved_object, connection_context }; // Return a successful handle
         }
         else {
@@ -36,22 +42,19 @@ namespace nt
         if (handle == nullptr) {
             return false;
         }
-        PermissionsManager permissions;
-        IdentityManager identities;
-        LifecycleManager lifecycles;
         // Somehow grab the object pointer and connection (maybe drop it...) from the handle
         ObjectManager::registry* object = handle->object;
         void* connection_context = handle->connection_context;
         // Checking for permissions here may be relevant.
         // What if we have a handle but no permission? Spooky
-        if (permissions.Access(object, connection_context)
-            && identities.CanClose(object)
+        if (permissions_.Access(object, connection_context)
+            && identities_.CanClose(object)
             // TODO: I think that in this case we do not need to worry about contention.
             // But be careful to evaluate this scenario later.
-            //&& LifecycleManager::Contention(retrieved_object)
+            //&& lifecycles_.Contention(object)
             ) {
             // Stops monitoring this guy
-            lifecycles.Unmonitor(object);
+            lifecycles_.Unmonitor(object);
             DeallocateHandle(handle);
             return true; // Return a successful handle
         }
-- 
cgit v1.2.3