AuroraRuntime/Include/Aurora/Async/IThreadPool.hpp

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

    File: IThreadPool.hpp
    Date: 2021-11-1
    Author: Reece
***/
#pragma once

namespace Aurora::Async
{
    struct IThreadPool
    {
        // Spawning
        virtual bool Spawn(WorkerId_t workerId)                                         = 0;

        // Event runner threads release the entire application upon encountering a zero work condition allowing for a clean exit of event driven apps without the headache of carefully chaining together exit callbacks
        // Applications that aren't designed around an event driven model should set runner to false to keep the around during global work exhaustion
        // tl'dr: runner = true, async app; runner = false, thread pool
        virtual void SetRunningMode(bool eventRunning)                                  = 0;
        
        // Converts the current thread into an async thread
        // Use with RunOnce, Poll
        virtual bool Create(WorkerId_t workerId)                                        = 0;
        
        //virtual bool CreateAndRun(WorkerId_t workerId)                                = 0;

        // @returns any threads with runner = true
        virtual bool InRunnerMode()                                                     = 0;

        // Manual execution (system thread and ::Create() users)
        virtual bool Poll()                                                             = 0;
        virtual bool RunOnce()                                                          = 0;
        virtual bool Run()                                                              = 0;

        //
        virtual void Shutdown()                                                         = 0;
        virtual bool Exiting()                                                          = 0;
        
        //
        virtual AuSPtr<IWorkItem> NewWorkItem(const WorkerId_t &worker, const AuSPtr<IWorkItemHandler> &task, bool supportsBlocking = false) = 0;
        virtual AuSPtr<IWorkItem> NewFence() = 0;

        //
        virtual Threading::Threads::ThreadShared_t ResolveHandle(WorkerId_t)            = 0;
        
        //
        virtual AuBST<ThreadGroup_t, AuList<ThreadId_t>> GetThreads()                   = 0;
        
        //
        virtual WorkerId_t GetCurrentThread()                                           = 0;

        // Synchronization
        // Note: syncing to yourself will nullify requireSignal to prevent deadlock
        virtual bool Sync(WorkerId_t workerId, AuUInt32 timeoutMs = 0, bool requireSignal = false) = 0;
        virtual void Signal(WorkerId_t workerId)                                        = 0;
        virtual void SyncAllSafe()                                                      = 0;

        // Features
        virtual void AddFeature(WorkerId_t id, AuSPtr<Threading::Threads::IThreadFeature> feature, bool async = false) = 0;
        
        // Debug
        virtual void AssertInThreadGroup(ThreadGroup_t group)                           = 0;
        virtual void AssertWorker(WorkerId_t id)                                        = 0;

        // Async subsystem glue
        virtual bool ScheduleLoopSource(const AuSPtr<Loop::ILoopSource> &loopSource, WorkerId_t workerId, AuUInt32 timeout, const AuConsumer<AuSPtr<Loop::ILoopSource>, bool> &callback) = 0;
    };
}