Method addActiveHandle

Libraries/Async/Async.cpp:2399–2494

    break;
    case AsyncRequest::State::Free:
        // TODO: Not sure if we should error out here
        return SC::Result::Error(AsyncResultCategory, AsyncError::RequestNotActive);
    case AsyncRequest::State::Cancelling:
        // Already Cancelling, but now we update the stop function
        break;
    }
    return Result(true);
}

SC::Result SC::AsyncEventLoop::Internal::unscheduleLoopTimeout(AsyncLoopTimeout& timeout)
{
    if (timeout.sequence != nullptr)
        return Result::Error(AsyncResultCategory, AsyncError::SequencedTimeout);
    switch (timeout.state)
    {
    case AsyncRequest::State::Free: timeout.closeCallback = nullptr; return Result(true);
    case AsyncRequest::State::Setup:
        timeout.closeCallback = nullptr;
        submissions.remove(timeout);
        numberOfSubmissions -= 1;
        timeout.markAsFree();
        return Result(true);
    case AsyncRequest::State::Active:
        timeout.closeCallback = nullptr;
        removeActiveHandle(timeout);
        return Result(true);
    case AsyncRequest::State::Submitting:
    case AsyncRequest::State::Reactivate:
    case AsyncRequest::State::Cancelling:
        return Result::Error(AsyncResultCategory, AsyncError::TimeoutTransitionInProgress);
    }
    return Result::Error(AsyncResultCategory, AsyncError::InvalidState);
}

void SC::AsyncEventLoop::Internal::updateTime()
{
#if SC_PLATFORM_WINDOWS
    LARGE_INTEGER queryPerformanceFrequency;
    LARGE_INTEGER performanceCounter;
    // Since WinXP this is guaranteed to succeed
    QueryPerformanceFrequency(&queryPerformanceFrequency);
    QueryPerformanceCounter(&performanceCounter);
    TimeMs newTime = {static_cast<int64_t>(performanceCounter.QuadPart * 1000 / queryPerformanceFrequency.QuadPart)};

#else
    struct timespec nowTimeSpec;
    clock_gettime(CLOCK_MONOTONIC, &nowTimeSpec);
    int64_t ms = static_cast<int64_t>(nowTimeSpec.tv_sec) * 1000;
    ms += static_cast<int64_t>(nowTimeSpec.tv_nsec / (1000 * 1000));
    TimeMs newTime = {ms};
#endif
    SC_ASYNC_ASSERT_RELEASE(newTime.milliseconds >= loopTime.milliseconds);
    loopTime = newTime;
}

SC::Result SC::AsyncEventLoop::wakeUpFromExternalThread(AsyncLoopWakeUp& async)
{
    SC_ASYNC_ASSERT_DEBUG(async.type == AsyncRequest::Type::LoopWakeUp);