mgl_task_node.h

[詳解]

// SPDX-License-Identifier: Zlib
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
 
#ifndef INCGUARD_MGL_TASK_NODE_H_1622533593
#define INCGUARD_MGL_TASK_NODE_H_1622533593
 
#include <mgl/task/mgl_task_defs.h>
 
namespace MGL::Task
{
class Node
{
public:
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr Node(Identifier identifier) noexcept
        : _identifier(identifier)
    {
    }
 
    virtual ~Node() = default;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr Identifier GetIdentifier() const noexcept
    {
        return _identifier;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void Kill() noexcept
    {
        _isRequestedKill = true;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsRequestedKill() const noexcept
    {
        return _isRequestedKill;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetResideLevel(ResideLevel resideLevel) noexcept
    {
        _resideLevel = resideLevel;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr ResideLevel GetResideLevel() const noexcept
    {
        return _resideLevel;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsResident() const noexcept
    {
        return _resideLevel > ResideLevel::NoResident;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <typename TaskIDType>
    constexpr void SetAsynchronous(bool isEnabled, TaskIDType barrierIdentifier = TaskIDType()) noexcept
    {
        _isAsynchronous = isEnabled;
        _barrierIdentifier = Identifier(barrierIdentifier);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsEnabledAsynchronous() const noexcept
    {
        return _isAsynchronous;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <typename TaskIDType = Identifier>
    [[nodiscard]] constexpr TaskIDType GetBarrierIdentifier() const noexcept
    {
        return TaskIDType(_barrierIdentifier);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool IsEnabledBarrier() const noexcept
    {
        return _barrierIdentifier > _identifier;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    virtual void OnInitialize() noexcept
    {
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <typename EventIDType>
    void NotifyEvent(EventIDType event, void *argument) noexcept
    {
        OnReceiveTaskEvent(EventIdentifier(event), argument);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    virtual void OnExecute(ExecuteStage stage) noexcept = 0;
 
 
protected:
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    virtual void OnReceiveTaskEvent(EventIdentifier eventID, void *argument) noexcept
    {
        (void)eventID;
        (void)argument;
    }
 
private:
    Identifier _identifier{0};
    ResideLevel _resideLevel{ResideLevel::NoResident};
    bool _isRequestedKill{false};
    bool _isAsynchronous{false};
    Identifier _barrierIdentifier{0};
};
}    // namespace MGL::Task
 
#endif    // INCGUARD_MGL_TASK_NODE_H_1622533593
 
// vim: et ts=4 sw=4 sts=4