resource.cpp

Go to the documentation of this file.

 
#include <processes/resources/resource.h>
 
#include "processes/resources/scheduler_resources.h"
 
using namespace MaxOS;
using namespace MaxOS::processes;
using namespace MaxOS::processes::resources;
 
BaseResourceRegistry::BaseResourceRegistry(resource_type_t type)
: m_type(type)
{
    GlobalResourceRegistry::add_registry(type, this);
}
 
BaseResourceRegistry::~BaseResourceRegistry(){
 
    GlobalResourceRegistry::remove_registry(this);
}
 
resource_type_t BaseResourceRegistry::type() {
 
    return m_type;
}
 
Resource* BaseResourceRegistry::get_resource(string const& name) {
 
    m_lock.lock();
 
    // Resource isn't stored in this registry
    if(m_resources.find(name) == m_resources.end()) {
        m_lock.unlock();
        return nullptr;
    }
 
    // Increment the use count of the resource and return it
    m_resource_uses[name]++;
    auto resource = m_resources[name];
 
    m_lock.unlock();
    return resource;
}
 
bool BaseResourceRegistry::register_resource(Resource* resource) {
 
    m_lock.lock();
 
    // Resource name is already stored in this registry
    if(m_resources.find(resource->name()) != m_resources.end()) {
        m_lock.unlock();
        return false;
    }
 
    m_resources.insert(resource->name(), resource);
    m_resource_uses.insert(resource->name(), 0);
 
    m_lock.unlock();
    return true;
}
 
 
void BaseResourceRegistry::close_resource(Resource* resource, size_t flags) {
 
    m_lock.lock();
 
    // Resource isn't stored in this registry
    if(m_resources.find(resource->name()) == m_resources.end()) {
        m_lock.unlock();
        return;
    }
 
    m_resource_uses[resource->name()]--;
 
    // Don't close a resource that has more processes using it
    if(m_resource_uses[resource->name()]) {
        m_lock.unlock();
        return;
    }
 
    // Can safely close the resource
    resource->close(flags);
    m_resources.erase(resource->name());
    m_resource_uses.erase(resource->name());
 
    m_lock.unlock();
    delete resource;
}
 
Resource* BaseResourceRegistry::create_resource(string const& name, size_t flags, uintptr_t data) {
    return nullptr;
}
 
GlobalResourceRegistry::GlobalResourceRegistry() {
    s_current = this;
 
}
 
GlobalResourceRegistry::~GlobalResourceRegistry() {
    if(s_current == this)
        s_current = nullptr;
 
}
 
BaseResourceRegistry* GlobalResourceRegistry::get_registry(resource_type_t type) {
 
    auto registry = s_current->m_registries.find(type);
    if(registry == s_current->m_registries.end())
        return nullptr;
 
    return registry->second;
}
 
void GlobalResourceRegistry::add_registry(resource_type_t type, BaseResourceRegistry* registry) {
 
    // Does it already exist?
    if(s_current->m_registries.find(type) != s_current->m_registries.end())
        return;
 
    s_current->m_registries.insert(type, registry);
}
 
void GlobalResourceRegistry::remove_registry(BaseResourceRegistry* registry) {
 
    // Does it already exist?
    if(s_current->m_registries.find(registry->type()) == s_current->m_registries.end())
        return;
 
    s_current->m_registries.erase(registry->type());
 
}
 
ResourceManager::ResourceManager() = default;
 
ResourceManager::~ResourceManager(){
 
    // Collect all resources (as closing will break iteration)
    common::Vector<uint64_t> handles;
    for (const auto& kv : m_resources)
        handles.push_back(kv.first);
 
    // Close the resources
    for (auto h : handles)
        close_resource(h, 0);
 
}
 
common::Map<uint64_t, Resource*> ResourceManager::resources() {
 
    return m_resources;
}
 
uint64_t ResourceManager::open_resource(resource_type_t type, string const& name, size_t flags) {
 
    // Make sure there is a registry of the requested type
    auto registry = GlobalResourceRegistry::get_registry(type);
    if(!registry)
        return 0;
 
    // Make sure the registry holds the requested resource
    auto resource = registry -> get_resource(name);
    if(!resource)
        return 0;
 
    // Store it
    m_resources.insert(m_next_handle, resource);
 
    // Open it
    resource->open(flags);
    return m_next_handle++;
}
 
void ResourceManager::close_resource(uint64_t handle, size_t flags) {
 
    auto it = m_resources.find(handle);
    if(it == m_resources.end())
        return;
 
    // Remove it
    Resource* resource = it->second;
    m_resources.erase(handle);
 
    // Close it
    GlobalResourceRegistry::get_registry(resource->type()) -> close_resource(resource, flags);
}
 
Resource* ResourceManager::get_resource(uint64_t handle) {
 
    if(m_resources.find(handle) == m_resources.end())
        return nullptr;
 
    return m_resources[handle];
}
 
Resource* ResourceManager::get_resource(string const& name) {
 
    for(const auto& resource : m_resources)
        if(resource.second->name() == name)
            return resource.second;
 
    return nullptr;
}