fixed_array.hpp

Go to the documentation of this file.

#ifndef SBL_PRIMITIVES_CONTAINERS_FIXED_ARRAY_HPP_
#define SBL_PRIMITIVES_CONTAINERS_FIXED_ARRAY_HPP_
 
/**
 * @file fixed_array.hpp
 * @brief Fixed-size array wrapper for ARM Cortex-M systems
 * @ingroup primitives
 * 
 * Provides std::array-like functionality for ARM Cortex-M platforms
 * that may not have full STL support. All storage is statically
 * allocated with zero dynamic memory usage.
 */
 
#include <cstdint>
 
namespace sbl {
namespace primitives {
namespace containers {
 
/**
 * @brief Fixed-size array container
 * 
 * Lightweight array wrapper providing bounds-safe access and
 * iteration support. All storage is allocated at compile time.
 * 
 * @tparam T Element type
 * @tparam N Array size (must be greater than 0)
 */
template<typename T, size_t N>
class Array {
    static_assert(N > 0, "Array size must be greater than 0");
    
public:
    using value_type = T;
    using size_type = size_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*;
    
    /**
     * @brief Default constructor
     * 
     * Elements are default-initialized.
     */
    Array() = default;
    
    /**
     * @brief Fill constructor
     * 
     * @param value Value to fill array with
     */
    explicit Array(const T& value) {
        fill(value);
    }
    
    /**
     * @brief Access element at index
     * 
     * @param index Element index
     * @return Reference to element
     * 
     * @note No bounds checking in release builds for performance
     */
    reference operator[](size_type index) {
        return data_[index];
    }
    
    /**
     * @brief Access element at index (const)
     * 
     * @param index Element index
     * @return Const reference to element
     */
    const_reference operator[](size_type index) const {
        return data_[index];
    }
    
    /**
     * @brief Access element with bounds checking
     * 
     * @param index Element index
     * @return Reference to element
     * 
     * @note Returns first element if index out of bounds
     */
    reference at(size_type index) {
        return (index < N) ? data_[index] : data_[0];
    }
    
    /**
     * @brief Access element with bounds checking (const)
     * 
     * @param index Element index
     * @return Const reference to element
     */
    const_reference at(size_type index) const {
        return (index < N) ? data_[index] : data_[0];
    }
    
    /**
     * @brief Access first element
     * 
     * @return Reference to first element
     */
    reference front() {
        return data_[0];
    }
    
    /**
     * @brief Access first element (const)
     * 
     * @return Const reference to first element
     */
    const_reference front() const {
        return data_[0];
    }
    
    /**
     * @brief Access last element
     * 
     * @return Reference to last element
     */
    reference back() {
        return data_[N - 1];
    }
    
    /**
     * @brief Access last element (const)
     * 
     * @return Const reference to last element
     */
    const_reference back() const {
        return data_[N - 1];
    }
    
    /**
     * @brief Get pointer to underlying array
     * 
     * @return Pointer to first element
     */
    pointer data() {
        return data_;
    }
    
    /**
     * @brief Get pointer to underlying array (const)
     * 
     * @return Const pointer to first element
     */
    const_pointer data() const {
        return data_;
    }
    
    /**
     * @brief Get iterator to beginning
     * 
     * @return Iterator to first element
     */
    iterator begin() {
        return data_;
    }
    
    /**
     * @brief Get iterator to beginning (const)
     * 
     * @return Const iterator to first element
     */
    const_iterator begin() const {
        return data_;
    }
    
    /**
     * @brief Get iterator to end
     * 
     * @return Iterator past last element
     */
    iterator end() {
        return data_ + N;
    }
    
    /**
     * @brief Get iterator to end (const)
     * 
     * @return Const iterator past last element
     */
    const_iterator end() const {
        return data_ + N;
    }
    
    /**
     * @brief Check if array is empty
     * 
     * @return Always false (fixed-size array is never empty)
     */
    constexpr bool empty() const {
        return false;
    }
    
    /**
     * @brief Get array size
     * 
     * @return Number of elements (N)
     */
    constexpr size_type size() const {
        return N;
    }
    
    /**
     * @brief Get maximum size
     * 
     * @return Maximum number of elements (same as size())
     */
    constexpr size_type max_size() const {
        return N;
    }
    
    /**
     * @brief Fill array with value
     * 
     * @param value Value to fill with
     */
    void fill(const T& value) {
        for (size_type i = 0; i < N; ++i) {
            data_[i] = value;
        }
    }
    
    /**
     * @brief Swap contents with another array
     * 
     * @param other Array to swap with
     */
    void swap(Array& other) {
        for (size_type i = 0; i < N; ++i) {
            T temp = data_[i];
            data_[i] = other.data_[i];
            other.data_[i] = temp;
        }
    }
    
private:
    T data_[N];
};
 
} // namespace containers
} // namespace primitives
} // namespace sbl
 
#endif // SBL_PRIMITIVES_CONTAINERS_FIXED_ARRAY_HPP_