OpenNI 1.5.4
XnEventT.h
Go to the documentation of this file.
1/****************************************************************************
2* *
3* OpenNI 1.x Alpha *
4* Copyright (C) 2011 PrimeSense Ltd. *
5* *
6* This file is part of OpenNI. *
7* *
8* OpenNI is free software: you can redistribute it and/or modify *
9* it under the terms of the GNU Lesser General Public License as published *
10* by the Free Software Foundation, either version 3 of the License, or *
11* (at your option) any later version. *
12* *
13* OpenNI is distributed in the hope that it will be useful, *
14* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16* GNU Lesser General Public License for more details. *
17* *
18* You should have received a copy of the GNU Lesser General Public License *
19* along with OpenNI. If not, see <http://www.gnu.org/licenses/>. *
20* *
21****************************************************************************/
22#ifndef _XN_EVENT_T_H_
23#define _XN_EVENT_T_H_
24
25//---------------------------------------------------------------------------
26// Includes
27//---------------------------------------------------------------------------
28#include "XnOSCpp.h"
29#include "XnListT.h"
30#include "XnTypes.h"
31
32//---------------------------------------------------------------------------
33// Types
34//---------------------------------------------------------------------------
35
41template<typename FuncPtr>
43{
44 XnCallbackT(FuncPtr func, void* cookie) : pFunc(func), pCookie(cookie) {}
45
46 FuncPtr pFunc;
47 void* pCookie;
48};
49
55template<typename FuncPtr>
57{
58public:
59 typedef FuncPtr HandlerPtr;
62
64 {
65 Clear();
67 }
68
69 XnStatus Register(FuncPtr pFunc, void* pCookie, XnCallbackHandle& hCallback)
70 {
71 XnStatus nRetVal = XN_STATUS_OK;
72
74
75 TCallback* pCallback = NULL;
76 XN_VALIDATE_NEW(pCallback, TCallback, pFunc, pCookie);
77
78 // always add to list of added (actual list will be updated in Raise method, to allow registering
79 // from a callback).
80 {
81 XnAutoCSLocker locker(m_hLock);
82 nRetVal = m_toAdd.AddLast(pCallback);
83 }
84
85 if (nRetVal != XN_STATUS_OK)
86 {
87 XN_DELETE(pCallback);
88 return nRetVal;
89 }
90
91 // return handle
92 hCallback = (XnCallbackHandle)pCallback;
93
94 return XN_STATUS_OK;
95 }
96
98 {
99 XnStatus nRetVal = XN_STATUS_OK;
100
101 TCallback* pCallback = (TCallback*)hCallback;
102
103 // add it to a temp list, to allow unregistering from a callback (actual list will be updated in raise
104 // function).
105 {
106 XnAutoCSLocker locker(m_hLock);
107
108 // try to remove it from the ToBeAdded list.
109 if (!RemoveCallback(m_toAdd, pCallback))
110 {
111 // it's not in this list, so it's probably in the main list
112 nRetVal = m_toRemove.AddLast(pCallback);
113 }
114 }
115 XN_IS_STATUS_OK(nRetVal);
116
117 return XN_STATUS_OK;
118 }
119
120protected:
122
123 // Constructors are protected, so that this class cannot be instantiated directly.
125 {
126 Init();
127 }
128
130 {
131 Init();
132 *this = other;
133 }
134
136 {
137 Clear();
138
139 // lock other one (so it won't change while being copied)
140 XnAutoCSLocker otherLocker(other.m_hLock);
141 // lock this one (we're making changes)
142 XnAutoCSLocker locker(m_hLock);
143
144 m_callbacks = other.m_callbacks;
145 m_toAdd = other.m_toAdd;
146 m_toRemove = other.m_toRemove;
147
149
150 return *this;
151 }
152
154 {
155 XnAutoCSLocker locker(m_hLock);
157
158 for (typename CallbackPtrList::ConstIterator it = m_callbacks.Begin(); it != m_callbacks.End(); ++it)
159 {
160 TCallback* pCallback = *it;
161 XN_DELETE(pCallback);
162 }
163
166 m_toAdd.Clear();
167 return (XN_STATUS_OK);
168 }
169
171 {
172 XnAutoCSLocker locker(m_hLock);
173
174 // first add all
175 for (typename CallbackPtrList::ConstIterator it = m_toAdd.Begin(); it != m_toAdd.End(); ++it)
176 {
177 m_callbacks.AddLast(*it);
178 }
179 m_toAdd.Clear();
180
181 // and now remove
182 for (typename CallbackPtrList::ConstIterator it = m_toRemove.Begin(); it != m_toRemove.End(); ++it)
183 {
184 TCallback* pCallback = *it;
185 RemoveCallback(m_callbacks, pCallback);
186 }
188
189 return (XN_STATUS_OK);
190 }
191
192 XnBool RemoveCallback(CallbackPtrList& list, TCallback* pCallback)
193 {
194 typename CallbackPtrList::Iterator it = list.Find(pCallback);
195 if (it != list.End())
196 {
197 list.Remove(it);
198 XN_DELETE(pCallback);
199 return TRUE;
200 }
201
202 return FALSE;
203 }
204
205 XN_CRITICAL_SECTION_HANDLE m_hLock;
209
210private:
211 void Init()
212 {
213 m_hLock = NULL;
215 if (nRetVal != XN_STATUS_OK)
216 {
217 XN_ASSERT(FALSE);
218 }
219 }
220};
221
222// Handlers
224{
225 typedef void (XN_CALLBACK_TYPE* FuncPtr)(void* pCookie);
226};
227
228template<class TArg1>
230{
231 typedef void (XN_CALLBACK_TYPE* FuncPtr)(TArg1 arg1, void* pCookie);
232};
233
234template<class TArg1, class TArg2>
236{
237 typedef void (XN_CALLBACK_TYPE* FuncPtr)(TArg1 arg1, TArg2 arg2, void* pCookie);
238};
239
240template<class TArg1, class TArg2, class TArg3>
242{
243 typedef void (XN_CALLBACK_TYPE* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, void* pCookie);
244};
245
246template<class TArg1, class TArg2, class TArg3, class TArg4>
248{
249 typedef void (XN_CALLBACK_TYPE* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4, void* pCookie);
250};
251
252template<class TArg1, class TArg2, class TArg3, class TArg4, class TArg5>
254{
255 typedef void (XN_CALLBACK_TYPE* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4, TArg5 arg5, void* pCookie);
256};
257
258// Event classes (there's a class per number of arguments)
259class XnEventNoArgs : public XnEventInterfaceT<XnHandlerFuncNoArgs::FuncPtr>
260{
261public:
263 {
264 XnAutoCSLocker locker(this->m_hLock);
266
267 for (CallbackPtrList::ConstIterator it = m_callbacks.Begin(); it != m_callbacks.End(); ++it)
268 {
269 TCallback* pCallback = *it;
270 pCallback->pFunc(pCallback->pCookie);
271 }
272
274 return (XN_STATUS_OK);
275 }
276};
277
278
279template<class TArg1>
280class XnEvent1Arg : public XnEventInterfaceT<typename XnHandlerFunc1Arg<TArg1>::FuncPtr>
281{
283
284public:
285 XnStatus Raise(TArg1 arg)
286 {
287 XnAutoCSLocker locker(this->m_hLock);
288 this->ApplyListChanges();
289
290 for (typename Base::CallbackPtrList::ConstIterator it = this->m_callbacks.Begin(); it != this->m_callbacks.End(); ++it)
291 {
292 typename Base::TCallback* pCallback = *it;
293 pCallback->pFunc(arg, pCallback->pCookie);
294 }
295
296 this->ApplyListChanges();
297 return (XN_STATUS_OK);
298 }
299};
300
301template<class TEventArgs>
302class XnEventT : public XnEvent1Arg<const TEventArgs&>
303{};
304
305template<class TArg1, class TArg2>
306class XnEvent2Args : public XnEventInterfaceT<typename XnHandlerFunc2Args<TArg1, TArg2>::FuncPtr>
307{
309
310public:
311 XnStatus Raise(TArg1 arg1, TArg2 arg2)
312 {
313 XnAutoCSLocker locker(this->m_hLock);
314 this->ApplyListChanges();
315
316 for (typename Base::CallbackPtrList::ConstIterator it = this->m_callbacks.Begin(); it != this->m_callbacks.End(); ++it)
317 {
318 typename Base::TCallback* pCallback = *it;
319 pCallback->pFunc(arg1, arg2, pCallback->pCookie);
320 }
321
322 this->ApplyListChanges();
323 return (XN_STATUS_OK);
324 }
325};
326
327template<class TArg1, class TArg2, class TArg3>
328class XnEvent3Args : public XnEventInterfaceT<typename XnHandlerFunc3Args<TArg1, TArg2, TArg3>::FuncPtr>
329{
331
332public:
333 XnStatus Raise(TArg1 arg1, TArg2 arg2, TArg3 arg3)
334 {
335 XnAutoCSLocker locker(this->m_hLock);
336 this->ApplyListChanges();
337
338 for (typename Base::CallbackPtrList::ConstIterator it = this->m_callbacks.Begin(); it != this->m_callbacks.End(); ++it)
339 {
340 typename Base::TCallback* pCallback = *it;
341 pCallback->pFunc(arg1, arg2, arg3, pCallback->pCookie);
342 }
343
344 this->ApplyListChanges();
345 return (XN_STATUS_OK);
346 }
347};
348
349template<class TArg1, class TArg2, class TArg3, class TArg4>
350class XnEvent4Args : public XnEventInterfaceT<typename XnHandlerFunc4Args<TArg1, TArg2, TArg3, TArg4>::FuncPtr>
351{
353
354public:
355 XnStatus Raise(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4)
356 {
357 XnAutoCSLocker locker(this->m_hLock);
358 this->ApplyListChanges();
359
360 for (typename Base::CallbackPtrList::ConstIterator it = this->m_callbacks.Begin(); it != this->m_callbacks.End(); ++it)
361 {
362 typename Base::TCallback* pCallback = *it;
363 pCallback->pFunc(arg1, arg2, arg3, arg4, pCallback->pCookie);
364 }
365
366 this->ApplyListChanges();
367 return (XN_STATUS_OK);
368 }
369};
370
371template<class TArg1, class TArg2, class TArg3, class TArg4, class TArg5>
372class XnEvent5Args : public XnEventInterfaceT<typename XnHandlerFunc5Args<TArg1, TArg2, TArg3, TArg4, TArg5>::FuncPtr>
373{
375
376public:
377 XnStatus Raise(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4, TArg5 arg5)
378 {
379 XnAutoCSLocker locker(this->m_hLock);
380 this->ApplyListChanges();
381
382 for (typename Base::CallbackPtrList::ConstIterator it = this->m_callbacks.Begin(); it != this->m_callbacks.End(); ++it)
383 {
384 typename Base::TCallback* pCallback = *it;
385 pCallback->pFunc(arg1, arg2, arg3, arg4, arg5, pCallback->pCookie);
386 }
387
388 this->ApplyListChanges();
389 return (XN_STATUS_OK);
390 }
391};
392
393#endif // _XN_EVENT_T_H_
#define XN_IS_STATUS_OK(x)
Definition: XnMacros.h:60
#define XN_VALIDATE_INPUT_PTR(x)
Definition: XnOS.h:123
XN_C_API XnStatus XN_C_DECL xnOSCloseCriticalSection(XN_CRITICAL_SECTION_HANDLE *pCriticalSectionHandle)
#define XN_DELETE(p)
Definition: XnOS.h:336
#define XN_VALIDATE_NEW(ptr, type,...)
Definition: XnOS.h:168
XN_C_API XnStatus XN_C_DECL xnOSCreateCriticalSection(XN_CRITICAL_SECTION_HANDLE *pCriticalSectionHandle)
#define TRUE
Definition: XnPlatform.h:93
#define FALSE
Definition: XnPlatform.h:97
XnUInt32 XnStatus
Definition: XnStatus.h:34
#define XN_STATUS_OK
Definition: XnStatus.h:37
void * XnCallbackHandle
Definition: XnTypes.h:268
Definition: XnOSCpp.h:34
Definition: XnEventT.h:281
XnStatus Raise(TArg1 arg)
Definition: XnEventT.h:285
Definition: XnEventT.h:307
XnStatus Raise(TArg1 arg1, TArg2 arg2)
Definition: XnEventT.h:311
Definition: XnEventT.h:329
XnStatus Raise(TArg1 arg1, TArg2 arg2, TArg3 arg3)
Definition: XnEventT.h:333
Definition: XnEventT.h:351
XnStatus Raise(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4)
Definition: XnEventT.h:355
Definition: XnEventT.h:373
XnStatus Raise(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4, TArg5 arg5)
Definition: XnEventT.h:377
Definition: XnEventT.h:57
XnBool RemoveCallback(CallbackPtrList &list, TCallback *pCallback)
Definition: XnEventT.h:192
XnStatus Clear()
Definition: XnEventT.h:153
XnStatus ApplyListChanges()
Definition: XnEventT.h:170
CallbackPtrList m_callbacks
Definition: XnEventT.h:206
CallbackPtrList m_toRemove
Definition: XnEventT.h:208
CallbackPtrList m_toAdd
Definition: XnEventT.h:207
XnListT< TCallback * > CallbackPtrList
Definition: XnEventT.h:121
XnEventInterfaceT & operator=(const XnEventInterfaceT &other)
Definition: XnEventT.h:135
XnEventInterfaceT TInterface
Definition: XnEventT.h:61
XnEventInterfaceT(const XnEventInterfaceT &other)
Definition: XnEventT.h:129
XnStatus Unregister(XnCallbackHandle hCallback)
Definition: XnEventT.h:97
XN_CRITICAL_SECTION_HANDLE m_hLock
Definition: XnEventT.h:205
FuncPtr HandlerPtr
Definition: XnEventT.h:59
~XnEventInterfaceT()
Definition: XnEventT.h:63
XnEventInterfaceT()
Definition: XnEventT.h:124
XnCallbackT< FuncPtr > TCallback
Definition: XnEventT.h:60
XnStatus Register(FuncPtr pFunc, void *pCookie, XnCallbackHandle &hCallback)
Definition: XnEventT.h:69
Definition: XnEventT.h:260
XnStatus Raise()
Definition: XnEventT.h:262
Definition: XnEventT.h:303
XnStatus Clear()
Definition: XnListT.h:471
XnStatus AddLast(T const &value)
Definition: XnListT.h:383
Iterator End()
Definition: XnListT.h:281
Iterator Begin()
Definition: XnListT.h:265
ConstIterator Find(T const &value) const
Definition: XnListT.h:395
XnStatus Remove(ConstIterator where)
Definition: XnListT.h:426
Definition: XnEventT.h:43
void * pCookie
Definition: XnEventT.h:47
FuncPtr pFunc
Definition: XnEventT.h:46
XnCallbackT(FuncPtr func, void *cookie)
Definition: XnEventT.h:44
Definition: XnEventT.h:230
void(* FuncPtr)(TArg1 arg1, void *pCookie)
Definition: XnEventT.h:231
Definition: XnEventT.h:236
void(* FuncPtr)(TArg1 arg1, TArg2 arg2, void *pCookie)
Definition: XnEventT.h:237
Definition: XnEventT.h:242
void(* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, void *pCookie)
Definition: XnEventT.h:243
Definition: XnEventT.h:248
void(* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4, void *pCookie)
Definition: XnEventT.h:249
Definition: XnEventT.h:254
void(* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4, TArg5 arg5, void *pCookie)
Definition: XnEventT.h:255
Definition: XnEventT.h:224
void(* FuncPtr)(void *pCookie)
Definition: XnEventT.h:225