A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
traced-value.h
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2005,2006,2007 INRIA
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
19  */
20 #ifndef TRACED_VALUE_H
21 #define TRACED_VALUE_H
22 
23 #include "traced-callback.h"
24 #include "integer.h"
25 #include "uinteger.h"
26 #include "boolean.h"
27 #include "double.h"
28 #include "enum.h"
29 
30 #define TRACED_VALUE_DEBUG(x)
31 
32 namespace ns3 {
33 
52 template <typename T>
53 class TracedValue
54 {
55 public:
56  TracedValue ()
57  : m_v () {}
58  TracedValue (const TracedValue &o)
59  : m_v (o.m_v) {}
60  TracedValue (const T &v)
61  : m_v (v) {}
62  operator T () const {
63  return m_v;
64  }
65  TracedValue &operator = (const TracedValue &o) {
66  TRACED_VALUE_DEBUG ("x=");
67  Set (o.m_v);
68  return *this;
69  }
70  template <typename U>
71  TracedValue (const TracedValue<U> &other)
72  : m_v (other.m_v)
73  {}
74  template <typename U>
75  TracedValue (const U &other)
76  : m_v ((T)other)
77  {}
78  void ConnectWithoutContext (const CallbackBase &cb) {
79  m_cb.ConnectWithoutContext (cb);
80  }
81  void Connect (const CallbackBase &cb, std::string path) {
82  m_cb.Connect (cb, path);
83  }
84  void DisconnectWithoutContext (const CallbackBase &cb) {
85  m_cb.DisconnectWithoutContext (cb);
86  }
87  void Disconnect (const CallbackBase &cb, std::string path) {
88  m_cb.Disconnect (cb, path);
89  }
90  void Set (const T &v) {
91  if (m_v != v)
92  {
93  m_cb (m_v, v);
94  m_v = v;
95  }
96  }
97  T Get (void) const {
98  return m_v;
99  }
100  TracedValue &operator++ () {
101  TRACED_VALUE_DEBUG ("++x");
102  T tmp = Get ();
103  ++tmp;
104  Set (tmp);
105  return *this;
106  }
107  TracedValue &operator-- () {
108  TRACED_VALUE_DEBUG ("--x");
109  T tmp = Get ();
110  --tmp;
111  Set (tmp);
112  return *this;
113  }
114  TracedValue operator++ (int) {
115  TRACED_VALUE_DEBUG ("x++");
116  TracedValue old (*this);
117  T tmp = Get ();
118  tmp++;
119  Set (tmp);
120  return old;
121  }
122  TracedValue operator-- (int) {
123  TRACED_VALUE_DEBUG ("x--");
124  TracedValue old (*this);
125  T tmp = Get ();
126  tmp--;
127  Set (tmp);
128  return old;
129  }
130 private:
131  T m_v;
132  TracedCallback<T,T> m_cb;
133 };
134 
135 template <typename T>
136 std::ostream& operator << (std::ostream& os, const TracedValue<T>& rhs)
137 {
138  return os<<rhs.Get ();
139 }
140 
141 template <typename T, typename U>
142 bool operator == (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
143 {
144  TRACED_VALUE_DEBUG ("x==x");
145  return lhs.Get () == rhs.Get ();
146 }
147 template <typename T, typename U>
148 bool operator == (const TracedValue<T> &lhs, const U &rhs)
149 {
150  TRACED_VALUE_DEBUG ("x==");
151  return lhs.Get () == rhs;
152 }
153 template <typename T, typename U>
154 bool operator == (const U &lhs, const TracedValue<T> &rhs)
155 {
156  TRACED_VALUE_DEBUG ("==x");
157  return lhs == rhs.Get ();
158 }
159 
160 template <typename T, typename U>
161 bool operator != (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
162 {
163  TRACED_VALUE_DEBUG ("x!=x");
164  return lhs.Get () != rhs.Get ();
165 }
166 template <typename T, typename U>
167 bool operator != (const TracedValue<T> &lhs, const U &rhs)
168 {
169  TRACED_VALUE_DEBUG ("x!=");
170  return lhs.Get () != rhs;
171 }
172 template <typename T, typename U>
173 bool operator != (const U &lhs, const TracedValue<T> &rhs)
174 {
175  TRACED_VALUE_DEBUG ("!=x");
176  return lhs != rhs.Get ();
177 }
178 
179 template <typename T, typename U>
180 bool operator <= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
181 {
182  TRACED_VALUE_DEBUG ("x<=x");
183  return lhs.Get () <= rhs.Get ();
184 }
185 template <typename T, typename U>
186 bool operator <= (const TracedValue<T> &lhs, const U &rhs)
187 {
188  TRACED_VALUE_DEBUG ("x<=");
189  return lhs.Get () <= rhs;
190 }
191 template <typename T, typename U>
192 bool operator <= (const U &lhs, const TracedValue<T> &rhs)
193 {
194  TRACED_VALUE_DEBUG ("<=x");
195  return lhs <= rhs.Get ();
196 }
197 template <typename T, typename U>
198 bool operator >= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
199 {
200  TRACED_VALUE_DEBUG ("x>=x");
201  return lhs.Get () >= rhs.Get ();
202 }
203 template <typename T, typename U>
204 bool operator >= (const TracedValue<T> &lhs, const U &rhs)
205 {
206  TRACED_VALUE_DEBUG ("x>=");
207  return lhs.Get () >= rhs;
208 }
209 template <typename T, typename U>
210 bool operator >= (const U &lhs, const TracedValue<T> &rhs)
211 {
212  TRACED_VALUE_DEBUG (">=x");
213  return lhs >= rhs.Get ();
214 }
215 
216 template <typename T, typename U>
217 bool operator < (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
218 {
219  TRACED_VALUE_DEBUG ("x<x");
220  return lhs.Get () < rhs.Get ();
221 }
222 template <typename T, typename U>
223 bool operator < (const TracedValue<T> &lhs, const U &rhs)
224 {
225  TRACED_VALUE_DEBUG ("x<");
226  return lhs.Get () < rhs;
227 }
228 template <typename T, typename U>
229 bool operator < (const U &lhs, const TracedValue<T> &rhs)
230 {
231  TRACED_VALUE_DEBUG ("<x");
232  return lhs < rhs.Get ();
233 }
234 template <typename T, typename U>
235 bool operator > (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
236 {
237  TRACED_VALUE_DEBUG ("x>x");
238  return lhs.Get () > rhs.Get ();
239 }
240 template <typename T, typename U>
241 bool operator > (const TracedValue<T> &lhs, const U &rhs)
242 {
243  TRACED_VALUE_DEBUG ("x>");
244  return lhs.Get () > rhs;
245 }
246 template <typename T, typename U>
247 bool operator > (const U &lhs, const TracedValue<T> &rhs)
248 {
249  TRACED_VALUE_DEBUG (">x");
250  return lhs > rhs.Get ();
251 }
252 template <typename T, typename U>
253 TracedValue<T> &operator += (TracedValue<T> &lhs, const U &rhs) {
254  TRACED_VALUE_DEBUG ("x+=");
255  T tmp = lhs.Get ();
256  tmp += rhs;
257  lhs.Set (tmp);
258  return lhs;
259 }
260 template <typename T, typename U>
261 TracedValue<T> &operator -= (TracedValue<T> &lhs, const U &rhs) {
262  TRACED_VALUE_DEBUG ("x-=");
263  T tmp = lhs.Get ();
264  tmp -= rhs;
265  lhs.Set (tmp);
266  return lhs;
267 }
268 template <typename T, typename U>
269 TracedValue<T> &operator *= (TracedValue<T> &lhs, const U &rhs) {
270  TRACED_VALUE_DEBUG ("x*=");
271  T tmp = lhs.Get ();
272  tmp *= rhs;
273  lhs.Set (tmp);
274  return lhs;
275 }
276 template <typename T, typename U>
277 TracedValue<T> &operator /= (TracedValue<T> &lhs, const U &rhs) {
278  TRACED_VALUE_DEBUG ("x/=");
279  T tmp = lhs.Get ();
280  tmp /= rhs;
281  lhs.Set (tmp);
282  return lhs;
283 }
284 template <typename T, typename U>
285 TracedValue<T> &operator %= (TracedValue<T> &lhs, const U &rhs) {
286  TRACED_VALUE_DEBUG ("x%=");
287  T tmp = lhs.Get ();
288  tmp %= rhs;
289  lhs.Set (tmp);
290  return lhs;
291 }
292 template <typename T, typename U>
293 TracedValue<T> &operator <<= (TracedValue<T> &lhs, const U &rhs) {
294  TRACED_VALUE_DEBUG ("x<<=");
295  T tmp = lhs.Get ();
296  tmp <<= rhs;
297  lhs.Set (tmp);
298  return lhs;
299 }
300 template <typename T, typename U>
301 TracedValue<T> &operator >>= (TracedValue<T> &lhs, const U &rhs) {
302  TRACED_VALUE_DEBUG ("x>>=");
303  T tmp = lhs.Get ();
304  tmp >>= rhs;
305  lhs.Set (tmp);
306  return lhs;
307 }
308 template <typename T, typename U>
309 TracedValue<T> &operator &= (TracedValue<T> &lhs, const U &rhs) {
310  TRACED_VALUE_DEBUG ("x&=");
311  T tmp = lhs.Get ();
312  tmp &= rhs;
313  lhs.Set (tmp);
314  return lhs;
315 }
316 template <typename T, typename U>
317 TracedValue<T> &operator |= (TracedValue<T> &lhs, const U &rhs) {
318  TRACED_VALUE_DEBUG ("x|=");
319  T tmp = lhs.Get ();
320  tmp |= rhs;
321  lhs.Set (tmp);
322  return lhs;
323 }
324 template <typename T, typename U>
325 TracedValue<T> &operator ^= (TracedValue<T> &lhs, const U &rhs) {
326  TRACED_VALUE_DEBUG ("x^=");
327  T tmp = lhs.Get ();
328  tmp ^= rhs;
329  lhs.Set (tmp);
330  return lhs;
331 }
332 template <typename T, typename U>
333 TracedValue<T> operator + (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
334  TRACED_VALUE_DEBUG ("x+x");
335  return TracedValue<T> (lhs.Get () + rhs.Get ());
336 }
337 template <typename T, typename U>
338 TracedValue<T> operator + (const TracedValue<T> &lhs, const U &rhs) {
339  TRACED_VALUE_DEBUG ("x+");
340  return TracedValue<T> (lhs.Get () + rhs);
341 }
342 template <typename T, typename U>
343 TracedValue<T> operator + (const U &lhs, const TracedValue<T> &rhs) {
344  TRACED_VALUE_DEBUG ("+x");
345  return TracedValue<T> (lhs + rhs.Get ());
346 }
347 
348 template <typename T, typename U>
349 TracedValue<T> operator - (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
350  TRACED_VALUE_DEBUG ("x-x");
351  return TracedValue<T> (lhs.Get () - rhs.Get ());
352 }
353 template <typename T, typename U>
354 TracedValue<T> operator - (const TracedValue<T> &lhs, const U &rhs) {
355  TRACED_VALUE_DEBUG ("x-");
356  return TracedValue<T> (lhs.Get () - rhs);
357 }
358 template <typename T, typename U>
359 TracedValue<T> operator - (const U &lhs, const TracedValue<T> &rhs) {
360  TRACED_VALUE_DEBUG ("-x");
361  return TracedValue<T> (lhs - rhs.Get ());
362 }
363 
364 template <typename T, typename U>
365 TracedValue<T> operator * (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
366  TRACED_VALUE_DEBUG ("x*x");
367  return TracedValue<T> (lhs.Get () * rhs.Get ());
368 }
369 template <typename T, typename U>
370 TracedValue<T> operator * (const TracedValue<T> &lhs, const U &rhs) {
371  TRACED_VALUE_DEBUG ("x*");
372  return TracedValue<T> (lhs.Get () * rhs);
373 }
374 template <typename T, typename U>
375 TracedValue<T> operator * (const U &lhs, const TracedValue<T> &rhs) {
376  TRACED_VALUE_DEBUG ("*x");
377  return TracedValue<T> (lhs * rhs.Get ());
378 }
379 
380 template <typename T, typename U>
381 TracedValue<T> operator / (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
382  TRACED_VALUE_DEBUG ("x/x");
383  return TracedValue<T> (lhs.Get () / rhs.Get ());
384 }
385 template <typename T, typename U>
386 TracedValue<T> operator / (const TracedValue<T> &lhs, const U &rhs) {
387  TRACED_VALUE_DEBUG ("x/");
388  return TracedValue<T> (lhs.Get () / rhs);
389 }
390 template <typename T, typename U>
391 TracedValue<T> operator / (const U &lhs, const TracedValue<T> &rhs) {
392  TRACED_VALUE_DEBUG ("/x");
393  return TracedValue<T> (lhs / rhs.Get ());
394 }
395 
396 template <typename T, typename U>
397 TracedValue<T> operator % (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
398  TRACED_VALUE_DEBUG ("x%x");
399  return TracedValue<T> (lhs.Get () % rhs.Get ());
400 }
401 template <typename T, typename U>
402 TracedValue<T> operator % (const TracedValue<T> &lhs, const U &rhs) {
403  TRACED_VALUE_DEBUG ("x%");
404  return TracedValue<T> (lhs.Get () % rhs);
405 }
406 template <typename T, typename U>
407 TracedValue<T> operator % (const U &lhs, const TracedValue<T> &rhs) {
408  TRACED_VALUE_DEBUG ("%x");
409  return TracedValue<T> (lhs % rhs.Get ());
410 }
411 
412 template <typename T, typename U>
413 TracedValue<T> operator ^ (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
414  TRACED_VALUE_DEBUG ("x^x");
415  return TracedValue<T> (lhs.Get () ^ rhs.Get ());
416 }
417 template <typename T, typename U>
418 TracedValue<T> operator ^ (const TracedValue<T> &lhs, const U &rhs) {
419  TRACED_VALUE_DEBUG ("x^");
420  return TracedValue<T> (lhs.Get () ^ rhs);
421 }
422 template <typename T, typename U>
423 TracedValue<T> operator ^ (const U &lhs, const TracedValue<T> &rhs) {
424  TRACED_VALUE_DEBUG ("^x");
425  return TracedValue<T> (lhs ^ rhs.Get ());
426 }
427 
428 template <typename T, typename U>
429 TracedValue<T> operator | (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
430  TRACED_VALUE_DEBUG ("x|x");
431  return TracedValue<T> (lhs.Get () | rhs.Get ());
432 }
433 template <typename T, typename U>
434 TracedValue<T> operator | (const TracedValue<T> &lhs, const U &rhs) {
435  TRACED_VALUE_DEBUG ("x|");
436  return TracedValue<T> (lhs.Get () | rhs);
437 }
438 template <typename T, typename U>
439 TracedValue<T> operator | (const U &lhs, const TracedValue<T> &rhs) {
440  TRACED_VALUE_DEBUG ("|x");
441  return TracedValue<T> (lhs | rhs.Get ());
442 }
443 
444 template <typename T, typename U>
445 TracedValue<T> operator & (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
446  TRACED_VALUE_DEBUG ("x&x");
447  return TracedValue<T> (lhs.Get () & rhs.Get ());
448 }
449 template <typename T, typename U>
450 TracedValue<T> operator & (const TracedValue<T> &lhs, const U &rhs) {
451  TRACED_VALUE_DEBUG ("x&");
452  return TracedValue<T> (lhs.Get () & rhs);
453 }
454 template <typename T, typename U>
455 TracedValue<T> operator & (const U &lhs, const TracedValue<T> &rhs) {
456  TRACED_VALUE_DEBUG ("&x");
457  return TracedValue<T> (lhs & rhs.Get ());
458 }
459 
460 template <typename T, typename U>
461 TracedValue<T> operator << (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
462  TRACED_VALUE_DEBUG ("x<<x");
463  return TracedValue<T> (lhs.Get () << rhs.Get ());
464 }
465 template <typename T, typename U>
466 TracedValue<T> operator << (const TracedValue<T> &lhs, const U &rhs) {
467  TRACED_VALUE_DEBUG ("x<<");
468  return TracedValue<T> (lhs.Get () << rhs);
469 }
470 template <typename T, typename U>
471 TracedValue<T> operator << (const U &lhs, const TracedValue<T> &rhs) {
472  TRACED_VALUE_DEBUG ("<<x");
473  return TracedValue<T> (lhs << rhs.Get ());
474 }
475 
476 template <typename T, typename U>
477 TracedValue<T> operator >> (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
478  TRACED_VALUE_DEBUG ("x>>x");
479  return TracedValue<T> (lhs.Get () >> rhs.Get ());
480 }
481 template <typename T, typename U>
482 TracedValue<T> operator >> (const TracedValue<T> &lhs, const U &rhs) {
483  TRACED_VALUE_DEBUG ("x>>");
484  return TracedValue<T> (lhs.Get () >> rhs);
485 }
486 template <typename T, typename U>
487 TracedValue<T> operator >> (const U &lhs, const TracedValue<T> &rhs) {
488  TRACED_VALUE_DEBUG (">>x");
489  return TracedValue<T> (lhs >> rhs.Get ());
490 }
491 
492 
493 template <typename T>
494 TracedValue<T> operator + (const TracedValue<T> &lhs) {
495  TRACED_VALUE_DEBUG ("(+x)");
496  return TracedValue<T> (+lhs.Get ());
497 }
498 template <typename T>
499 TracedValue<T> operator - (const TracedValue<T> &lhs) {
500  TRACED_VALUE_DEBUG ("(-x)");
501  return TracedValue<T> (-lhs.Get ());
502 }
503 template <typename T>
504 TracedValue<T> operator ~ (const TracedValue<T> &lhs) {
505  TRACED_VALUE_DEBUG ("(~x)");
506  return TracedValue<T> (~lhs.Get ());
507 }
508 template <typename T>
509 TracedValue<T> operator ! (const TracedValue<T> &lhs) {
510  TRACED_VALUE_DEBUG ("(!x)");
511  return TracedValue<T> (!lhs.Get ());
512 }
513 
514 
515 } // namespace ns3
516 
517 #endif /* TRACED_VALUE_H */
ns3::operator!
TracedValue< T > operator!(const TracedValue< T > &lhs)
Definition: traced-value.h:509
ns3::operator>>
std::istream & operator>>(std::istream &is, Angles &a)
initialize a struct Angles from input
Definition: angles.cc:49
ns3::operator%=
TracedValue< T > & operator%=(TracedValue< T > &lhs, const U &rhs)
Definition: traced-value.h:285
ns3::TracedValue::operator=
TracedValue & operator=(const TracedValue &o)
Definition: traced-value.h:65
ns3::operator>
bool operator>(const Time &lhs, const Time &rhs)
Definition: nstime.h:645
ns3::operator~
TracedValue< T > operator~(const TracedValue< T > &lhs)
Definition: traced-value.h:504
ns3::operator*
TracedValue< T > operator*(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Definition: traced-value.h:365
ns3::CallbackBase
Base class for Callback class.
Definition: callback.h:844
ns3::TracedValue::Disconnect
void Disconnect(const CallbackBase &cb, std::string path)
Definition: traced-value.h:87
ns3::TracedValue::Set
void Set(const T &v)
Definition: traced-value.h:90
ns3::TracedValue
trace classes with value semantics
Definition: traced-value.h:53
ns3::TracedValue::Get
T Get(void) const
Definition: traced-value.h:97
ns3::TracedValue::TracedValue
TracedValue(const TracedValue< U > &other)
Definition: traced-value.h:71
ns3::operator&=
TracedValue< T > & operator&=(TracedValue< T > &lhs, const U &rhs)
Definition: traced-value.h:309
ns3::TracedValue::ConnectWithoutContext
void ConnectWithoutContext(const CallbackBase &cb)
Definition: traced-value.h:78
ns3::operator+=
Time & operator+=(Time &lhs, const Time &rhs)
Definition: nstime.h:657
ns3::TracedValue::Connect
void Connect(const CallbackBase &cb, std::string path)
Definition: traced-value.h:81
ns3::operator*=
TracedValue< T > & operator*=(TracedValue< T > &lhs, const U &rhs)
Definition: traced-value.h:269
ns3::TracedCallback::DisconnectWithoutContext
void DisconnectWithoutContext(const CallbackBase &callback)
Definition: traced-callback.h:138
ns3::TracedValue::operator--
TracedValue & operator--()
Definition: traced-value.h:107
ns3::operator+
Time operator+(const Time &lhs, const Time &rhs)
Definition: nstime.h:649
ns3::operator^=
TracedValue< T > & operator^=(TracedValue< T > &lhs, const U &rhs)
Definition: traced-value.h:325
ns3::TracedCallback::Disconnect
void Disconnect(const CallbackBase &callback, std::string path)
Definition: traced-callback.h:158
ns3::operator|=
TracedValue< T > & operator|=(TracedValue< T > &lhs, const U &rhs)
Definition: traced-value.h:317
ns3::operator/
TracedValue< T > operator/(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Definition: traced-value.h:381
ns3::TracedValue::TracedValue
TracedValue(const U &other)
Definition: traced-value.h:75
ns3::operator-=
Time & operator-=(Time &lhs, const Time &rhs)
Definition: nstime.h:662
ns3::operator!=
bool operator!=(Callback< R, T1, T2, T3, T4, T5, T6, T7, T8, T9 > a, Callback< R, T1, T2, T3, T4, T5, T6, T7, T8, T9 > b)
Inequality test.
Definition: callback.h:1213
ns3::operator>=
bool operator>=(const Time &lhs, const Time &rhs)
Definition: nstime.h:635
ns3::operator>>=
TracedValue< T > & operator>>=(TracedValue< T > &lhs, const U &rhs)
Definition: traced-value.h:301
ns3::operator-
Time operator-(const Time &lhs, const Time &rhs)
Definition: nstime.h:653
ns3::TracedValue::TracedValue
TracedValue(const T &v)
Definition: traced-value.h:60
ns3::operator&
TracedValue< T > operator&(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Definition: traced-value.h:445
ns3::TracedCallback::Connect
void Connect(const CallbackBase &callback, std::string path)
Definition: traced-callback.h:126
ns3::TracedValue::TracedValue
TracedValue(const TracedValue &o)
Definition: traced-value.h:58
ns3::operator/=
TracedValue< T > & operator/=(TracedValue< T > &lhs, const U &rhs)
Definition: traced-value.h:277
ns3::TracedCallback::ConnectWithoutContext
void ConnectWithoutContext(const CallbackBase &callback)
Definition: traced-callback.h:115
ns3::operator==
bool operator==(const EventId &a, const EventId &b)
Definition: event-id.cc:89
ns3::operator^
TracedValue< T > operator^(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Definition: traced-value.h:413
ns3::TracedValue::DisconnectWithoutContext
void DisconnectWithoutContext(const CallbackBase &cb)
Definition: traced-value.h:84
TRACED_VALUE_DEBUG
#define TRACED_VALUE_DEBUG(x)
Definition: traced-value.h:30
ns3::operator|
TracedValue< T > operator|(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Definition: traced-value.h:429
ns3::TracedValue::operator++
TracedValue & operator++()
Definition: traced-value.h:100
ns3::operator%
TracedValue< T > operator%(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Definition: traced-value.h:397
ns3::TracedValue::m_cb
TracedCallback< T, T > m_cb
Definition: traced-value.h:132