SlotManager.h

Go to the documentation of this file.

#pragma once
 
#include "cdc_core/IModule.h"
#include "cdc_core/TropicStorage.h"
#include <cstdint>
#include <cstring>
#include <memory>
#include <new>
 
namespace cdc::core {

class SlotManager {
public:
    void setSlotRange(uint16_t start, uint16_t end, uint8_t moduleId) {
        if (start > end || start == 0 || end == 0) {
            hasSlotRange_ = false;
            rmemStart_ = 0;
            rmemEnd_ = 0;
            moduleId_ = 0;
            return;
        }
        hasSlotRange_ = true;
        rmemStart_ = start;
        rmemEnd_ = end;
        moduleId_ = moduleId;
    }

    void setSlotRange(const IModule::SlotRange& range) {
        if (!range.hasRmem) {
            setSlotRange(0, 0, 0);
            return;
        }
        setSlotRange(range.rmemStart, range.rmemEnd, range.moduleId);
    }

    uint16_t capacity() const {
        if (!hasSlotRange_) return 0;
        return static_cast<uint16_t>(rmemEnd_ - rmemStart_ + 1);
    }

    bool toPhysicalSlot(uint16_t logicalIndex, uint16_t* slotOut) const {
        if (!slotOut) return false;
        if (!hasSlotRange_) return false;
        uint32_t slot = static_cast<uint32_t>(rmemStart_) + logicalIndex;
        if (slot > rmemEnd_) return false;
        *slotOut = static_cast<uint16_t>(slot);
        return true;
    }

    bool toLogicalSlot(uint16_t slot, uint16_t* logicalIndexOut) const {
        if (!logicalIndexOut) return false;
        if (!hasSlotRange_) return false;
        if (slot < rmemStart_ || slot > rmemEnd_) return false;
        *logicalIndexOut = static_cast<uint16_t>(slot - rmemStart_);
        return true;
    }

    bool findFreeSlot(uint16_t* slotOut) const {
        if (!slotOut) return false;
        if (!hasSlotRange_) return false;
 
        uint16_t cap = capacity();
        if (cap == 0) return false;
        auto used = std::unique_ptr<bool[]>(new (std::nothrow) bool[cap]);
        if (!used) return false;
        std::memset(used.get(), 0, cap * sizeof(bool));
 
        struct Ctx {
            bool* used;
            uint16_t base;
            uint16_t cap;
        } ctx = { used.get(), rmemStart_, cap };
 
        auto cb = [](uint16_t slot, const TropicStorage::CacheEntry&, void* user) {
            auto* c = static_cast<Ctx*>(user);
            if (slot < c->base) return;
            uint16_t idx = slot - c->base;
            if (idx < c->cap) {
                c->used[idx] = true;
            }
        };
 
        TropicStorage::instance().forEachSlot(
            moduleId_, rmemStart_, rmemEnd_, cb, &ctx);
 
        for (uint16_t i = 0; i < cap; i++) {
            if (!used[i]) {
                uint16_t candidate = static_cast<uint16_t>(rmemStart_ + i);
                if (candidate <= rmemEnd_) {
                    *slotOut = candidate;
                    return true;
                }
                return false;
            }
        }
 
        return false;
    }

    bool hasSlotRange() const { return hasSlotRange_; }

    uint16_t rmemStart() const { return rmemStart_; }

    uint16_t rmemEnd() const { return rmemEnd_; }

    uint8_t moduleId() const { return moduleId_; }
 
protected:
    bool hasSlotRange_ = false;
    uint16_t rmemStart_ = 0;
    uint16_t rmemEnd_ = 0;
    uint8_t moduleId_ = 0;
};
 
} // namespace cdc::core