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
|
/*
* Copyright (C) 2001-2006 Jacek Sieka, arnetheduck on gmail point com
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#if !defined(SPEAKER_H)
#define SPEAKER_H
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "CriticalSection.h"
template<typename Listener>
class Speaker {
typedef vector<Listener*> ListenerList;
typedef typename ListenerList::iterator ListenerIter;
public:
Speaker() throw() { }
virtual ~Speaker() throw() { }
template<typename T0>
void fire(T0 type) throw() {
Lock l(listenerCS);
tmp = listeners;
for(ListenerIter i=tmp.begin(); i != tmp.end(); ++i ) {
(*i)->on(type);
}
}
template<typename T0, class T1>
void fire(T0 type, const T1& p1) throw() {
Lock l(listenerCS);
tmp = listeners;
for(ListenerIter i=tmp.begin(); i != tmp.end(); ++i ) {
(*i)->on(type, p1);
}
}
template<typename T0, class T1>
void fire(T0 type, T1& p1) throw() {
Lock l(listenerCS);
tmp = listeners;
for(ListenerIter i=tmp.begin(); i != tmp.end(); ++i ) {
(*i)->on(type, p1);
}
}
template<typename T0, class T1, class T2>
void fire(T0 type, const T1& p1, const T2& p2) throw() {
Lock l(listenerCS);
tmp = listeners;
for(ListenerIter i=tmp.begin(); i != tmp.end(); ++i ) {
(*i)->on(type, p1, p2);
}
}
template<typename T0, class T1, class T2, class T3>
void fire(T0 type, const T1& p1, const T2& p2, const T3& p3) throw() {
Lock l(listenerCS);
tmp = listeners;
for(ListenerIter i=tmp.begin(); i != tmp.end(); ++i ) {
(*i)->on(type, p1, p2, p3);
}
}
template<typename T0, class T1, class T2, class T3, class T4>
void fire(T0 type, const T1& p1, const T2& p2, const T3& p3, const T4& p4) throw() {
Lock l(listenerCS);
tmp = listeners;
for(ListenerIter i=tmp.begin(); i != tmp.end(); ++i ) {
(*i)->on(type, p1, p2, p3, p4);
}
}
template<typename T0, class T1, class T2, class T3, class T4, class T5>
void fire(T0 type, const T1& p1, const T2& p2, const T3& p3, const T4& p4, const T5& p5) throw() {
Lock l(listenerCS);
tmp = listeners;
for(ListenerIter i=tmp.begin(); i != tmp.end(); ++i ) {
(*i)->on(type, p1, p2, p3, p4, p5);
}
}
template<typename T0, class T1, class T2, class T3, class T4, class T5, class T6>
void fire(T0 type, const T1& p1, const T2& p2, const T3& p3, const T4& p4, const T5& p5, const T6& p6) throw() {
Lock l(listenerCS);
tmp = listeners;
for(ListenerIter i=tmp.begin(); i != tmp.end(); ++i ) {
(*i)->on(type, p1, p2, p3, p4, p5, p6);
}
}
void addListener(Listener* aListener) {
Lock l(listenerCS);
if(find(listeners.begin(), listeners.end(), aListener) == listeners.end())
listeners.push_back(aListener);
}
void removeListener(Listener* aListener) {
Lock l(listenerCS);
ListenerIter it = find(listeners.begin(), listeners.end(), aListener);
if(it != listeners.end())
listeners.erase(it);
}
void removeListeners() {
Lock l(listenerCS);
listeners.clear();
}
protected:
ListenerList listeners;
ListenerList tmp;
CriticalSection listenerCS;
};
#endif // !defined(SPEAKER_H)
|
