/
ActionManager.h
154 lines (127 loc) 路 4.3 KB
/
ActionManager.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/* -------------------------------------------------------------------------- */
/* Copyright 2002-2016, OpenNebula Project, OpenNebula Systems */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); you may */
/* not use this file except in compliance with the License. You may obtain */
/* a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
/* See the License for the specific language governing permissions and */
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#ifndef ACTION_MANAGER_H_
#define ACTION_MANAGER_H_
#include <queue>
#include <pthread.h>
#include <ctime>
#include <string>
using namespace std;
/**
* ActionListener class. Interface to be implemented by any class
* that need to handle actions. There are two predefined actions
* (each action is identified with its name, a string):
* - ACTION_TIMER, periodic action
* - ACTION_FINALIZE, to finalize the action loop
*/
class ActionListener
{
public:
/**
* Predefined string to refer to the periodic action
*/
static const string ACTION_TIMER;
/**
* Predefined string to refer to the finalize action
*/
static const string ACTION_FINALIZE;
ActionListener(){};
virtual ~ActionListener(){};
/**
* the do_action() function is executed upon action arrival.
* This function should check the action type, and perform the
* corresponding action.
* @param name the action name
* @param args action arguments
*/
virtual void do_action(const string &name, void *args) = 0;
};
/**
* ActionManager. Provides action support for a class implementing
* the ActionListener interface.
*/
class ActionManager
{
public:
ActionManager();
virtual ~ActionManager();
/** Function to trigger an action to this manager.
* @param action the action name
* @param args arguments for the action
*/
void trigger(
const string &action,
void * args);
/** The calling thread will be suspended until an action is triggeed.
* @param timeout for the periodic action. Use 0 to disable the timer.
* @param timer_args arguments for the timer action
*/
void loop(
time_t timeout,
void * timer_args);
/** Register the calling object in this action manager.
* @param listener a pointer to the action listner
*/
void addListener(
ActionListener * listener)
{
this->listener = listener;
};
private:
/**
* Implementation class, pending actions are stored in a queue.
* Each element stores the action name and its arguments
*/
struct ActionRequest
{
string name;
void * args;
ActionRequest(
const string &aname = "",
void * aargs = 0):
name(aname),
args(aargs){};
};
/**
* Queue of pending actions, processed in a FIFO manner
*/
queue<ActionRequest> actions;
/**
* Action synchronization is implemented using the pthread library,
* with condition variable and its associated mutex
*/
pthread_mutex_t mutex;
pthread_cond_t cond;
/**
* The listener notified by this manager
*/
ActionListener * listener;
/**
* Function to lock the Manager mutex
*/
void lock()
{
pthread_mutex_lock(&mutex);
};
/**
* Function to unlock the Manager mutex
*/
void unlock()
{
pthread_mutex_unlock(&mutex);
};
};
#endif /*ACTION_MANAGER_H_*/