projects/smsdaemon/TaskManager.cpp

        
#include "TaskManager.h"

#include "common.h"

#include <time.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()
{

}


void TaskManager::AddTask(Task* task)
{
        Common* cmn = Common::instance();

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

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

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


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