restructure project

2 files changed, 0 insertions, 192 deletions

diff --git a/Runtime/NtContext.cpp b/Runtime/NtContext.cpp
deleted file mode 100644
index 248fdaf..0000000
--- a/Runtime/NtContext.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "pch.h"
-#include "Runtime/NtContext.h"
-
-namespace nt
-{
-    bool NtContext::IsRunning() const
-    {
-        return true;
-    }
-}
diff --git a/Runtime/NtContext.h b/Runtime/NtContext.h
deleted file mode 100644
index 4e28f9f..0000000
--- a/Runtime/NtContext.h
+++ /dev/null
@@ -1,182 +0,0 @@
-#pragma once
-#include <cstdint>
-#include <set>
-#include <vector>
-#include <string>
-
-#ifdef NT_EXPORTS
-#define NT_API __declspec(dllexport)
-#else
-#define NT_API __declspec(dllimport)
-#endif
-
-enum OBJECT_TYPE {
-    MULTIGROUP,
-    RELATION,
-    TUPLE,
-    ATTRIBUTE,
-    TRANSACTION
-};
-
-enum METHOD {
-    OPEN,
-    CLOSE,
-    PARSE, // To plug a secondary namespace
-    SECURITY
-};
-
-enum AUTH_CLAIM {
-    READ,
-    WRITE
-};
-
-enum AUTH_METHOD {
-    CERTIFICATE,
-    PLAIN_TEXT
-};
-
-namespace nt
-{
-    class NT_API ObjectManager
-    {
-    public:
-        class IObject {
-            virtual ~IObject() {}
-        };
-        class Multigroup : IObject {};
-        class Relation : IObject {};
-        class Tuple : IObject {};
-        class Transaction : IObject {};
-        struct object_type {
-            OBJECT_TYPE label;
-            // If the object is not durable. E.g.: TRANSACTION
-            bool disposable;
-            std::set<METHOD> methods;
-        };
-        struct registry_head {
-            uint32_t reference_count;
-            uint32_t handle_count;
-            struct object_type* type;
-            std::vector<std::string> path;
-            //security_descriptor to be added later, maybe also a set of labels
-        };
-        struct registry {
-            struct registry_head* head;
-            IObject object;
-            // TODO: Treat as a list for now, but ideally it's a tree
-            struct registry* next;
-        };
-        struct registry** registry;
-        // Looks into this registry and attempts to retrieve the entry
-        struct registry* Find(const std::vector<std::string> object_path){}
-    };
-
-    class NT_API PermissionsManager
-    {
-    public:
-        // For validating connections at login
-        std::set<AUTH_CLAIM> Firewall(AUTH_METHOD method) {}
-        // For validating permission to an object
-        const bool Access(const std::vector<std::string> object_path, const void* connection_context) {
-            // Checks the security descriptor on the head of the object we find in the ObjectManager::registry
-            // Then additionally check other metadata yet to be defined in the connection_context,
-            // like user group, policy, etc.
-            // Yet to decide if this should be summoned at every attempt to get ahold of an object,
-            // that might produce significant overhead. How can we solve this?
-        }
-    };
-
-    class NT_API NamespaceReferenceManager
-    {
-    };
-    
-    class NT_API CursorManager
-    {
-    };
-    
-    class NT_API IdentityManager
-    {
-    public:
-        // Looks into the methods of the object type and asserts if it can be opened
-        const bool CanOpen(struct ObjectManager::registry* object) {}
-    };
-
-    class NT_API LifecycleManager
-    {
-    public:
-        // If object is not being monitored already, monitors the lifecycle by updating the handle count.
-        // Maybe also look at the reference count and kill some categories of disposable objects no longer referenced by other objects, like transactions.
-        // Think of other use cases later.
-        void Monitor(struct ObjectManager::registry* object) {}
-        // Serializes contention for the change of a mutable reference.
-        // This can be used in, for example, the HEAD of a branch to serialize the access.
-        // If the object does not causes contention, like a relation (since they are immutable, just like multigroups, all snapshots)
-        // then just approve, as they do not cause any contention. Transactions also do not cause any, 
-        // the only things that do are mutable reference states in shared sessions,
-        // for example: the HEAD of a branch, namespace collisions (creating two branches with the same name, or two multigroups with the same name from the same state, etc),
-        // multi-branch atomic commits (which I wish to not have as it damages isolation), 
-        // garbage collection of old state (as in, we want to delete an old-enough history to save up space), etc.
-        const bool Contention(struct ObjectManager::registry* object){}
-        // The inverse of `Monitor`, stops monitoring.
-        // Maybe garbage collect here also if the counters goes to zero.
-        void Unmonitor(struct ObjectManager::registry* object) {}
-    };
-
-    class NT_API HandlerManager
-    {
-    public:
-        // This is supposed to represent an authorized access to a certain object in the registry
-        // This increases the handle count in the object manager
-        // We should consider adding on the object manager a vector of all the handles that refer to an object
-        struct handle {};
-        void DeallocateHandle(struct handle* handle) {}
-        struct handle Open(std::vector<std::string> object_path, void* connection_context) {
-            struct ObjectManager::registry* retrieved_object = ObjectManager::Find((const std::vector<std::string>)object_path);
-            if (PermissionsManager::Access(retrieved_object, (const void*)connection_context)
-                && IdentityManager::CanOpen(retrieved_object)
-                && LifecycleManager::Contention(retrieved_object)) {
-                // Starts monitoring this guy
-                LifecycleManager::Monitor(retrieved_object);
-                return {}; // Return a successful handle
-            }
-            else {
-                // Return something more algebraic instead of null or an int
-                return {};
-            };
-        }
-        bool Close(struct handle *handle) {
-            // Somehow grab the object pointer and connection (maybe drop it...) from the handle
-            struct 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 (PermissionsManager::Access(object, connection_context)
-                && IdentityManager::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)
-                ) {
-                // Stops monitoring this guy
-                LifecycleManager::Unmonitor(object);
-                DeallocateHandle(handle);
-                return true; // Return a successful handle
-            }
-            else {
-                // Return something more algebraic instead of null or an int.
-                // It's kinda bad to not even report what went wrong.
-                return false;
-            };
-        }
-    };
-
-    class NT_API WAM
-    {
-    };
-
-    class NT_API NT
-    {
-    public:
-        bool IsRunning() const;
-        void SimulateEntryCall() {};
-    };
-}