AdjacencyRow.hpp

Go to the documentation of this file.

#pragma once
/// @file AdjacencyRow.hpp
/// @brief Non-owning row view for adjacency arrays.
 
#include "../Defines.hpp"
 
namespace DNDS
{
    /**
     * @brief Non-owning span `(pointer, size)` into an @ref DNDS::ArrayAdjacency "ArrayAdjacency" row.
     *
     * @details Serves as the return value of `ArrayAdjacency::operator[]`.
     * It is the "typed row handle" equivalent of `std::span<index_T>` with a
     * few DNDSR-specific conveniences:
     *  - indexing is bounds-checked in debug (@ref DNDS_assert);
     *  - assignment from / conversion to `std::vector<index>`;
     *  - device-callable accessors so kernels can walk adjacency rows.
     *
     * The span does not own the underlying storage; it must not outlive the
     * backing @ref DNDS::ArrayAdjacency "ArrayAdjacency".
     *
     * @tparam index_T  Either `DNDS::index` (mutable) or `const DNDS::index`.
     */
    template <typename index_T = index>
    class AdjacencyRow // instead of std::vector<index> for building on raw buffer as a "mapping" object
    {
        index_T *__p_indices;
        rowsize __Row_size;
 
    public:
        //! the copy is not trivial!
        // DNDS_DEVICE_TRIVIAL_COPY_DEFINE(AdjacencyRow, AdjacencyRow)
 
        DNDS_DEVICE_CALLABLE AdjacencyRow() = default;
        DNDS_DEVICE_CALLABLE AdjacencyRow(const AdjacencyRow &) = default;
        DNDS_DEVICE_CALLABLE ~AdjacencyRow() = default;
        /// @brief Construct a span from raw pointer and size.
        DNDS_DEVICE_CALLABLE AdjacencyRow(index_T *ptr, rowsize siz) : __p_indices(ptr), __Row_size(siz) {} // default actually
 
        /// @brief Bounds-checked (debug) element access.
        DNDS_DEVICE_CALLABLE index_T &operator[](rowsize j)
        {
            DNDS_assert(j >= 0 && j < __Row_size);
            return __p_indices[j];
        }
 
        DNDS_DEVICE_CALLABLE index_T operator[](rowsize j) const
        {
            DNDS_assert(j >= 0 && j < __Row_size);
            return __p_indices[j];
        }
 
        /// @brief Copy the row into a new `std::vector<index>`.
        operator std::vector<index>() const // copies to a new std::vector<index>
        {
            return {__p_indices, __p_indices + __Row_size};
        }
 
        /// @brief Overwrite the row from a vector of the same size.
        void operator=(const std::vector<index> &r)
        {
            DNDS_assert(__Row_size == r.size());
            std::copy(r.begin(), r.end(), __p_indices);
        }
 
        /// @brief Copy contents of another span (same size required).
        DNDS_DEVICE_CALLABLE void operator=(const AdjacencyRow &r)
        {
            DNDS_assert(__Row_size == r.size());
            std::copy(r.cbegin(), r.cend(), __p_indices);
        }
 
        DNDS_DEVICE_CALLABLE index_T *begin() { return __p_indices; }
        DNDS_DEVICE_CALLABLE index_T *end() { return __p_indices + __Row_size; } // past-end
        DNDS_DEVICE_CALLABLE index_T *cbegin() const { return __p_indices; }
        DNDS_DEVICE_CALLABLE index_T *cend() const { return __p_indices + __Row_size; } // past-end
        /// @brief Row width in number of `index_T` elements.
        DNDS_DEVICE_CALLABLE [[nodiscard]] rowsize size() const { return __Row_size; }
    };
}