projects/smsdaemon/TaskManager.cpp

        
#include "TaskManager.h"

#include "common.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)
                        Common::instance()->logMessage( std::string("Loaded task \"") + tsk->GetName() + "\"" );
        }
}


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

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

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