resource.h

Go to the documentation of this file.

 
#ifndef MAXOS_PROCESSES_RESOURCES_RESOURCE_H
#define MAXOS_PROCESSES_RESOURCES_RESOURCE_H
 
#include <cstddef>
 
#include <libcommon/map.h>
#include <libcommon/vector.h>
#include <libcommon/string.h>
#include <libcommon/mem.h>
#include <libkpi/syscalls.h>
#include <libkpi/resource.h>
 
#include <common/logger.h>
 
namespace MaxOS::processes::resources {
 
    typedef KPI::ResourceType resource_type_t;  
    typedef KPI::Resource Resource;             
 
    class BaseResourceRegistry {
 
        protected:
            common::Map<string, Resource*> m_resources;         
            common::Map<string, uint64_t> m_resource_uses;      
 
            common::Spinlock m_lock;                            
 
            resource_type_t m_type;                             
 
        public:
            explicit BaseResourceRegistry(resource_type_t type);
            ~BaseResourceRegistry();
 
            resource_type_t type();
 
            bool register_resource(Resource* resource);
            void close_resource(Resource* resource, size_t flags);
 
            virtual Resource* get_resource(const string& name);
            virtual Resource* create_resource(const string& name, size_t flags, uintptr_t data);
    };
 
    template<class Type> class ResourceRegistry : public BaseResourceRegistry {
 
        public:
            explicit ResourceRegistry(resource_type_t type);
            ~ResourceRegistry() = default;
 
            Resource* create_resource(const string& name, size_t flags, uintptr_t data) override {
 
                auto resource = new Type(name, flags, type());
 
                // Creation failed
                if(!register_resource(resource)) {
                    delete resource;
                    return nullptr;
                }
 
                return resource;
            }
    };
 
    template<class Type> ResourceRegistry<Type>::ResourceRegistry(resource_type_t type)
            :BaseResourceRegistry(type) { }
 
    class GlobalResourceRegistry {
 
        private:
            common::Map<resource_type_t, BaseResourceRegistry*> m_registries;
            inline static GlobalResourceRegistry* s_current;
 
        public:
            GlobalResourceRegistry();
            ~GlobalResourceRegistry();
 
            static BaseResourceRegistry* get_registry(resource_type_t type);
 
            static void add_registry(resource_type_t type, BaseResourceRegistry* registry);
            static void remove_registry(BaseResourceRegistry* registry);
    };
 
    class ResourceManager {
 
        private:
            common::Map<uint64_t, Resource*> m_resources;
 
            uint64_t m_next_handle = 1;
 
        public:
            ResourceManager();
            ~ResourceManager();
 
            common::Map<uint64_t, Resource*> resources();
 
            uint64_t open_resource(resource_type_t type, const string& name, size_t flags);
            void close_resource(uint64_t handle, size_t flags);
 
            Resource* get_resource(uint64_t handle);
            Resource* get_resource(const string& name);
    };
}
 
 
#endif //MAXOS_PROCESSES_RESOURCES_RESOURCE_H