access.hpp

Go to the documentation of this file.

#pragma once
 
#include <co_ecs/component.hpp>
 
namespace co_ecs {
 
enum access_type {
    none, 
    read, 
    write 
};
 
class access_pattern_t {
public:
    access_pattern_t() = default;
 
    access_pattern_t(access_type registry_access) : _registry_access(registry_access) {
    }
 
    access_pattern_t(access_type access, component_meta meta) {
        _component_access.emplace(meta.id, access);
    }
 
    [[nodiscard]] auto allows(const access_pattern_t& other) const noexcept -> bool {
        if ((writes_all() && other.reads_all()) || (reads_all() && !other.reads_all())) {
            return false;
        }
 
        for (auto [component_id, access] : _component_access) {
            if ((access == access_type::write && other.reads(component_id)) || other.writes(component_id)) {
                return false;
            }
        }
 
        return true;
    }
 
    [[nodiscard]] auto writes_all() const noexcept -> bool {
        return _registry_access == access_type::write;
    }
 
 
    [[nodiscard]] auto reads_all() const noexcept -> bool {
        return _registry_access != access_type::none;
    }
 
    [[nodiscard]] auto writes(component_id_t id) const noexcept -> bool {
        if (_registry_access == access_type::write) {
            return true;
        }
 
        if (auto iter = _component_access.find(id); iter != _component_access.end()) {
            auto [_, access] = *iter;
            if (access == access_type::write) {
                return true;
            }
        }
 
        return false;
    }
 
    [[nodiscard]] auto reads(component_id_t id) const noexcept -> bool {
        if (_registry_access != access_type::none) {
            return true;
        }
 
        if (auto iter = _component_access.find(id); iter != _component_access.end()) {
            return true;
        }
 
        return false;
    }
 
    auto operator&(const access_pattern_t& rhs) -> access_pattern_t {
        access_pattern_t res = *this;
        res &= rhs;
        return res;
    }
 
    auto operator&=(const access_pattern_t& rhs) -> access_pattern_t& {
        _registry_access = std::max(_registry_access, rhs._registry_access);
 
        for (auto [component_id, access] : rhs._component_access) {
            _component_access[component_id] = std::max(access, _component_access[component_id]);
        }
 
        return *this;
    }
 
private:
    access_type _registry_access{ access_type::none };
    detail::sparse_map<component_id_t, access_type> _component_access;
};
 
} // namespace co_ecs