A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
make-event.h
Go to the documentation of this file.
1 #ifndef MAKE_EVENT_H
2 #define MAKE_EVENT_H
3 
4 namespace ns3 {
5 
6 class EventImpl;
7 
8 template <typename MEM, typename OBJ>
9 EventImpl * MakeEvent (MEM mem_ptr, OBJ obj);
10 
11 template <typename MEM, typename OBJ,
12  typename T1>
13 EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1);
14 
15 template <typename MEM, typename OBJ,
16  typename T1, typename T2>
17 EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2);
18 
19 template <typename MEM, typename OBJ,
20  typename T1, typename T2, typename T3>
21 EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);
22 
23 template <typename MEM, typename OBJ,
24  typename T1, typename T2, typename T3, typename T4>
25 EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4);
26 
27 template <typename MEM, typename OBJ,
28  typename T1, typename T2, typename T3, typename T4, typename T5>
29 EventImpl * MakeEvent (MEM mem_ptr, OBJ obj,
30  T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
31 
32 EventImpl * MakeEvent (void (*f)(void));
33 template <typename U1,
34  typename T1>
35 EventImpl * MakeEvent (void (*f)(U1), T1 a1);
36 
37 template <typename U1, typename U2,
38  typename T1, typename T2>
39 EventImpl * MakeEvent (void (*f)(U1,U2), T1 a1, T2 a2);
40 
41 template <typename U1, typename U2, typename U3,
42  typename T1, typename T2, typename T3>
43 EventImpl * MakeEvent (void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3);
44 
45 template <typename U1, typename U2, typename U3, typename U4,
46  typename T1, typename T2, typename T3, typename T4>
47 EventImpl * MakeEvent (void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4);
48 
49 template <typename U1, typename U2, typename U3, typename U4, typename U5,
50  typename T1, typename T2, typename T3, typename T4, typename T5>
51 EventImpl * MakeEvent (void (*f)(U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
52 
53 } // namespace ns3
54 
55 /********************************************************************
56  Implementation of templates defined above
57  ********************************************************************/
58 
59 #include "event-impl.h"
60 #include "type-traits.h"
61 
62 namespace ns3 {
63 
64 template <typename T>
66 
67 template <typename T>
69 {
70  static T &GetReference (T *p)
71  {
72  return *p;
73  }
74 };
75 
76 template <typename MEM, typename OBJ>
77 EventImpl * MakeEvent (MEM mem_ptr, OBJ obj)
78 {
79  // zero argument version
80  class EventMemberImpl0 : public EventImpl
81  {
82 public:
83  EventMemberImpl0 (OBJ obj, MEM function)
84  : m_obj (obj),
85  m_function (function)
86  {
87  }
88  virtual ~EventMemberImpl0 ()
89  {
90  }
91 private:
92  virtual void Notify (void)
93  {
94  (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function)();
95  }
96  OBJ m_obj;
97  MEM m_function;
98  } *ev = new EventMemberImpl0 (obj, mem_ptr);
99  return ev;
100 }
101 
102 
103 template <typename MEM, typename OBJ,
104  typename T1>
105 EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1)
106 {
107  // one argument version
108  class EventMemberImpl1 : public EventImpl
109  {
110 public:
111  EventMemberImpl1 (OBJ obj, MEM function, T1 a1)
112  : m_obj (obj),
113  m_function (function),
114  m_a1 (a1)
115  {
116  }
117 protected:
118  virtual ~EventMemberImpl1 ()
119  {
120  }
121 private:
122  virtual void Notify (void)
123  {
124  (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function)(m_a1);
125  }
126  OBJ m_obj;
127  MEM m_function;
128  typename TypeTraits<T1>::ReferencedType m_a1;
129  } *ev = new EventMemberImpl1 (obj, mem_ptr, a1);
130  return ev;
131 }
132 
133 template <typename MEM, typename OBJ,
134  typename T1, typename T2>
135 EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2)
136 {
137  // two argument version
138  class EventMemberImpl2 : public EventImpl
139  {
140 public:
141  EventMemberImpl2 (OBJ obj, MEM function, T1 a1, T2 a2)
142  : m_obj (obj),
143  m_function (function),
144  m_a1 (a1),
145  m_a2 (a2)
146  {
147  }
148 protected:
149  virtual ~EventMemberImpl2 ()
150  {
151  }
152 private:
153  virtual void Notify (void)
154  {
155  (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function)(m_a1, m_a2);
156  }
157  OBJ m_obj;
158  MEM m_function;
159  typename TypeTraits<T1>::ReferencedType m_a1;
160  typename TypeTraits<T2>::ReferencedType m_a2;
161  } *ev = new EventMemberImpl2 (obj, mem_ptr, a1, a2);
162  return ev;
163 }
164 
165 template <typename MEM, typename OBJ,
166  typename T1, typename T2, typename T3>
167 EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3)
168 {
169  // three argument version
170  class EventMemberImpl3 : public EventImpl
171  {
172 public:
173  EventMemberImpl3 (OBJ obj, MEM function, T1 a1, T2 a2, T3 a3)
174  : m_obj (obj),
175  m_function (function),
176  m_a1 (a1),
177  m_a2 (a2),
178  m_a3 (a3)
179  {
180  }
181 protected:
182  virtual ~EventMemberImpl3 ()
183  {
184  }
185 private:
186  virtual void Notify (void)
187  {
188  (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function)(m_a1, m_a2, m_a3);
189  }
190  OBJ m_obj;
191  MEM m_function;
192  typename TypeTraits<T1>::ReferencedType m_a1;
193  typename TypeTraits<T2>::ReferencedType m_a2;
194  typename TypeTraits<T3>::ReferencedType m_a3;
195  } *ev = new EventMemberImpl3 (obj, mem_ptr, a1, a2, a3);
196  return ev;
197 }
198 
199 template <typename MEM, typename OBJ,
200  typename T1, typename T2, typename T3, typename T4>
201 EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4)
202 {
203  // four argument version
204  class EventMemberImpl4 : public EventImpl
205  {
206 public:
207  EventMemberImpl4 (OBJ obj, MEM function, T1 a1, T2 a2, T3 a3, T4 a4)
208  : m_obj (obj),
209  m_function (function),
210  m_a1 (a1),
211  m_a2 (a2),
212  m_a3 (a3),
213  m_a4 (a4)
214  {
215  }
216 protected:
217  virtual ~EventMemberImpl4 ()
218  {
219  }
220 private:
221  virtual void Notify (void)
222  {
223  (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function)(m_a1, m_a2, m_a3, m_a4);
224  }
225  OBJ m_obj;
226  MEM m_function;
227  typename TypeTraits<T1>::ReferencedType m_a1;
228  typename TypeTraits<T2>::ReferencedType m_a2;
229  typename TypeTraits<T3>::ReferencedType m_a3;
230  typename TypeTraits<T4>::ReferencedType m_a4;
231  } *ev = new EventMemberImpl4 (obj, mem_ptr, a1, a2, a3, a4);
232  return ev;
233 }
234 
235 template <typename MEM, typename OBJ,
236  typename T1, typename T2, typename T3, typename T4, typename T5>
237 EventImpl * MakeEvent (MEM mem_ptr, OBJ obj,
238  T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
239 {
240  // five argument version
241  class EventMemberImpl5 : public EventImpl
242  {
243 public:
244  EventMemberImpl5 (OBJ obj, MEM function, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
245  : m_obj (obj),
246  m_function (function),
247  m_a1 (a1),
248  m_a2 (a2),
249  m_a3 (a3),
250  m_a4 (a4),
251  m_a5 (a5)
252  {
253  }
254 protected:
255  virtual ~EventMemberImpl5 ()
256  {
257  }
258 private:
259  virtual void Notify (void)
260  {
261  (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function)(m_a1, m_a2, m_a3, m_a4, m_a5);
262  }
263  OBJ m_obj;
264  MEM m_function;
265  typename TypeTraits<T1>::ReferencedType m_a1;
266  typename TypeTraits<T2>::ReferencedType m_a2;
267  typename TypeTraits<T3>::ReferencedType m_a3;
268  typename TypeTraits<T4>::ReferencedType m_a4;
269  typename TypeTraits<T5>::ReferencedType m_a5;
270  } *ev = new EventMemberImpl5 (obj, mem_ptr, a1, a2, a3, a4, a5);
271  return ev;
272 }
273 
274 template <typename U1, typename T1>
275 EventImpl * MakeEvent (void (*f)(U1), T1 a1)
276 {
277  // one arg version
278  class EventFunctionImpl1 : public EventImpl
279  {
280 public:
281  typedef void (*F)(U1);
282 
283  EventFunctionImpl1 (F function, T1 a1)
284  : m_function (function),
285  m_a1 (a1)
286  {
287  }
288 protected:
289  virtual ~EventFunctionImpl1 ()
290  {
291  }
292 private:
293  virtual void Notify (void)
294  {
295  (*m_function)(m_a1);
296  }
297  F m_function;
298  typename TypeTraits<T1>::ReferencedType m_a1;
299  } *ev = new EventFunctionImpl1 (f, a1);
300  return ev;
301 }
302 
303 template <typename U1, typename U2, typename T1, typename T2>
304 EventImpl * MakeEvent (void (*f)(U1,U2), T1 a1, T2 a2)
305 {
306  // two arg version
307  class EventFunctionImpl2 : public EventImpl
308  {
309 public:
310  typedef void (*F)(U1, U2);
311 
312  EventFunctionImpl2 (F function, T1 a1, T2 a2)
313  : m_function (function),
314  m_a1 (a1),
315  m_a2 (a2)
316  {
317  }
318 protected:
319  virtual ~EventFunctionImpl2 ()
320  {
321  }
322 private:
323  virtual void Notify (void)
324  {
325  (*m_function)(m_a1, m_a2);
326  }
327  F m_function;
328  typename TypeTraits<T1>::ReferencedType m_a1;
329  typename TypeTraits<T2>::ReferencedType m_a2;
330  } *ev = new EventFunctionImpl2 (f, a1, a2);
331  return ev;
332 }
333 
334 template <typename U1, typename U2, typename U3,
335  typename T1, typename T2, typename T3>
336 EventImpl * MakeEvent (void (*f)(U1,U2,U3), T1 a1, T2 a2, T3 a3)
337 {
338  // three arg version
339  class EventFunctionImpl3 : public EventImpl
340  {
341 public:
342  typedef void (*F)(U1, U2, U3);
343 
344  EventFunctionImpl3 (F function, T1 a1, T2 a2, T3 a3)
345  : m_function (function),
346  m_a1 (a1),
347  m_a2 (a2),
348  m_a3 (a3)
349  {
350  }
351 protected:
352  virtual ~EventFunctionImpl3 ()
353  {
354  }
355 private:
356  virtual void Notify (void)
357  {
358  (*m_function)(m_a1, m_a2, m_a3);
359  }
360  F m_function;
361  typename TypeTraits<T1>::ReferencedType m_a1;
362  typename TypeTraits<T2>::ReferencedType m_a2;
363  typename TypeTraits<T3>::ReferencedType m_a3;
364  } *ev = new EventFunctionImpl3 (f, a1, a2, a3);
365  return ev;
366 }
367 
368 template <typename U1, typename U2, typename U3, typename U4,
369  typename T1, typename T2, typename T3, typename T4>
370 EventImpl * MakeEvent (void (*f)(U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4)
371 {
372  // four arg version
373  class EventFunctionImpl4 : public EventImpl
374  {
375 public:
376  typedef void (*F)(U1, U2, U3, U4);
377 
378  EventFunctionImpl4 (F function, T1 a1, T2 a2, T3 a3, T4 a4)
379  : m_function (function),
380  m_a1 (a1),
381  m_a2 (a2),
382  m_a3 (a3),
383  m_a4 (a4)
384  {
385  }
386 protected:
387  virtual ~EventFunctionImpl4 ()
388  {
389  }
390 private:
391  virtual void Notify (void)
392  {
393  (*m_function)(m_a1, m_a2, m_a3, m_a4);
394  }
395  F m_function;
396  typename TypeTraits<T1>::ReferencedType m_a1;
397  typename TypeTraits<T2>::ReferencedType m_a2;
398  typename TypeTraits<T3>::ReferencedType m_a3;
399  typename TypeTraits<T4>::ReferencedType m_a4;
400  } *ev = new EventFunctionImpl4 (f, a1, a2, a3, a4);
401  return ev;
402 }
403 
404 template <typename U1, typename U2, typename U3, typename U4, typename U5,
405  typename T1, typename T2, typename T3, typename T4, typename T5>
406 EventImpl * MakeEvent (void (*f)(U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
407 {
408  // five arg version
409  class EventFunctionImpl5 : public EventImpl
410  {
411 public:
412  typedef void (*F)(U1,U2,U3,U4,U5);
413 
414  EventFunctionImpl5 (F function, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
415  : m_function (function),
416  m_a1 (a1),
417  m_a2 (a2),
418  m_a3 (a3),
419  m_a4 (a4),
420  m_a5 (a5)
421  {
422  }
423 protected:
424  virtual ~EventFunctionImpl5 ()
425  {
426  }
427 private:
428  virtual void Notify (void)
429  {
430  (*m_function)(m_a1, m_a2, m_a3, m_a4, m_a5);
431  }
432  F m_function;
433  typename TypeTraits<T1>::ReferencedType m_a1;
434  typename TypeTraits<T2>::ReferencedType m_a2;
435  typename TypeTraits<T3>::ReferencedType m_a3;
436  typename TypeTraits<T4>::ReferencedType m_a4;
437  typename TypeTraits<T5>::ReferencedType m_a5;
438  } *ev = new EventFunctionImpl5 (f, a1, a2, a3, a4, a5);
439  return ev;
440 }
441 
442 } // namespace ns3
443 
444 #endif /* MAKE_EVENT_H */
ReferenceTraits< T >::ReferencedType ReferencedType
Referenced type.
Definition: type-traits.h:286
a simulation event
Definition: event-impl.h:39
EventImpl * MakeEvent(void(*f)(void))
Definition: make-event.cc:8