AuroraRuntime/Source/IO/AuIOProcessorItem.cpp

/***
    Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: AuIOProcessorItem.cpp
    Date: 2022-6-6
    Author: Reece
***/
#include <Source/RuntimeInternal.hpp>
#include <Aurora/IO/IOExperimental.hpp>
#include "AuIOProcessorItem.hpp"
#include "AuIOProcessor.hpp"

namespace Aurora::IO
{
    bool IOProcessorItem::StopWatch()
    {
        if (!this->pParent)
        {
            return false;
        }

        if (this->pParent->CheckThread() &&
            this->pParent->bFrameStart)
        {
            this->pParent->ClearProcessor(AuSharedFromThis(), false);
            return true;
        }

        return this->pParent->items.ScheduleFinish(AuSharedFromThis(), false);
    }

    bool IOProcessorItem::FailWatch()
    {
        if (!this->pParent)
        {
            return false;
        }

        if (this->pParent->CheckThread() &&
            this->pParent->bFrameStart)
        {
            this->pParent->ClearProcessor(AuSharedFromThis(), true);
            return false;
        }

        return this->pParent->items.ScheduleFinish(AuSharedFromThis(), true);
    }

    bool IOProcessorItem::OnFinished(const AuSPtr<AuLoop::ILoopSource>& source, AuUInt8 pos)
    {
        if (!this->pParent)
        {
            return true;
        }

        if (this->bSingleshot)
        {
            if (AuExchange(this->bTriggered, true))
            {
                StopWatch();
                return false;
            }
        }

        IOAlert(false);
        return this->bSingleshot;
    }

    void IOProcessorItem::OnTimeout(const AuSPtr<AuLoop::ILoopSource>& source)
    {
        SysPushErrorIO("IO Timeout");
        this->FailWatch();
    }

    void IOProcessorItem::InvokeManualTick()
    {
        IOAlert(true);
    }

    void IOProcessorItem::IOAlert(bool force)
    {
        if (!this->pParent)
        {
            return;
        }

        if (!this->pParent->IsTickOnly())
        {
            bool bForceTick {};
            if (!this->pParent->bFrameStart ||
                (bForceTick = this->pParent->bNoDeferredTick))
            {
                if (force || bForceTick)
                {
                    this->pParent->TickFor(AuSharedFromThis());
                }
                else
                {
                    this->pParent->TickForHack(AuSharedFromThis());
                }
            }
            else
            {
                this->pParent->TickForRegister(AuSharedFromThis());
            }
        }
        else if (force) // manual tick
        {
            if (this->pParent->CheckThread())
            {
                this->pParent->TickFor(AuSharedFromThis());
            }
            else if (this->pParent->IsAsync())
            {
                // TODO:
            }
            else
            {
                SysPanic("Missing");
            }
        }

        if (this->bSingleshot)
        {
            StopWatch();
        }
    }

    void IOProcessorItem::Finalize()
    {
        AuResetMember(this->pItem);
        AuResetMember(this->pListener);
    }
}