100 lines
2.6 KiB
C++
100 lines
2.6 KiB
C++
/**
|
|
* Copyright 2013 (c) Anna Schumaker.
|
|
*/
|
|
#ifndef OCARINA_CORE_IDLE_H
|
|
#define OCARINA_CORE_IDLE_H
|
|
|
|
/**
|
|
* The idle queue is used to schedule function calls to run at a
|
|
* later time. It is expected that a higher layer can determine
|
|
* when the application is idle and call idle::run_task() accordingly.
|
|
*
|
|
* The idle layer keeps a count of the number of tasks added to the queue
|
|
* since the last time the queue was empty. Whenever a task is scheduled,
|
|
* the "queued" count is incremented by 1. When tasks are run, the "serviced"
|
|
* count is incremented by 1. These counters are reset to 0 once the queue
|
|
* is empty.
|
|
*/
|
|
namespace idle
|
|
{
|
|
|
|
/**
|
|
* Base class used by the templated IdleTask class. This lets
|
|
* us create an idle queue storing IdleBase pointers to get
|
|
* around potential templating issues.
|
|
*/
|
|
class IdleBase {
|
|
protected:
|
|
/**
|
|
* Adds the IdleBase to the idle queue and increments
|
|
* the "queued" counter by 1.
|
|
*/
|
|
void schedule();
|
|
|
|
public:
|
|
IdleBase(); /**< IdleBase constructor. */
|
|
virtual ~IdleBase(); /**< IdleBase destructor. */
|
|
virtual void run() = 0; /**< Run the idle task. */
|
|
};
|
|
|
|
|
|
/**
|
|
* Generic IdleTask class. This class is templated to allow
|
|
* for scheduling functions that take different types of data
|
|
* parameters.
|
|
*/
|
|
template <class T>
|
|
class IdleTask : public IdleBase {
|
|
private:
|
|
void (*_func)(T &); /**< Function to call when run. */
|
|
T _data; /**< Data to pass to the function. */
|
|
|
|
public:
|
|
/**
|
|
* IdleTask constructor.
|
|
*
|
|
* @param func Function to call when running this task.
|
|
* @param data Data to pass to the function.
|
|
*/
|
|
IdleTask(void (*)(T &), T);
|
|
|
|
~IdleTask(); /**< IdleTask destructor. */
|
|
void run(); /**< Call func(), passing data as the argument. */
|
|
};
|
|
|
|
|
|
/**
|
|
* Creates a new IdleTask and adds it to the queue.
|
|
*
|
|
* @param func Function to call when running the new task.
|
|
* @param data Data to pass to the function.
|
|
*/
|
|
template <class T>
|
|
static inline void schedule(void (*func)(T &), T data)
|
|
{
|
|
new IdleTask<T>(func, data);
|
|
}
|
|
|
|
/**
|
|
* Run the next task on the idle queue and increment the "serviced"
|
|
* counter. If this was the last task then the "queued" and
|
|
* "serviced" values are reset to 0.
|
|
*
|
|
* @return True if there are still tasks on the queue, false otherwise.
|
|
*/
|
|
bool run_task();
|
|
|
|
/**
|
|
* Use the values of the queued and serviced counters to find the
|
|
* overall process of the idle queue (serviced / queued).
|
|
*
|
|
* @return The percentage of IdleTasks that have been run.
|
|
*/
|
|
float get_progress();
|
|
|
|
};
|
|
|
|
#include "idle.hpp"
|
|
|
|
#endif /* OCARINA_CORE_IDLE_H */
|