optional_storage.hpp

Go to the documentation of this file.

#ifndef KOKKOS_EXECUTION_IMPL_OPTIONAL_STORAGE_HPP
#define KOKKOS_EXECUTION_IMPL_OPTIONAL_STORAGE_HPP
 
#include "kokkos-execution/stdexec.hpp"
 
#include "Kokkos_Macros.hpp"
#ifdef KOKKOS_ENABLE_EXPERIMENTAL_CXX20_MODULES
import kokkos.core;
#    include "Kokkos_Assert.hpp"
#else
#    include "Kokkos_Core.hpp"
#endif
 
namespace Kokkos::Execution::Impl {

template <typename T>
class OptionalStorage {
   public:
    constexpr OptionalStorage() noexcept = default;
 
    constexpr ~OptionalStorage() {
        if (m_has_value) {
            m_storage.__destroy();
        }
    }
 
    OptionalStorage(const OptionalStorage&) = delete;
    OptionalStorage(OptionalStorage&&) = delete;
    OptionalStorage& operator=(const OptionalStorage&) = delete;
    OptionalStorage& operator=(OptionalStorage&&) = delete;
 
    template <typename... Args>
    constexpr auto emplace(Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Args...>) -> T& {
        KOKKOS_ASSERT(!m_has_value);
        auto& ref = m_storage.__construct(std::forward<Args>(args)...);
        m_has_value = true;
        return ref;
    }
 
    template <typename Func, typename... Args>
    constexpr auto emplace_from(Func&& func, Args&&... args)
        noexcept(noexcept(T{std::forward<Func>(func)(std::forward<Args>(args)...)})) -> T& {
        KOKKOS_ASSERT(!m_has_value);
        auto& ref = m_storage.__construct_from(std::forward<Func>(func), std::forward<Args>(args)...);
        m_has_value = true;
        return ref;
    }
 
    constexpr void reset() noexcept {
        KOKKOS_ASSERT(m_has_value);
        m_storage.__destroy();
        m_has_value = false;
    }
 
    constexpr auto get() & noexcept -> T& {
        KOKKOS_ASSERT(m_has_value);
        return m_storage.__get();
    }
 
    constexpr auto get() const & noexcept -> const T& {
        KOKKOS_ASSERT(m_has_value);
        return m_storage.__get();
    }
 
    constexpr auto get() && noexcept -> T&& {
        KOKKOS_ASSERT(m_has_value);
        return std::move(m_storage.__get());
    }
 
    constexpr auto get() const && noexcept -> const T&& = delete;
 
    constexpr auto operator->() noexcept -> T* {
        KOKKOS_ASSERT(m_has_value);
        return m_storage.operator->();
    }
 
    constexpr auto operator->() const noexcept -> const T* {
        KOKKOS_ASSERT(m_has_value);
        return m_storage.operator->();
    }
 
    constexpr explicit operator bool() const noexcept {
        return m_has_value;
    }
 
    constexpr bool has_value() const noexcept {
        return m_has_value;
    }
 
   private:
    stdexec::__manual_lifetime<T> m_storage{};
    bool m_has_value{false};
};
 
} // namespace Kokkos::Execution::Impl
 
#endif // KOKKOS_EXECUTION_IMPL_OPTIONAL_STORAGE_HPP