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 
41 template<typename FuncPtr>
43 {
44  XnCallbackT(FuncPtr func, void* cookie) : pFunc(func), pCookie(cookie) {}
45 
46  FuncPtr pFunc;
47  void* pCookie;
48 };
49 
55 template<typename FuncPtr>
57 {
58 public:
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 
73  XN_VALIDATE_INPUT_PTR(pFunc);
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 
120 protected:
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 
164  m_callbacks.Clear();
165  m_toRemove.Clear();
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  }
187  m_toRemove.Clear();
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;
206  CallbackPtrList m_callbacks;
207  CallbackPtrList m_toAdd;
208  CallbackPtrList m_toRemove;
209 
210 private:
211  void Init()
212  {
213  m_hLock = NULL;
214  XnStatus nRetVal = xnOSCreateCriticalSection(&m_hLock);
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 
228 template<class TArg1>
230 {
231  typedef void (XN_CALLBACK_TYPE* FuncPtr)(TArg1 arg1, void* pCookie);
232 };
233 
234 template<class TArg1, class TArg2>
236 {
237  typedef void (XN_CALLBACK_TYPE* FuncPtr)(TArg1 arg1, TArg2 arg2, void* pCookie);
238 };
239 
240 template<class TArg1, class TArg2, class TArg3>
242 {
243  typedef void (XN_CALLBACK_TYPE* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, void* pCookie);
244 };
245 
246 template<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 
252 template<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)
259 class XnEventNoArgs : public XnEventInterfaceT<XnHandlerFuncNoArgs::FuncPtr>
260 {
261 public:
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 
279 template<class TArg1>
280 class XnEvent1Arg : public XnEventInterfaceT<typename XnHandlerFunc1Arg<TArg1>::FuncPtr>
281 {
283 
284 public:
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 
301 template<class TEventArgs>
302 class XnEventT : public XnEvent1Arg<const TEventArgs&>
303 {};
304 
305 template<class TArg1, class TArg2>
306 class XnEvent2Args : public XnEventInterfaceT<typename XnHandlerFunc2Args<TArg1, TArg2>::FuncPtr>
307 {
309 
310 public:
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 
327 template<class TArg1, class TArg2, class TArg3>
328 class XnEvent3Args : public XnEventInterfaceT<typename XnHandlerFunc3Args<TArg1, TArg2, TArg3>::FuncPtr>
329 {
331 
332 public:
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 
349 template<class TArg1, class TArg2, class TArg3, class TArg4>
350 class XnEvent4Args : public XnEventInterfaceT<typename XnHandlerFunc4Args<TArg1, TArg2, TArg3, TArg4>::FuncPtr>
351 {
353 
354 public:
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 
371 template<class TArg1, class TArg2, class TArg3, class TArg4, class TArg5>
372 class XnEvent5Args : public XnEventInterfaceT<typename XnHandlerFunc5Args<TArg1, TArg2, TArg3, TArg4, TArg5>::FuncPtr>
373 {
375 
376 public:
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_
XnEventInterfaceT TInterface
Definition: XnEventT.h:61
Definition: XnEventT.h:253
XnStatus Raise(TArg1 arg1, TArg2 arg2)
Definition: XnEventT.h:311
XnListT< TCallback * > CallbackPtrList
Definition: XnEventT.h:121
CallbackPtrList m_toAdd
Definition: XnEventT.h:207
ConstIterator Find(T const &value) const
Definition: XnListT.h:395
XN_CRITICAL_SECTION_HANDLE m_hLock
Definition: XnEventT.h:205
~XnEventInterfaceT()
Definition: XnEventT.h:63
#define XN_IS_STATUS_OK(x)
Definition: XnMacros.h:60
#define FALSE
Definition: XnPlatform.h:85
Definition: XnEventT.h:235
XnStatus ApplyListChanges()
Definition: XnEventT.h:170
XnEventInterfaceT & operator=(const XnEventInterfaceT &other)
Definition: XnEventT.h:135
Definition: XnEventT.h:302
FuncPtr pFunc
Definition: XnEventT.h:46
#define XN_STATUS_OK
Definition: XnStatus.h:37
XnCallbackT(FuncPtr func, void *cookie)
Definition: XnEventT.h:44
CallbackPtrList m_toRemove
Definition: XnEventT.h:208
CallbackPtrList m_callbacks
Definition: XnEventT.h:206
void(* FuncPtr)(TArg1 arg1, TArg2 arg2, void *pCookie)
Definition: XnEventT.h:237
XnStatus Raise(TArg1 arg1, TArg2 arg2, TArg3 arg3)
Definition: XnEventT.h:333
#define XN_VALIDATE_NEW(ptr, type,...)
Definition: XnOS.h:168
XnUInt32 XnStatus
Definition: XnStatus.h:34
Definition: XnEventT.h:229
XnBool RemoveCallback(CallbackPtrList &list, TCallback *pCallback)
Definition: XnEventT.h:192
void * pCookie
Definition: XnEventT.h:47
Definition: XnEventT.h:328
void(* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, void *pCookie)
Definition: XnEventT.h:243
#define TRUE
Definition: XnPlatform.h:81
void(* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4, void *pCookie)
Definition: XnEventT.h:249
Definition: XnEventT.h:306
XnStatus Raise()
Definition: XnEventT.h:262
XnStatus Register(FuncPtr pFunc, void *pCookie, XnCallbackHandle &hCallback)
Definition: XnEventT.h:69
XnStatus Clear()
Definition: XnEventT.h:153
void * XnCallbackHandle
Definition: XnTypes.h:268
Definition: XnOSCpp.h:33
Definition: XnEventT.h:247
XN_C_API XnStatus XN_C_DECL xnOSCloseCriticalSection(XN_CRITICAL_SECTION_HANDLE *pCriticalSectionHandle)
Iterator Begin()
Definition: XnListT.h:265
XnEventInterfaceT()
Definition: XnEventT.h:124
#define XN_VALIDATE_INPUT_PTR(x)
Definition: XnOS.h:123
XnStatus Clear()
Definition: XnListT.h:471
Definition: XnEventT.h:259
#define XN_DELETE(p)
Definition: XnOS.h:336
XnStatus Raise(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4, TArg5 arg5)
Definition: XnEventT.h:377
XnCallbackT< FuncPtr > TCallback
Definition: XnEventT.h:60
void(* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4, TArg5 arg5, void *pCookie)
Definition: XnEventT.h:255
XnStatus Remove(ConstIterator where)
Definition: XnListT.h:426
Definition: XnEventT.h:223
void(* FuncPtr)(TArg1 arg1, void *pCookie)
Definition: XnEventT.h:231
Definition: XnEventT.h:42
Iterator End()
Definition: XnListT.h:281
Definition: XnEventT.h:350
XnStatus Raise(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4)
Definition: XnEventT.h:355
XnEventInterfaceT(const XnEventInterfaceT &other)
Definition: XnEventT.h:129
XN_C_API XnStatus XN_C_DECL xnOSCreateCriticalSection(XN_CRITICAL_SECTION_HANDLE *pCriticalSectionHandle)
XnStatus Unregister(XnCallbackHandle hCallback)
Definition: XnEventT.h:97
XnStatus Raise(TArg1 arg)
Definition: XnEventT.h:285
Definition: XnEventT.h:280
void(* FuncPtr)(void *pCookie)
Definition: XnEventT.h:225
Definition: XnEventT.h:241
Definition: XnEventT.h:372
FuncPtr HandlerPtr
Definition: XnEventT.h:59
Definition: XnEventT.h:56
XnStatus AddLast(T const &value)
Definition: XnListT.h:383