shm_table.h

Go to the documentation of this file.

#pragma once
#include <cstddef>
#include <string>
#include <array>
#include <cstring>
#include <optional>
#include <algorithm>
#include <string_view>
 
template<size_t MaxNameSize = 32, size_t MaxEntries = 64>
class shm_table_impl
{
public:
    static constexpr size_t MAX_NAME_SIZE = MaxNameSize;
    static constexpr size_t MAX_ENTRIES = MaxEntries;
 
    struct entry
    {
        std::array<char, MAX_NAME_SIZE> name{};
        size_t offset{0};
        size_t size{0};
        size_t elem_size{0};
        size_t num_elem{0};
        bool active{false};
    };
 
private:
    entry entries[MAX_ENTRIES]{};
    size_t total_allocated{0};
 
public:
    shm_table_impl() = default;
 
    bool add(const char* name, size_t offset, size_t size, 
             size_t elem_size = 0, size_t num_elem = 0)
    {
        if (find(name))
            return false;
 
        for (size_t i = 0; i < MAX_ENTRIES; ++i)
        {
            if (!entries[i].active)
            {
                auto &e = entries[i];
                std::strncpy(e.name.data(), name, MAX_NAME_SIZE - 1);
                e.name[MAX_NAME_SIZE - 1] = '\0';
                e.offset = offset;
                e.size = size;
                e.elem_size = elem_size;
                e.num_elem = num_elem;
                e.active = true;
                
                // Update total allocated
                size_t end_offset = offset + size - sizeof(*this);
                total_allocated = std::max(total_allocated, end_offset);
                
                return true;
            }
        }
        return false;
    }
 
    bool add(std::string_view name, size_t offset, size_t size,
             size_t elem_size = 0, size_t num_elem = 0)
    {
        char name_buf[MAX_NAME_SIZE]{};
        size_t copy_len = std::min(name.size(), sizeof(name_buf) - 1);
        std::copy_n(name.begin(), copy_len, name_buf);
        return add(name_buf, offset, size, elem_size, num_elem);
    }
 
    bool erase(const char* name)
    {
        for (size_t i = 0; i < MAX_ENTRIES; ++i)
        {
            if (entries[i].active && 
                std::strcmp(name, entries[i].name.data()) == 0)
            {
                entries[i].active = false;
                // Note: doesn't reclaim space, just marks as inactive
                return true;
            }
        }
        return false;
    }
 
    bool erase(std::string_view name)
    {
        char name_buf[MAX_NAME_SIZE]{};
        size_t copy_len = std::min(name.size(), sizeof(name_buf) - 1);
        std::copy_n(name.begin(), copy_len, name_buf);
        return erase(name_buf);
    }
 
    entry* find(const char* name)
    {
        for (size_t i = 0; i < MAX_ENTRIES; ++i)
        {
            if (entries[i].active && 
                std::strcmp(name, entries[i].name.data()) == 0)
            {
                return &entries[i];
            }
        }
        return nullptr;
    }
 
    const entry* find(const char* name) const
    {
        for (size_t i = 0; i < MAX_ENTRIES; ++i)
        {
            if (entries[i].active && 
                std::strcmp(name, entries[i].name.data()) == 0)
            {
                return &entries[i];
            }
        }
        return nullptr;
    }
 
    entry* find(std::string_view name)
    {
        char name_buf[MAX_NAME_SIZE]{};
        size_t copy_len = std::min(name.size(), sizeof(name_buf) - 1);
        std::copy_n(name.begin(), copy_len, name_buf);
        return find(name_buf);
    }
 
    const entry* find(std::string_view name) const
    {
        char name_buf[MAX_NAME_SIZE]{};
        size_t copy_len = std::min(name.size(), sizeof(name_buf) - 1);
        std::copy_n(name.begin(), copy_len, name_buf);
        return find(name_buf);
    }
 
    size_t get_total_allocated_size() const
    {
        return total_allocated;
    }
 
    size_t get_entry_count() const
    {
        size_t count = 0;
        for (size_t i = 0; i < MAX_ENTRIES; ++i)
        {
            if (entries[i].active)
                ++count;
        }
        return count;
    }
 
    void clear()
    {
        for (size_t i = 0; i < MAX_ENTRIES; ++i)
        {
            entries[i].active = false;
        }
        total_allocated = 0;
    }
 
    static constexpr size_t size_bytes() 
    {
        return sizeof(shm_table_impl<MaxNameSize, MaxEntries>);
    }
};
 
// Default table type for backward compatibility
using shm_table = shm_table_impl<32, 64>;
 
// Common alternative configurations
using shm_table_small = shm_table_impl<16, 16>;   // Minimal overhead
using shm_table_large = shm_table_impl<64, 256>;   // More entries, longer names
using shm_table_huge = shm_table_impl<256, 1024>;  // Maximum flexibility