1 files changed, 19 insertions, 31 deletions

diff --git a/src/HandlerManager.cpp b/src/HandlerManager.cpp
index cb3b723..505b393 100644
--- a/src/HandlerManager.cpp
+++ b/src/HandlerManager.cpp
@@ -5,44 +5,34 @@
 #include "NamespaceReferenceManager.h"
 #include "PermissionsManager.h"
 
-namespace nt
-{
-    void HandlerManager::DeallocateHandle(struct handle* handle)
-    {
+namespace nt {
+    void HandlerManager::DeallocateHandle(struct handle* handle) {
         delete handle;
     }
 
-    HandlerManager::HandlerManager(ObjectManager& objects,
-                                       PermissionsManager& permissions,
-                                       IdentityManager& identities,
-                                       LifecycleManager& lifecycles,
-                                       NamespaceReferenceManager& references)
-        : objects_(objects)
-        , permissions_(permissions)
-        , identities_(identities)
-        , lifecycles_(lifecycles)
-        , references_(references)
-    {}
+    HandlerManager::HandlerManager(ObjectManager& objects, PermissionsManager& permissions,
+                                   IdentityManager& identities, LifecycleManager& lifecycles,
+                                   NamespaceReferenceManager& references)
+        : objects_(objects), permissions_(permissions), identities_(identities),
+          lifecycles_(lifecycles), references_(references) {
+    }
 
-    struct HandlerManager::handle* HandlerManager::Open(std::vector<std::string> object_path, void* connection_context)
-    {
+    struct HandlerManager::handle* HandlerManager::Open(std::vector<std::string> object_path,
+                                                        void* connection_context) {
         const auto resolved = references_.Resolve(std::move(object_path));
         ObjectManager::registry* retrieved_object = objects_.Find(resolved);
-        if (permissions_.Access(retrieved_object, (const void*)connection_context)
-            && identities_.CanOpen(retrieved_object)
-            && lifecycles_.Contention(retrieved_object)) {
+        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);
-            return new handle{ retrieved_object, connection_context }; // Return a successful handle
-        }
-        else {
+            return new handle{retrieved_object, connection_context}; // Return a successful handle
+        } else {
             // Return something more algebraic instead of null or an int
             return nullptr;
         };
     }
 
-    bool HandlerManager::Close(struct handle* handle)
-    {
+    bool HandlerManager::Close(struct handle* handle) {
         if (handle == nullptr) {
             return false;
         }
@@ -51,21 +41,19 @@ namespace nt
         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.
             //&& lifecycles_.Contention(object)
-            ) {
+        ) {
             // Stops monitoring this guy
             lifecycles_.Unmonitor(object);
             DeallocateHandle(handle);
             return true; // Return a successful handle
-        }
-        else {
+        } else {
             // Return something more algebraic instead of null or an int.
             // It's kinda bad to not even report what went wrong.
             return false;
         };
     }
-}
+} // namespace nt