projects/smsdaemon/TaskManager.cpp


#include "TaskManager.h"

#include "Logger.h"

#include <time.h>

#include "tasks/SpoolTask.h"


TaskManager::TaskManager()
                : _lastExecuted(0)
{
}

TaskManager::~TaskManager()
{
        //delete any temporary tasks still in the list
        std::list<Task*>::iterator it;
        for (it = _temp_tasks.begin(); it != _temp_tasks.end(); ++it)
        {
                delete (*it);
        }
}


void TaskManager::LoadTasks()
{
        static SpoolTask task;

        //print the loaded tasks
        std::map<std::string, Task*>::iterator it;
        for (it = _persistant_tasks.begin(); it != _persistant_tasks.end(); ++it)
        {
                Task* tsk = (*it).second;
                if (tsk != 0)
                        Logger::logMessage( std::string("Loaded task \"") + tsk->GetName() + "\"" );
        }
}


void TaskManager::AddPersistantTask(Task* task)
{

        if (task != 0)
        {
                std::string name = task->GetName();

                if ( _persistant_tasks[ name ] == 0)
                        _persistant_tasks[ name ] = task;
                else
                        Logger::logMessage( std::string("AddTask() -- already have a task called ") + name);
        }
        else
        {
                Logger::logMessage("AddTask() -- cannot register a null pointer");
        }
}

void TaskManager::AddTemporaryTask(Task* task)
{
        _temp_tasks.push_back(task);
}


void TaskManager::ExecuteTasks(ISmsTransceiver& modem)
{
        const int SLEEP_TIME = 2; //wait this long between task executions
        int now = time(0);

        if (now < (_lastExecuted + SLEEP_TIME) )
                return;

        _lastExecuted = now;

        //execute real tasks

        std::map<std::string, Task*>::iterator m_it;

        for (m_it = _persistant_tasks.begin(); m_it != _persistant_tasks.end(); ++m_it)
        {
                Task* tsk = (*m_it).second;
                tsk->ExecuteTask(modem);
        }

        //execute temporary tasks

        std::list<Task*>::iterator l_it;
        for (l_it = _temp_tasks.begin(); l_it != _temp_tasks.end(); ++l_it)
        {
                Task* tsk = (*l_it);
                tsk->ExecuteTask(modem);

                if ( tsk->IsFinished() )
                {
                        delete tsk;
                        l_it = _temp_tasks.erase(l_it);

                        //now l_it points to the next element in the list,
                        //but since the for() loop will increment it before next iteration we will decrease it here
                        --l_it;
                }
        }


}


Task* TaskManager::GetPersistantTask(const std::string& taskname)
{
        return _persistant_tasks[ taskname ];
}
1	torben	196
2	torben	26	#include "TaskManager.h"
3
4	torben	157	#include "Logger.h"
5	torben	26
6	torben	82	#include <time.h>
7	torben	26
8	torben	132	#include "tasks/SpoolTask.h"
9
10
11	torben	26	TaskManager::TaskManager()
12	torben	196	: _lastExecuted(0)
13	torben	26	{
14			}
15	torben	196
16	torben	26	TaskManager::~TaskManager()
17	torben	196	{
18	torben	96	//delete any temporary tasks still in the list
19			std::list<Task*>::iterator it;
20			for (it = _temp_tasks.begin(); it != _temp_tasks.end(); ++it)
21			{
22			delete (*it);
23			}
24	torben	26	}
25
26
27			void TaskManager::LoadTasks()
28			{
29	torben	132	static SpoolTask task;
30	torben	26
31	torben	104	//print the loaded tasks
32	torben	196	std::map<std::string, Task*>::iterator it;
33			for (it = _persistant_tasks.begin(); it != _persistant_tasks.end(); ++it)
34	torben	104	{
35			Task* tsk = (*it).second;
36			if (tsk != 0)
37	torben	157	Logger::logMessage( std::string("Loaded task \"") + tsk->GetName() + "\"" );
38	torben	104	}
39	torben	26	}
40
41	torben	82
42	torben	129	void TaskManager::AddPersistantTask(Task* task)
43	torben	82	{
44
45	torben	96	if (task != 0)
46	torben	82	{
47	torben	96	std::string name = task->GetName();
48	torben	82
49	torben	129	if ( _persistant_tasks[ name ] == 0)
50			_persistant_tasks[ name ] = task;
51	torben	96	else
52	torben	157	Logger::logMessage( std::string("AddTask() -- already have a task called ") + name);
53	torben	82	}
54	torben	96	else
55			{
56	torben	157	Logger::logMessage("AddTask() -- cannot register a null pointer");
57	torben	96	}
58	torben	82	}
59
60	torben	96	void TaskManager::AddTemporaryTask(Task* task)
61	torben	26	{
62	torben	96	_temp_tasks.push_back(task);
63	torben	26	}
64
65
66	torben	149	void TaskManager::ExecuteTasks(ISmsTransceiver& modem)
67	torben	26	{
68	torben	189	const int SLEEP_TIME = 2; //wait this long between task executions
69	torben	96	int now = time(0);
70	torben	26
71	torben	196	if (now < (_lastExecuted + SLEEP_TIME) )
72	torben	96	return;
73
74			_lastExecuted = now;
75
76			//execute real tasks
77
78			std::map<std::string, Task*>::iterator m_it;
79
80	torben	129	for (m_it = _persistant_tasks.begin(); m_it != _persistant_tasks.end(); ++m_it)
81	torben	26	{
82	torben	96	Task* tsk = (*m_it).second;
83			tsk->ExecuteTask(modem);
84	torben	26	}
85
86	torben	96	//execute temporary tasks
87	torben	26
88	torben	96	std::list<Task*>::iterator l_it;
89			for (l_it = _temp_tasks.begin(); l_it != _temp_tasks.end(); ++l_it)
90			{
91			Task* tsk = (*l_it);
92			tsk->ExecuteTask(modem);
93
94			if ( tsk->IsFinished() )
95			{
96			delete tsk;
97	torben	196	l_it = _temp_tasks.erase(l_it);
98
99	torben	96	//now l_it points to the next element in the list,
100			//but since the for() loop will increment it before next iteration we will decrease it here
101	torben	196	--l_it;
102	torben	96	}
103			}
104
105
106	torben	26	}
107
108
109	torben	129	Task* TaskManager::GetPersistantTask(const std::string& taskname)
110	torben	96	{
111	torben	129	return _persistant_tasks[ taskname ];
112	torben	96	}