access.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 XCENA Inc.
 
#pragma once
 
#include <cstddef>
#include <type_traits>
 
namespace mu
{
 
namespace detail
{
 
struct input_buffer_direction
{
    static constexpr bool reads_existing_data = true;
    static constexpr bool writes_result = false;
};
 
struct output_buffer_direction
{
    static constexpr bool reads_existing_data = false;
    static constexpr bool writes_result = true;
};
 
}  // namespace detail
 
template <typename T>
class input_ptr
{
    static_assert(!std::is_void_v<T>, "input_ptr<void> is not supported");
    static_assert(!std::is_const_v<T>, "input_ptr adds const access itself");
    static_assert(!std::is_function_v<T>, "input_ptr cannot point to a function");
 
public:
    using element_type = T;
    using kernel_buffer_direction = detail::input_buffer_direction;
    using pointer = const T*;
 
    constexpr input_ptr() noexcept = default;
    constexpr input_ptr(const T* ptr) noexcept
        : ptr_(ptr)
    {
    }
 
    constexpr operator pointer() const noexcept
    {
        return ptr_;
    }
 
    [[nodiscard]] constexpr const T& operator*() const noexcept
    {
        return *ptr_;
    }
 
    [[nodiscard]] constexpr pointer operator->() const noexcept
    {
        return ptr_;
    }
 
    [[nodiscard]] constexpr const T& operator[](std::ptrdiff_t index) const noexcept
    {
        return ptr_[index];
    }
 
private:
    const T* ptr_ = nullptr;
};
 
template <typename T>
class output_ptr
{
    static_assert(!std::is_void_v<T>, "output_ptr<void> is not supported");
    static_assert(!std::is_const_v<T>, "output_ptr requires mutable elements");
    static_assert(!std::is_function_v<T>, "output_ptr cannot point to a function");
 
public:
    using element_type = T;
    using kernel_buffer_direction = detail::output_buffer_direction;
    using pointer = T*;
 
    constexpr output_ptr() noexcept = default;
    constexpr output_ptr(T* ptr) noexcept
        : ptr_(ptr)
    {
    }
 
    constexpr operator pointer() const noexcept
    {
        return ptr_;
    }
 
    [[nodiscard]] constexpr T& operator*() const noexcept
    {
        return *ptr_;
    }
 
    [[nodiscard]] constexpr pointer operator->() const noexcept
    {
        return ptr_;
    }
 
    [[nodiscard]] constexpr T& operator[](std::ptrdiff_t index) const noexcept
    {
        return ptr_[index];
    }
 
private:
    T* ptr_ = nullptr;
};
 
static_assert(std::is_trivially_copyable_v<input_ptr<int>>,
              "input_ptr must remain trivially copyable");
static_assert(std::is_standard_layout_v<input_ptr<int>>,
              "input_ptr must remain standard-layout");
static_assert(sizeof(input_ptr<int>) == sizeof(const int*),
              "input_ptr must remain pointer-sized");
static_assert(input_ptr<int>::kernel_buffer_direction::reads_existing_data);
static_assert(!input_ptr<int>::kernel_buffer_direction::writes_result);
static_assert(std::is_trivially_copyable_v<output_ptr<int>>,
              "output_ptr must remain trivially copyable");
static_assert(std::is_standard_layout_v<output_ptr<int>>,
              "output_ptr must remain standard-layout");
static_assert(sizeof(output_ptr<int>) == sizeof(int*),
              "output_ptr must remain pointer-sized");
static_assert(!output_ptr<int>::kernel_buffer_direction::reads_existing_data);
static_assert(output_ptr<int>::kernel_buffer_direction::writes_result);
 
}  // namespace mu