resource.cpp

Go to the documentation of this file.

 
#include <processes/resource.h>
 
using namespace MaxOS;
using namespace MaxOS::processes;
 
Resource::Resource(const string& name, size_t flags, resource_type_t type)
: m_name(name),
  m_type(type)
{
 
}
 
Resource::~Resource() = default;
 
void Resource::open(size_t flags) {
 
}
 
 
void Resource::close(size_t flags) {
 
}
 
int Resource::read(void* buffer, size_t size, size_t flags) {
    return 0;
}
 
int Resource::write(void const* buffer, size_t size, size_t flags) {
 
    return 0;
}
 
string Resource::name() {
    return m_name;
}
 
resource_type_t Resource::type() {
 
    return m_type;
}
 
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) {
 
    // Resource isn't stored in this registry
    if(m_resources.find(name) == m_resources.end())
        return nullptr;
 
    // Increment the use count of the resource and return it
    m_resource_uses[name]++;
    return m_resources[name];
 
}
 
bool BaseResourceRegistry::register_resource(Resource* resource) {
 
    // Resource name is already stored in this registry
    if(m_resources.find(resource->name()) != m_resources.end())
        return false;
 
    m_resources.insert(resource->name(), resource);
    m_resource_uses.insert(resource->name(), 0);
    return true;
}
 
 
void BaseResourceRegistry::close_resource(Resource* resource, size_t flags) {
 
    // Resource isn't stored in this registry
    if(m_resources.find(resource->name()) == m_resources.end())
        return;
 
    m_resource_uses[resource->name()]--;
 
    // Don't close a resource that has more processes using it
    if(m_resource_uses[resource->name()])
        return;
 
    // Can safely close the resource
    resource->close(flags);
    m_resources.erase(resource->name());
    m_resource_uses.erase(resource->name());
    delete resource;
}
 
Resource* BaseResourceRegistry::create_resource(string const& name, size_t flags) {
    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) {
 
    // Get the resource
    auto resource = GlobalResourceRegistry::get_registry(type) -> 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;
}