Question

I am trying to build a very simple scheduler. It allows tasks (functions) to be added to a list and run on set intervals. The ‘Scheduler’ class works fine if I provide a static function as an argument to its ‘ScheduleTask’ member.

class TestController
{
private:
    Scheduler _scheduler;

public:
    TestController(void)
    {
        _scheduler.ScheduleTask(Task1, 3000);
        _scheduler.ScheduleTask(Task2, 5000);
    }
    ~TestController(void);

    void Task1(void) { }
    void Task2(void) { }
};

struct Task
{
    long interval;
    long last_run;
    void (*TaskCallback) (void);

    Task()
    {
        last_run = 0;
    }
};

class Scheduler
{
private:
    std::vector<Task> _tasks;
public:
    Scheduler(void) { }
    ~Scheduler(void) { }

    void ScheduleTask(void (*TaskCallback) (void), long interval)
    {
        Task t;
        t.TaskCallback = TaskCallback;
        t.interval = interval;
        _tasks.push_back(t);
    }

    void loop()
    {
        for(unsigned int i = 0; i < _tasks.size(); i++)
        {
            long elapsed = clock();

            if(elapsed - _tasks[i].last_run >= _tasks[i].interval)
            {
                _tasks[i].last_run = elapsed;
                _tasks[i].TaskCallback();
            }
        }
    }

};

How can I modify the callback to accept the member on the already instantiated ‘TestController’ object?

Answer 1

Use a combination of boost::function and boost::bind. Alternatively, use std::function and std::bind if your compiler supports them.

#include <boost/bind.hpp>
#include <boost/function.hpp>

#include <vector>

typedef boost::function<void()> Callback;

struct Task
{
    long interval;
    long last_run;
    Callback TaskCallback;

    Task()
    {
        last_run = 0;
    }
};

class Scheduler
{
private:
    std::vector<Task> _tasks;
public:
    Scheduler(void) { }
    ~Scheduler(void) { }

    void ScheduleTask(const Callback& TaskCallback, long interval)
    {
        Task t;
        t.TaskCallback = TaskCallback;
        t.interval = interval;
        _tasks.push_back(t);
    }

    void loop()
    {
        for(unsigned int i = 0; i < _tasks.size(); i++)
        {
            long elapsed = clock();

            if(elapsed - _tasks[i].last_run >= _tasks[i].interval)
            {
                _tasks[i].last_run = elapsed;
                _tasks[i].TaskCallback();
            }
        }
    }
};

class TestController
{
private:
    Scheduler _scheduler;

public:
    TestController(void)
    {
        _scheduler.ScheduleTask(boost::bind(&TestController::Task1,this), 3000);
        _scheduler.ScheduleTask(boost::bind(&TestController::Task2,this), 5000);
    }
    ~TestController(void);

    void Task1(void) { }
    void Task2(void) { }
};