A Discrete-Event Network Simulator
API
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 
48 #define TRACED_VALUE_DEBUG(x)
49 
50 namespace ns3 {
51 
70 namespace TracedValueCallback {
71 
82  typedef void (* Bool) (bool oldValue, bool newValue);
83  typedef void (* Int8) (int8_t oldValue, int8_t newValue);
84  typedef void (* Uint8) (uint8_t oldValue, uint8_t newValue);
85  typedef void (* Int16) (int16_t oldValue, int16_t newValue);
86  typedef void (* Uint16)(uint16_t oldValue, uint16_t newValue);
87  typedef void (* Int32) (int32_t oldValue, int32_t newValue);
88  typedef void (* Uint32)(uint32_t oldValue, uint32_t newValue);
89  typedef void (* Double)(double oldValue, double newValue);
91 } // namespace TracedValueCallback
92 
93 
109 template <typename T>
110 class TracedValue
111 {
112 public:
114  TracedValue ()
115  : m_v () {}
120  TracedValue (const TracedValue &o)
121  : m_v (o.m_v) {}
126  TracedValue (const T &v)
127  : m_v (v) {}
132  operator T () const {
133  return m_v;
134  }
140  TracedValue &operator = (const TracedValue &o) {
141  TRACED_VALUE_DEBUG ("x=");
142  Set (o.m_v);
143  return *this;
144  }
150  template <typename U>
151  TracedValue (const TracedValue<U> &other)
152  : m_v (other.m_v)
153  {}
159  template <typename U>
160  TracedValue (const U &other)
161  : m_v ((T)other)
162  {}
168  void ConnectWithoutContext (const CallbackBase &cb) {
169  m_cb.ConnectWithoutContext (cb);
170  }
180  void Connect (const CallbackBase &cb, std::string path) {
181  m_cb.Connect (cb, path);
182  }
188  void DisconnectWithoutContext (const CallbackBase &cb) {
189  m_cb.DisconnectWithoutContext (cb);
190  }
197  void Disconnect (const CallbackBase &cb, std::string path) {
198  m_cb.Disconnect (cb, path);
199  }
206  void Set (const T &v) {
207  if (m_v != v)
208  {
209  m_cb (m_v, v);
210  m_v = v;
211  }
212  }
217  T Get (void) const {
218  return m_v;
219  }
227  TracedValue &operator++ () {
228  TRACED_VALUE_DEBUG ("++x");
229  T tmp = Get ();
230  ++tmp;
231  Set (tmp);
232  return *this;
233  }
234  TracedValue &operator-- () {
235  TRACED_VALUE_DEBUG ("--x");
236  T tmp = Get ();
237  --tmp;
238  Set (tmp);
239  return *this;
240  }
241  TracedValue operator++ (int) {
242  TRACED_VALUE_DEBUG ("x++");
243  TracedValue old (*this);
244  T tmp = Get ();
245  tmp++;
246  Set (tmp);
247  return old;
248  }
249  TracedValue operator-- (int) {
250  TRACED_VALUE_DEBUG ("x--");
251  TracedValue old (*this);
252  T tmp = Get ();
253  tmp--;
254  Set (tmp);
255  return old;
256  }
259 private:
261  T m_v;
263  TracedCallback<T,T> m_cb;
264 };
265 
266 
267 /********************************************************************
268  Operator implementations for TracedValue
269  ********************************************************************/
270 
285 template <typename T>
286 std::ostream& operator << (std::ostream& os, const TracedValue<T>& rhs)
287 {
288  return os<<rhs.Get ();
289 }
290 
299 template <typename T, typename U>
300 bool operator == (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
301 {
302  TRACED_VALUE_DEBUG ("x==x");
303  return lhs.Get () == rhs.Get ();
304 }
306 template <typename T, typename U>
307 bool operator == (const TracedValue<T> &lhs, const U &rhs)
308 {
309  TRACED_VALUE_DEBUG ("x==");
310  return lhs.Get () == rhs;
311 }
313 template <typename T, typename U>
314 bool operator == (const U &lhs, const TracedValue<T> &rhs)
315 {
316  TRACED_VALUE_DEBUG ("==x");
317  return lhs == rhs.Get ();
318 }
319 
321 template <typename T, typename U>
322 bool operator != (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
323 {
324  TRACED_VALUE_DEBUG ("x!=x");
325  return lhs.Get () != rhs.Get ();
326 }
328 template <typename T, typename U>
329 bool operator != (const TracedValue<T> &lhs, const U &rhs)
330 {
331  TRACED_VALUE_DEBUG ("x!=");
332  return lhs.Get () != rhs;
333 }
335 template <typename T, typename U>
336 bool operator != (const U &lhs, const TracedValue<T> &rhs)
337 {
338  TRACED_VALUE_DEBUG ("!=x");
339  return lhs != rhs.Get ();
340 }
341 
343 template <typename T, typename U>
344 bool operator <= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
345 {
346  TRACED_VALUE_DEBUG ("x<=x");
347  return lhs.Get () <= rhs.Get ();
348 }
350 template <typename T, typename U>
351 bool operator <= (const TracedValue<T> &lhs, const U &rhs)
352 {
353  TRACED_VALUE_DEBUG ("x<=");
354  return lhs.Get () <= rhs;
355 }
357 template <typename T, typename U>
358 bool operator <= (const U &lhs, const TracedValue<T> &rhs)
359 {
360  TRACED_VALUE_DEBUG ("<=x");
361  return lhs <= rhs.Get ();
362 }
364 template <typename T, typename U>
365 bool operator >= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
366 {
367  TRACED_VALUE_DEBUG ("x>=x");
368  return lhs.Get () >= rhs.Get ();
369 }
371 template <typename T, typename U>
372 bool operator >= (const TracedValue<T> &lhs, const U &rhs)
373 {
374  TRACED_VALUE_DEBUG ("x>=");
375  return lhs.Get () >= rhs;
376 }
378 template <typename T, typename U>
379 bool operator >= (const U &lhs, const TracedValue<T> &rhs)
380 {
381  TRACED_VALUE_DEBUG (">=x");
382  return lhs >= rhs.Get ();
383 }
384 
386 template <typename T, typename U>
387 bool operator < (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
388 {
389  TRACED_VALUE_DEBUG ("x<x");
390  return lhs.Get () < rhs.Get ();
391 }
393 template <typename T, typename U>
394 bool operator < (const TracedValue<T> &lhs, const U &rhs)
395 {
396  TRACED_VALUE_DEBUG ("x<");
397  return lhs.Get () < rhs;
398 }
400 template <typename T, typename U>
401 bool operator < (const U &lhs, const TracedValue<T> &rhs)
402 {
403  TRACED_VALUE_DEBUG ("<x");
404  return lhs < rhs.Get ();
405 }
407 template <typename T, typename U>
408 bool operator > (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
409 {
410  TRACED_VALUE_DEBUG ("x>x");
411  return lhs.Get () > rhs.Get ();
412 }
414 template <typename T, typename U>
415 bool operator > (const TracedValue<T> &lhs, const U &rhs)
416 {
417  TRACED_VALUE_DEBUG ("x>");
418  return lhs.Get () > rhs;
419 }
421 template <typename T, typename U>
422 bool operator > (const U &lhs, const TracedValue<T> &rhs)
423 {
424  TRACED_VALUE_DEBUG (">x");
425  return lhs > rhs.Get ();
426 }
427 
428 
442 template <typename T, typename U>
443 TracedValue<T> operator + (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
444  TRACED_VALUE_DEBUG ("x+x");
445  return TracedValue<T> (lhs.Get () + rhs.Get ());
446 }
448 template <typename T, typename U>
449 TracedValue<T> operator + (const TracedValue<T> &lhs, const U &rhs) {
450  TRACED_VALUE_DEBUG ("x+");
451  return TracedValue<T> (lhs.Get () + rhs);
452 }
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 
461 template <typename T, typename U>
462 TracedValue<T> operator - (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
463  TRACED_VALUE_DEBUG ("x-x");
464  return TracedValue<T> (lhs.Get () - rhs.Get ());
465 }
467 template <typename T, typename U>
468 TracedValue<T> operator - (const TracedValue<T> &lhs, const U &rhs) {
469  TRACED_VALUE_DEBUG ("x-");
470  return TracedValue<T> (lhs.Get () - rhs);
471 }
473 template <typename T, typename U>
474 TracedValue<T> operator - (const U &lhs, const TracedValue<T> &rhs) {
475  TRACED_VALUE_DEBUG ("-x");
476  return TracedValue<T> (lhs - rhs.Get ());
477 }
478 
480 template <typename T, typename U>
481 TracedValue<T> operator * (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
482  TRACED_VALUE_DEBUG ("x*x");
483  return TracedValue<T> (lhs.Get () * rhs.Get ());
484 }
486 template <typename T, typename U>
487 TracedValue<T> operator * (const TracedValue<T> &lhs, const U &rhs) {
488  TRACED_VALUE_DEBUG ("x*");
489  return TracedValue<T> (lhs.Get () * rhs);
490 }
492 template <typename T, typename U>
493 TracedValue<T> operator * (const U &lhs, const TracedValue<T> &rhs) {
494  TRACED_VALUE_DEBUG ("*x");
495  return TracedValue<T> (lhs * rhs.Get ());
496 }
497 
499 template <typename T, typename U>
500 TracedValue<T> operator / (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
501  TRACED_VALUE_DEBUG ("x/x");
502  return TracedValue<T> (lhs.Get () / rhs.Get ());
503 }
505 template <typename T, typename U>
506 TracedValue<T> operator / (const TracedValue<T> &lhs, const U &rhs) {
507  TRACED_VALUE_DEBUG ("x/");
508  return TracedValue<T> (lhs.Get () / rhs);
509 }
511 template <typename T, typename U>
512 TracedValue<T> operator / (const U &lhs, const TracedValue<T> &rhs) {
513  TRACED_VALUE_DEBUG ("/x");
514  return TracedValue<T> (lhs / rhs.Get ());
515 }
516 
518 template <typename T, typename U>
519 TracedValue<T> operator % (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
520  TRACED_VALUE_DEBUG ("x%x");
521  return TracedValue<T> (lhs.Get () % rhs.Get ());
522 }
524 template <typename T, typename U>
525 TracedValue<T> operator % (const TracedValue<T> &lhs, const U &rhs) {
526  TRACED_VALUE_DEBUG ("x%");
527  return TracedValue<T> (lhs.Get () % rhs);
528 }
530 template <typename T, typename U>
531 TracedValue<T> operator % (const U &lhs, const TracedValue<T> &rhs) {
532  TRACED_VALUE_DEBUG ("%x");
533  return TracedValue<T> (lhs % rhs.Get ());
534 }
535 
537 template <typename T, typename U>
538 TracedValue<T> operator ^ (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
539  TRACED_VALUE_DEBUG ("x^x");
540  return TracedValue<T> (lhs.Get () ^ rhs.Get ());
541 }
543 template <typename T, typename U>
544 TracedValue<T> operator ^ (const TracedValue<T> &lhs, const U &rhs) {
545  TRACED_VALUE_DEBUG ("x^");
546  return TracedValue<T> (lhs.Get () ^ rhs);
547 }
549 template <typename T, typename U>
550 TracedValue<T> operator ^ (const U &lhs, const TracedValue<T> &rhs) {
551  TRACED_VALUE_DEBUG ("^x");
552  return TracedValue<T> (lhs ^ rhs.Get ());
553 }
554 
556 template <typename T, typename U>
557 TracedValue<T> operator | (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
558  TRACED_VALUE_DEBUG ("x|x");
559  return TracedValue<T> (lhs.Get () | rhs.Get ());
560 }
562 template <typename T, typename U>
563 TracedValue<T> operator | (const TracedValue<T> &lhs, const U &rhs) {
564  TRACED_VALUE_DEBUG ("x|");
565  return TracedValue<T> (lhs.Get () | rhs);
566 }
568 template <typename T, typename U>
569 TracedValue<T> operator | (const U &lhs, const TracedValue<T> &rhs) {
570  TRACED_VALUE_DEBUG ("|x");
571  return TracedValue<T> (lhs | rhs.Get ());
572 }
573 
575 template <typename T, typename U>
576 TracedValue<T> operator & (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
577  TRACED_VALUE_DEBUG ("x&x");
578  return TracedValue<T> (lhs.Get () & rhs.Get ());
579 }
581 template <typename T, typename U>
582 TracedValue<T> operator & (const TracedValue<T> &lhs, const U &rhs) {
583  TRACED_VALUE_DEBUG ("x&");
584  return TracedValue<T> (lhs.Get () & rhs);
585 }
587 template <typename T, typename U>
588 TracedValue<T> operator & (const U &lhs, const TracedValue<T> &rhs) {
589  TRACED_VALUE_DEBUG ("&x");
590  return TracedValue<T> (lhs & rhs.Get ());
591 }
592 
594 template <typename T, typename U>
595 TracedValue<T> operator << (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
596  TRACED_VALUE_DEBUG ("x<<x");
597  return TracedValue<T> (lhs.Get () << rhs.Get ());
598 }
600 template <typename T, typename U>
601 TracedValue<T> operator << (const TracedValue<T> &lhs, const U &rhs) {
602  TRACED_VALUE_DEBUG ("x<<");
603  return TracedValue<T> (lhs.Get () << rhs);
604 }
606 template <typename T, typename U>
607 TracedValue<T> operator << (const U &lhs, const TracedValue<T> &rhs) {
608  TRACED_VALUE_DEBUG ("<<x");
609  return TracedValue<T> (lhs << rhs.Get ());
610 }
611 
613 template <typename T, typename U>
614 TracedValue<T> operator >> (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
615  TRACED_VALUE_DEBUG ("x>>x");
616  return TracedValue<T> (lhs.Get () >> rhs.Get ());
617 }
619 template <typename T, typename U>
620 TracedValue<T> operator >> (const TracedValue<T> &lhs, const U &rhs) {
621  TRACED_VALUE_DEBUG ("x>>");
622  return TracedValue<T> (lhs.Get () >> rhs);
623 }
625 template <typename T, typename U>
626 TracedValue<T> operator >> (const U &lhs, const TracedValue<T> &rhs) {
627  TRACED_VALUE_DEBUG (">>x");
628  return TracedValue<T> (lhs >> rhs.Get ());
629 }
630 
645 template <typename T, typename U>
646 TracedValue<T> &operator += (TracedValue<T> &lhs, const U &rhs) {
647  TRACED_VALUE_DEBUG ("x+=");
648  T tmp = lhs.Get ();
649  tmp += rhs;
650  lhs.Set (tmp);
651  return lhs;
652 }
654 template <typename T, typename U>
655 TracedValue<T> &operator -= (TracedValue<T> &lhs, const U &rhs) {
656  TRACED_VALUE_DEBUG ("x-=");
657  T tmp = lhs.Get ();
658  tmp -= rhs;
659  lhs.Set (tmp);
660  return lhs;
661 }
663 template <typename T, typename U>
664 TracedValue<T> &operator *= (TracedValue<T> &lhs, const U &rhs) {
665  TRACED_VALUE_DEBUG ("x*=");
666  T tmp = lhs.Get ();
667  tmp *= rhs;
668  lhs.Set (tmp);
669  return lhs;
670 }
672 template <typename T, typename U>
673 TracedValue<T> &operator /= (TracedValue<T> &lhs, const U &rhs) {
674  TRACED_VALUE_DEBUG ("x/=");
675  T tmp = lhs.Get ();
676  tmp /= rhs;
677  lhs.Set (tmp);
678  return lhs;
679 }
681 template <typename T, typename U>
682 TracedValue<T> &operator %= (TracedValue<T> &lhs, const U &rhs) {
683  TRACED_VALUE_DEBUG ("x%=");
684  T tmp = lhs.Get ();
685  tmp %= rhs;
686  lhs.Set (tmp);
687  return lhs;
688 }
690 template <typename T, typename U>
691 TracedValue<T> &operator <<= (TracedValue<T> &lhs, const U &rhs) {
692  TRACED_VALUE_DEBUG ("x<<=");
693  T tmp = lhs.Get ();
694  tmp <<= rhs;
695  lhs.Set (tmp);
696  return lhs;
697 }
699 template <typename T, typename U>
700 TracedValue<T> &operator >>= (TracedValue<T> &lhs, const U &rhs) {
701  TRACED_VALUE_DEBUG ("x>>=");
702  T tmp = lhs.Get ();
703  tmp >>= rhs;
704  lhs.Set (tmp);
705  return lhs;
706 }
708 template <typename T, typename U>
709 TracedValue<T> &operator &= (TracedValue<T> &lhs, const U &rhs) {
710  TRACED_VALUE_DEBUG ("x&=");
711  T tmp = lhs.Get ();
712  tmp &= rhs;
713  lhs.Set (tmp);
714  return lhs;
715 }
717 template <typename T, typename U>
718 TracedValue<T> &operator |= (TracedValue<T> &lhs, const U &rhs) {
719  TRACED_VALUE_DEBUG ("x|=");
720  T tmp = lhs.Get ();
721  tmp |= rhs;
722  lhs.Set (tmp);
723  return lhs;
724 }
726 template <typename T, typename U>
727 TracedValue<T> &operator ^= (TracedValue<T> &lhs, const U &rhs) {
728  TRACED_VALUE_DEBUG ("x^=");
729  T tmp = lhs.Get ();
730  tmp ^= rhs;
731  lhs.Set (tmp);
732  return lhs;
733 }
734 
735 
744 template <typename T>
745 TracedValue<T> operator + (const TracedValue<T> &lhs) {
746  TRACED_VALUE_DEBUG ("(+x)");
747  return TracedValue<T> (+lhs.Get ());
748 }
750 template <typename T>
751 TracedValue<T> operator - (const TracedValue<T> &lhs) {
752  TRACED_VALUE_DEBUG ("(-x)");
753  return TracedValue<T> (-lhs.Get ());
754 }
756 template <typename T>
757 TracedValue<T> operator ~ (const TracedValue<T> &lhs) {
758  TRACED_VALUE_DEBUG ("(~x)");
759  return TracedValue<T> (~lhs.Get ());
760 }
762 template <typename T>
763 TracedValue<T> operator ! (const TracedValue<T> &lhs) {
764  TRACED_VALUE_DEBUG ("(!x)");
765  return TracedValue<T> (!lhs.Get ());
766 }
767  // \ingroup tracing
769 
770 } // namespace ns3
771 
772 #endif /* TRACED_VALUE_H */
boolean.h
Boolean attribute value declarations.
double.h
Double attribute value declarations and template implementations.
ns3::operator>>
std::istream & operator>>(std::istream &is, Angles &a)
initialize a struct Angles from input
Definition: angles.cc:48
ns3::operator|=
TracedValue< T > & operator|=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:718
ns3::operator+
int64x64_t operator+(const int64x64_t &lhs)
Unary plus operator.
Definition: int64x64-128.h:410
ns3::operator/=
int64x64_t & operator/=(int64x64_t &lhs, const int64x64_t &rhs)
Compound division operator.
Definition: int64x64-128.h:400
ns3::TracedValue::m_v
T m_v
The underlying value.
Definition: traced-value.h:261
uinteger.h
Unsigned integer attribute value declarations and template implementations.
ns3::TracedValue::operator=
TracedValue & operator=(const TracedValue &o)
Assignment.
Definition: traced-value.h:140
ns3::operator-
int64x64_t operator-(const int64x64_t &lhs)
Unary negation operator (change sign operator).
Definition: int64x64-128.h:418
ns3::operator&
TracedValue< T > operator&(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Infix arithmetic operator for TracedValue.
Definition: traced-value.h:576
ns3::CallbackBase
Base class for Callback class.
Definition: callback.h:1092
ns3::TracedValue::Disconnect
void Disconnect(const CallbackBase &cb, std::string path)
Disconnect a Callback which was connected with context.
Definition: traced-value.h:197
ns3::TracedValueCallback::Uint8
void(* Uint8)(uint8_t oldValue, uint8_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:84
ns3::operator+=
int64x64_t & operator+=(int64x64_t &lhs, const int64x64_t &rhs)
Compound addition operator.
Definition: int64x64-128.h:373
ns3::TracedValue::Set
void Set(const T &v)
Set the value of the underlying variable.
Definition: traced-value.h:206
ns3::TracedValue
Trace classes with value semantics.
Definition: traced-value.h:110
ns3::TracedValue::Get
T Get(void) const
Get the underlying value.
Definition: traced-value.h:217
ns3::operator>=
bool operator>=(const int64x64_t &lhs, const int64x64_t &rhs)
Greater or equal operator.
Definition: int64x64.h:145
ns3::TracedValue::TracedValue
TracedValue(const TracedValue< U > &other)
Copy from a TracedValue of a compatable type.
Definition: traced-value.h:151
ns3::TracedValueCallback::Int16
void(* Int16)(int16_t oldValue, int16_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:85
ns3::operator~
TracedValue< T > operator~(const TracedValue< T > &lhs)
Unary arithmetic operator for TracedValue.
Definition: traced-value.h:757
traced-callback.h
ns3::TracedCallback declaration and template implementation.
ns3::TracedValue::ConnectWithoutContext
void ConnectWithoutContext(const CallbackBase &cb)
Connect a Callback (without context.)
Definition: traced-value.h:168
ns3::operator*
int64x64_t operator*(const int64x64_t &lhs, const int64x64_t &rhs)
Multiplication operator.
Definition: int64x64.h:108
ns3::TracedValue::Connect
void Connect(const CallbackBase &cb, std::string path)
Connect a Callback with a context string.
Definition: traced-value.h:180
ns3::operator^
TracedValue< T > operator^(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Infix arithmetic operator for TracedValue.
Definition: traced-value.h:538
ns3::TracedValue::TracedValue
TracedValue()
Default constructor.
Definition: traced-value.h:114
ns3::TracedValueCallback::Int8
void(* Int8)(int8_t oldValue, int8_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:83
ns3::TracedCallback::DisconnectWithoutContext
void DisconnectWithoutContext(const CallbackBase &callback)
Remove from the chain a Callback which was connected without a context.
Definition: traced-callback.h:289
enum.h
Enum attribute value declarations.
ns3::TracedValue::operator--
TracedValue & operator--()
Pre/post- increment/decrement operator.
Definition: traced-value.h:234
ns3::TracedCallback::Disconnect
void Disconnect(const CallbackBase &callback, std::string path)
Remove from the chain a Callback which was connected with a context.
Definition: traced-callback.h:309
ns3::TracedValueCallback::Int32
void(* Int32)(int32_t oldValue, int32_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:87
ns3::TracedValue::TracedValue
TracedValue(const U &other)
Copy from a variable type compatible with this underlying type.
Definition: traced-value.h:160
ns3::operator%=
TracedValue< T > & operator%=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:682
ns3::operator/
int64x64_t operator/(const int64x64_t &lhs, const int64x64_t &rhs)
Division operator.
Definition: int64x64.h:119
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:1462
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::operator*=
int64x64_t & operator*=(int64x64_t &lhs, const int64x64_t &rhs)
Compound multiplication operator.
Definition: int64x64-128.h:391
ns3::operator>>=
TracedValue< T > & operator>>=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:700
ns3::operator%
TracedValue< T > operator%(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Infix arithmetic operator for TracedValue.
Definition: traced-value.h:519
ns3::operator^=
TracedValue< T > & operator^=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:727
ns3::TracedValue::TracedValue
TracedValue(const T &v)
Construct from an explicit variable.
Definition: traced-value.h:126
ns3::TracedCallback::Connect
void Connect(const CallbackBase &callback, std::string path)
Append a Callback to the chain with a context.
Definition: traced-callback.h:276
ns3::TracedValue::TracedValue
TracedValue(const TracedValue &o)
Copy constructor.
Definition: traced-value.h:120
ns3::TracedValueCallback::Double
void(* Double)(double oldValue, double newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:89
ns3::TracedCallback::ConnectWithoutContext
void ConnectWithoutContext(const CallbackBase &callback)
Append a Callback to the chain (without a context).
Definition: traced-callback.h:264
ns3::operator&=
TracedValue< T > & operator&=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:709
ns3::operator>
bool operator>(const int64x64_t &lhs, const int64x64_t &rhs)
Greater operator.
Definition: int64x64-128.h:364
ns3::operator==
bool operator==(const EventId &a, const EventId &b)
Definition: event-id.cc:95
integer.h
Integer attribute value declarations and template implementations.
ns3::TracedValue::DisconnectWithoutContext
void DisconnectWithoutContext(const CallbackBase &cb)
Disconnect a Callback which was connected without context.
Definition: traced-value.h:188
TRACED_VALUE_DEBUG
#define TRACED_VALUE_DEBUG(x)
Logging macro for TracedValue.
Definition: traced-value.h:48
ns3::TracedValueCallback::Uint16
void(* Uint16)(uint16_t oldValue, uint16_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:86
ns3::operator|
TracedValue< T > operator|(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Infix arithmetic operator for TracedValue.
Definition: traced-value.h:557
ns3::TracedValue::operator++
TracedValue & operator++()
Pre/post- increment/decrement operator.
Definition: traced-value.h:227
ns3::TracedValueCallback::Uint32
void(* Uint32)(uint32_t oldValue, uint32_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:88
ns3::TracedValue::m_cb
TracedCallback< T, T > m_cb
The connected Callback.
Definition: traced-value.h:263
ns3::operator!
int64x64_t operator!(const int64x64_t &lhs)
Logical not operator.
Definition: int64x64-128.h:426
ns3::TracedValueCallback::Bool
void(* Bool)(bool oldValue, bool newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:82
ns3::operator-=
int64x64_t & operator-=(int64x64_t &lhs, const int64x64_t &rhs)
Compound subtraction operator.
Definition: int64x64-128.h:382