shm_array.h

Go to the documentation of this file.

 
#pragma once
#include "posix_shm.h"
#include "shm_span.h"
#include "shm_table.h"
#include <stdexcept>
#include <algorithm>
#include <concepts>
#include <span>
#include <string_view>
#include <iterator>
 
template <typename T, typename TableType = shm_table>
    requires std::is_trivially_copyable_v<T>
class shm_array : public shm_span<T, posix_shm_impl<TableType>>
{
private:
    const typename TableType::entry* _table_entry{nullptr};  
 
public:
    template<typename ShmType>
    shm_array(ShmType &shared_mem, std::string_view name, size_t count = 0)
        : shm_span<T, posix_shm_impl<TableType>>(shared_mem, 0, 0)
    {
        static_assert(std::is_same_v<typename ShmType::table_type, TableType>,
                      "SharedMemory table type must match array table type");
        initialize(name, count);
    }
 
    void initialize(std::string_view name, size_t count = 0)
    {
        auto *table = static_cast<TableType *>(this->shm.get_base_addr());
        
        // Convert string_view to null-terminated string for find
        char name_buf[TableType::MAX_NAME_SIZE]{};
        size_t copy_len = std::min(name.size(), sizeof(name_buf) - 1);
        std::copy_n(name.begin(), copy_len, name_buf);
        
        auto *entry = table->find(name_buf);
 
        if (entry)
        {
            // Open existing array
            if (count != 0 && entry->num_elem != count)
            {
                throw std::runtime_error("Mismatch in array size");
            }
            this->offset = entry->offset;  // Keep as byte offset
            this->num_elem = entry->num_elem;
            _table_entry = entry;
        }
        else if (count > 0)
        {
            // Create new array
            size_t required_size = count * sizeof(T);
            size_t current_used = table->get_total_allocated_size();
            // get_total_size() already excludes the header (which includes the table)
            size_t available_size = this->shm.get_total_size() - current_used;
            
            if (required_size > available_size)
            {
                throw std::runtime_error("Not enough space in shared memory");
            }
            
            // Data must come after the table
            size_t byte_offset = sizeof(TableType) + current_used;
            this->offset = byte_offset;  // Keep as byte offset
            this->num_elem = count;
            
            if (!table->add(name_buf, byte_offset, required_size, sizeof(T), count))
            {
                throw std::runtime_error("Failed to add array to table");
            }
            // Find the entry we just added to get a pointer to it
            _table_entry = table->find(name_buf);
        }
        else
        {
            throw std::runtime_error("Array not found and size not specified");
        }
    }
 
    [[nodiscard]] T &at(size_t pos)
    {
        if (pos >= this->num_elem)
        {
            throw std::out_of_range("Array index out of range");
        }
        return (*this)[pos];
    }
 
    [[nodiscard]] const T &at(size_t pos) const
    {
        if (pos >= this->num_elem)
        {
            throw std::out_of_range("Array index out of range");
        }
        return (*this)[pos];
    }
 
    [[nodiscard]] T &front() { return *this->data(); }
    
    [[nodiscard]] const T &front() const { return *this->data(); }
 
    [[nodiscard]] T &back() { return *(this->data() + this->num_elem - 1); }
    
    [[nodiscard]] const T &back() const { return *(this->data() + this->num_elem - 1); }
 
    [[nodiscard]] bool empty() const noexcept { return this->num_elem == 0; }
    
    [[nodiscard]] size_t size() const noexcept { return this->num_elem; }
 
    void fill(const T &value)
    {
        std::fill_n(this->data(), this->num_elem, value);
    }
 
    [[nodiscard]] std::span<T> as_span() noexcept
    {
        return std::span<T>(this->data(), this->num_elem);
    }
 
    [[nodiscard]] std::span<const T> as_span() const noexcept
    {
        return std::span<const T>(this->data(), this->num_elem);
    }
 
    using value_type = T;                                    
    using size_type = size_t;                               
    using difference_type = std::ptrdiff_t;                 
    using reference = T&;                                   
    using const_reference = const T&;                       
    using pointer = T*;                                     
    using const_pointer = const T*;                         
    using iterator = T*;                                     
    using const_iterator = const T*;                        
    using reverse_iterator = std::reverse_iterator<iterator>; 
    using const_reverse_iterator = std::reverse_iterator<const_iterator>; 
    
    
    [[nodiscard]] iterator begin() noexcept { return this->data(); }
    
    [[nodiscard]] iterator end() noexcept { return this->data() + this->num_elem; }
    
    [[nodiscard]] const_iterator begin() const noexcept { return this->data(); }
    
    [[nodiscard]] const_iterator end() const noexcept { return this->data() + this->num_elem; }
    
    [[nodiscard]] const_iterator cbegin() const noexcept { return begin(); }
    
    [[nodiscard]] const_iterator cend() const noexcept { return end(); }
    
    
    [[nodiscard]] reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
    
    [[nodiscard]] reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
    
    [[nodiscard]] const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
    
    [[nodiscard]] const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
    
    [[nodiscard]] const_reverse_iterator crbegin() const noexcept { return rbegin(); }
    
    [[nodiscard]] const_reverse_iterator crend() const noexcept { return rend(); }
    
    [[nodiscard]] size_type max_size() const noexcept { return this->num_elem; }
    
    [[nodiscard]] pointer data() noexcept { return shm_span<T, posix_shm_impl<TableType>>::data(); }
    
    [[nodiscard]] const_pointer data() const noexcept { return shm_span<T, posix_shm_impl<TableType>>::data(); }
 
    [[nodiscard]] std::string_view name() const noexcept { 
        return _table_entry ? std::string_view(_table_entry->name.data()) : std::string_view{};
    }
};