async.h

Go to the documentation of this file.

#pragma once

 
#include "fl/namespace.h"
#include "fl/vector.h"
#include "fl/function.h"
#include "fl/ptr.h"
#include "fl/variant.h"
#include "fl/promise.h"
#include "fl/promise_result.h"
#include "fl/singleton.h"
#include "fl/thread_local.h"
 
#include "fl/task.h"
#include "fl/time.h"
 
namespace fl {
 
// Forward declarations
class AsyncManager;

class async_runner {
public:
    virtual ~async_runner() = default;
    
    virtual void update() = 0;
    
    virtual bool has_active_tasks() const = 0;
    
    virtual size_t active_task_count() const = 0;
};

class AsyncManager {
public:
    static AsyncManager& instance();
    
    void register_runner(async_runner* runner);
    
    void unregister_runner(async_runner* runner);
    
    void update_all();
    
    bool has_active_tasks() const;
    
    size_t total_active_tasks() const;
 
private:
    fl::vector<async_runner*> mRunners;
};

void async_yield();
 

void async_run();
 
 

size_t async_active_tasks();

bool async_has_tasks();

template<typename T>
fl::result<T> await_top_level(fl::promise<T> promise) {
    // Handle invalid promises
    if (!promise.valid()) {
        return fl::result<T>(Error("Invalid promise"));
    }
    
    // If already completed, return immediately
    if (promise.is_completed()) {
        if (promise.is_resolved()) {
            return fl::result<T>(promise.value());
        } else {
            return fl::result<T>(promise.error());
        }
    }
    
    // Track recursion depth to prevent infinite loops
    static fl::ThreadLocal<int> await_depth(0);
    if (await_depth.access() > 10) {
        return fl::result<T>(Error("await_top_level recursion limit exceeded - possible infinite loop"));
    }
    
    ++await_depth.access();
    
    // Wait for promise to complete while pumping async tasks
    int pump_count = 0;
    const int max_pump_iterations = 10000; // Safety limit
    
    while (!promise.is_completed() && pump_count < max_pump_iterations) {
        // Update the promise first (in case it's not managed by async system)
        promise.update();
        
        // Check if completed after update
        if (promise.is_completed()) {
            break;
        }
        
        // Platform-agnostic async pump and yield
        async_yield();
        
        ++pump_count;
    }
    
    --await_depth.access();
    
    // Check for timeout
    if (pump_count >= max_pump_iterations) {
        return fl::result<T>(Error("await_top_level timeout - promise did not complete"));
    }
    
    // Return the result
    if (promise.is_resolved()) {
        return fl::result<T>(promise.value());
    } else {
        return fl::result<T>(promise.error());
    }
}
 
class Scheduler {
public:
    static Scheduler& instance();
 
    int add_task(task t);
    void update();
    
    // New methods for frame task handling
    void update_before_frame_tasks();
    void update_after_frame_tasks();
    
    // For testing: clear all tasks
    void clear_all_tasks() { mTasks.clear(); mNextTaskId = 1; }
 
private:
    friend class fl::Singleton<Scheduler>;
    Scheduler() : mTasks() {}
 
    void warn_no_then(int task_id, const fl::string& trace_label);
    void warn_no_catch(int task_id, const fl::string& trace_label, const Error& error);
    
    // Helper method for running specific task types
    void update_tasks_of_type(TaskType task_type);
 
    fl::vector<task> mTasks;
    int mNextTaskId = 1;
};
 
} // namespace fl