ObjectManager.h

Go to the documentation of this file.

#pragma once
 
#include "Api.h"
#include "Types.h"
 
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>

 
namespace nt {
    class ObjectManager {
      public:
        class IObject {
          public:
            virtual ~IObject() = default;
        };

        class Multigroup : public IObject {
          public:
            std::string merkle_root;
        };

        class Relation : public IObject {
          public:
            std::string merkle_root;
        };

        class EphemeralRelation : public IObject {
          public:
            std::string merkle_root;
            std::vector<std::string> dependencies;
        };

        class Transaction : public IObject {};

        class Session : public IObject {
          public:
            void* connection_context = nullptr;
            std::map<std::string, std::string> branch_overrides;
        };

        class Branch : public IObject {
          public:
            std::string name;
            std::string target_hash;
        };

        class BranchTree : public IObject {
          public:
            std::string merkle_root;
        };

        struct object_type {
            OBJECT_TYPE label;
            bool disposable;
            std::set<METHOD> methods;
            bool exclusive = false;
 
            virtual ~object_type() = default;
        };

        struct ephemeral_object_type : object_type {
            enum class Cardinality { Finite, ConstrainedFinite, AlephZero, Continuum };

            using Generator = std::function<std::vector<Tuple>(
                const std::vector<std::string>& args, std::size_t offset, std::size_t limit)>;
 
            Cardinality cardinality;
            Generator generator;
        };

        struct registry_head {
            uint32_t reference_count = 0;
            uint32_t handle_count = 0;
            std::unique_ptr<object_type> type;
            std::vector<std::string> path;
        };

        struct registry {
            std::unique_ptr<registry_head> head;
            std::unique_ptr<IObject> object;
            std::unique_ptr<registry> next;
        };

        std::unique_ptr<registry> entries;

        void Register(std::vector<std::string> path, std::unique_ptr<IObject> object,
                      std::unique_ptr<object_type> type);

        registry* Find(const std::vector<std::string> object_path);

        bool Unregister(const std::vector<std::string>& object_path);
    };
} // namespace nt