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 
40 template<typename FuncPtr>
42 {
43  XnCallbackT(FuncPtr func, void* cookie) : pFunc(func), pCookie(cookie) {}
44 
45  FuncPtr pFunc;
46  void* pCookie;
47 };
48 
54 template<typename FuncPtr>
56 {
57 public:
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 
72  XN_VALIDATE_INPUT_PTR(pFunc);
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 
119 protected:
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 
163  m_callbacks.Clear();
164  m_toRemove.Clear();
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  }
186  m_toRemove.Clear();
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;
205  CallbackPtrList m_callbacks;
206  CallbackPtrList m_toAdd;
207  CallbackPtrList m_toRemove;
208 
209 private:
210  void Init()
211  {
212  m_hLock = NULL;
213  XnStatus nRetVal = xnOSCreateCriticalSection(&m_hLock);
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 
227 template<class TArg1>
229 {
230  typedef void (XN_CALLBACK_TYPE* FuncPtr)(TArg1 arg1, void* pCookie);
231 };
232 
233 template<class TArg1, class TArg2>
235 {
236  typedef void (XN_CALLBACK_TYPE* FuncPtr)(TArg1 arg1, TArg2 arg2, void* pCookie);
237 };
238 
239 template<class TArg1, class TArg2, class TArg3>
241 {
242  typedef void (XN_CALLBACK_TYPE* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, void* pCookie);
243 };
244 
245 template<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 
251 template<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)
258 class XnEventNoArgs : public XnEventInterfaceT<XnHandlerFuncNoArgs::FuncPtr>
259 {
260 public:
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 
278 template<class TArg1>
279 class XnEvent1Arg : public XnEventInterfaceT<typename XnHandlerFunc1Arg<TArg1>::FuncPtr>
280 {
282 
283 public:
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 
300 template<class TEventArgs>
301 class XnEventT : public XnEvent1Arg<const TEventArgs&>
302 {};
303 
304 template<class TArg1, class TArg2>
305 class XnEvent2Args : public XnEventInterfaceT<typename XnHandlerFunc2Args<TArg1, TArg2>::FuncPtr>
306 {
308 
309 public:
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 
326 template<class TArg1, class TArg2, class TArg3>
327 class XnEvent3Args : public XnEventInterfaceT<typename XnHandlerFunc3Args<TArg1, TArg2, TArg3>::FuncPtr>
328 {
330 
331 public:
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 
348 template<class TArg1, class TArg2, class TArg3, class TArg4>
349 class XnEvent4Args : public XnEventInterfaceT<typename XnHandlerFunc4Args<TArg1, TArg2, TArg3, TArg4>::FuncPtr>
350 {
352 
353 public:
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 
370 template<class TArg1, class TArg2, class TArg3, class TArg4, class TArg5>
371 class XnEvent5Args : public XnEventInterfaceT<typename XnHandlerFunc5Args<TArg1, TArg2, TArg3, TArg4, TArg5>::FuncPtr>
372 {
374 
375 public:
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_
XnEventInterfaceT TInterface
Definition: XnEventT.h:60
Definition: XnEventT.h:252
XnStatus Raise(TArg1 arg1, TArg2 arg2)
Definition: XnEventT.h:310
XnListT< TCallback * > CallbackPtrList
Definition: XnEventT.h:120
CallbackPtrList m_toAdd
Definition: XnEventT.h:206
ConstIterator Find(T const &value) const
Definition: XnListT.h:415
XN_CRITICAL_SECTION_HANDLE m_hLock
Definition: XnEventT.h:204
~XnEventInterfaceT()
Definition: XnEventT.h:62
#define XN_IS_STATUS_OK(x)
Definition: XnMacros.h:59
#define FALSE
Definition: XnPlatform.h:84
Definition: XnEventT.h:234
XnStatus ApplyListChanges()
Definition: XnEventT.h:169
XnEventInterfaceT & operator=(const XnEventInterfaceT &other)
Definition: XnEventT.h:134
Definition: XnEventT.h:301
FuncPtr pFunc
Definition: XnEventT.h:45
#define XN_STATUS_OK
Definition: XnStatus.h:36
XnCallbackT(FuncPtr func, void *cookie)
Definition: XnEventT.h:43
CallbackPtrList m_toRemove
Definition: XnEventT.h:207
CallbackPtrList m_callbacks
Definition: XnEventT.h:205
void(* FuncPtr)(TArg1 arg1, TArg2 arg2, void *pCookie)
Definition: XnEventT.h:236
XnStatus Raise(TArg1 arg1, TArg2 arg2, TArg3 arg3)
Definition: XnEventT.h:332
#define XN_VALIDATE_NEW(ptr, type,...)
Definition: XnOS.h:167
XnUInt32 XnStatus
Definition: XnStatus.h:33
Definition: XnEventT.h:228
XnBool RemoveCallback(CallbackPtrList &list, TCallback *pCallback)
Definition: XnEventT.h:191
void * pCookie
Definition: XnEventT.h:46
Definition: XnEventT.h:327
void(* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, void *pCookie)
Definition: XnEventT.h:242
#define TRUE
Definition: XnPlatform.h:80
void(* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4, void *pCookie)
Definition: XnEventT.h:248
Definition: XnEventT.h:305
XnStatus Raise()
Definition: XnEventT.h:261
XnStatus Register(FuncPtr pFunc, void *pCookie, XnCallbackHandle &hCallback)
Definition: XnEventT.h:68
XnStatus Clear()
Definition: XnEventT.h:152
void * XnCallbackHandle
Definition: XnTypes.h:270
Definition: XnOSCpp.h:32
Definition: XnEventT.h:246
XN_C_API XnStatus XN_C_DECL xnOSCloseCriticalSection(XN_CRITICAL_SECTION_HANDLE *pCriticalSectionHandle)
Iterator Begin()
Definition: XnListT.h:285
XnEventInterfaceT()
Definition: XnEventT.h:123
#define XN_VALIDATE_INPUT_PTR(x)
Definition: XnOS.h:122
XnStatus Clear()
Definition: XnListT.h:491
Definition: XnEventT.h:258
#define XN_DELETE(p)
Definition: XnOS.h:335
XnStatus Raise(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4, TArg5 arg5)
Definition: XnEventT.h:376
XnCallbackT< FuncPtr > TCallback
Definition: XnEventT.h:59
void(* FuncPtr)(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4, TArg5 arg5, void *pCookie)
Definition: XnEventT.h:254
XnStatus Remove(ConstIterator where)
Definition: XnListT.h:446
Definition: XnEventT.h:222
void(* FuncPtr)(TArg1 arg1, void *pCookie)
Definition: XnEventT.h:230
Definition: XnEventT.h:41
Iterator End()
Definition: XnListT.h:301
Definition: XnEventT.h:349
XnStatus Raise(TArg1 arg1, TArg2 arg2, TArg3 arg3, TArg4 arg4)
Definition: XnEventT.h:354
XnEventInterfaceT(const XnEventInterfaceT &other)
Definition: XnEventT.h:128
XN_C_API XnStatus XN_C_DECL xnOSCreateCriticalSection(XN_CRITICAL_SECTION_HANDLE *pCriticalSectionHandle)
XnStatus Unregister(XnCallbackHandle hCallback)
Definition: XnEventT.h:96
XnStatus Raise(TArg1 arg)
Definition: XnEventT.h:284
Definition: XnEventT.h:279
void(* FuncPtr)(void *pCookie)
Definition: XnEventT.h:224
Definition: XnEventT.h:240
Definition: XnEventT.h:371
FuncPtr HandlerPtr
Definition: XnEventT.h:58
Definition: XnEventT.h:55
XnStatus AddLast(T const &value)
Definition: XnListT.h:403