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