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 (* Int64) (int64_t oldValue, int64_t newValue);
90 typedef void (* Uint64)(uint64_t oldValue, uint64_t newValue);
91 typedef void (* Double)(double oldValue, double newValue);
92 typedef void (* Void) (void);
94 } // namespace TracedValueCallback
95 
96 
112 template <typename T>
113 class TracedValue
114 {
115 public:
117  TracedValue ()
118  : m_v ()
119  {}
124  TracedValue (const TracedValue &o)
125  : m_v (o.m_v)
126  {}
131  TracedValue (const T &v)
132  : m_v (v)
133  {}
138  operator T () const {
139  return m_v;
140  }
146  TracedValue &operator = (const TracedValue &o)
147  {
148  TRACED_VALUE_DEBUG ("x=");
149  Set (o.m_v);
150  return *this;
151  }
157  template <typename U>
158  TracedValue (const TracedValue<U> &other)
159  : m_v (other.Get ())
160  {}
166  template <typename U>
167  TracedValue (const U &other)
168  : m_v ((T)other)
169  {}
175  void ConnectWithoutContext (const CallbackBase &cb)
176  {
177  m_cb.ConnectWithoutContext (cb);
178  }
188  void Connect (const CallbackBase &cb, std::string path)
189  {
190  m_cb.Connect (cb, path);
191  }
197  void DisconnectWithoutContext (const CallbackBase &cb)
198  {
199  m_cb.DisconnectWithoutContext (cb);
200  }
207  void Disconnect (const CallbackBase &cb, std::string path)
208  {
209  m_cb.Disconnect (cb, path);
210  }
217  void Set (const T &v)
218  {
219  if (m_v != v)
220  {
221  m_cb (m_v, v);
222  m_v = v;
223  }
224  }
229  T Get (void) const
230  {
231  return m_v;
232  }
240  TracedValue &operator++ ()
241  {
242  TRACED_VALUE_DEBUG ("++x");
243  T tmp = Get ();
244  ++tmp;
245  Set (tmp);
246  return *this;
247  }
248  TracedValue &operator-- ()
249  {
250  TRACED_VALUE_DEBUG ("--x");
251  T tmp = Get ();
252  --tmp;
253  Set (tmp);
254  return *this;
255  }
256  TracedValue operator++ (int)
257  {
258  TRACED_VALUE_DEBUG ("x++");
259  TracedValue old (*this);
260  T tmp = Get ();
261  tmp++;
262  Set (tmp);
263  return old;
264  }
265  TracedValue operator-- (int)
266  {
267  TRACED_VALUE_DEBUG ("x--");
268  TracedValue old (*this);
269  T tmp = Get ();
270  tmp--;
271  Set (tmp);
272  return old;
273  }
276 private:
278  T m_v;
280  TracedCallback<T,T> m_cb;
281 };
282 
283 
284 /********************************************************************
285  Operator implementations for TracedValue
286  ********************************************************************/
287 
302 template <typename T>
303 std::ostream& operator << (std::ostream& os, const TracedValue<T>& rhs)
304 {
305  return os << rhs.Get ();
306 }
307 
316 template <typename T, typename U>
317 bool operator == (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
318 {
319  TRACED_VALUE_DEBUG ("x==x");
320  return lhs.Get () == rhs.Get ();
321 }
323 template <typename T, typename U>
324 bool operator == (const TracedValue<T> &lhs, const U &rhs)
325 {
326  TRACED_VALUE_DEBUG ("x==");
327  return lhs.Get () == rhs;
328 }
330 template <typename T, typename U>
331 bool operator == (const U &lhs, const TracedValue<T> &rhs)
332 {
333  TRACED_VALUE_DEBUG ("==x");
334  return lhs == rhs.Get ();
335 }
336 
338 template <typename T, typename U>
339 bool operator != (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
340 {
341  TRACED_VALUE_DEBUG ("x!=x");
342  return lhs.Get () != rhs.Get ();
343 }
345 template <typename T, typename U>
346 bool operator != (const TracedValue<T> &lhs, const U &rhs)
347 {
348  TRACED_VALUE_DEBUG ("x!=");
349  return lhs.Get () != rhs;
350 }
352 template <typename T, typename U>
353 bool operator != (const U &lhs, const TracedValue<T> &rhs)
354 {
355  TRACED_VALUE_DEBUG ("!=x");
356  return lhs != rhs.Get ();
357 }
358 
360 template <typename T, typename U>
361 bool operator <= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
362 {
363  TRACED_VALUE_DEBUG ("x<=x");
364  return lhs.Get () <= rhs.Get ();
365 }
367 template <typename T, typename U>
368 bool operator <= (const TracedValue<T> &lhs, const U &rhs)
369 {
370  TRACED_VALUE_DEBUG ("x<=");
371  return lhs.Get () <= rhs;
372 }
374 template <typename T, typename U>
375 bool operator <= (const U &lhs, const TracedValue<T> &rhs)
376 {
377  TRACED_VALUE_DEBUG ("<=x");
378  return lhs <= rhs.Get ();
379 }
381 template <typename T, typename U>
382 bool operator >= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
383 {
384  TRACED_VALUE_DEBUG ("x>=x");
385  return lhs.Get () >= rhs.Get ();
386 }
388 template <typename T, typename U>
389 bool operator >= (const TracedValue<T> &lhs, const U &rhs)
390 {
391  TRACED_VALUE_DEBUG ("x>=");
392  return lhs.Get () >= rhs;
393 }
395 template <typename T, typename U>
396 bool operator >= (const U &lhs, const TracedValue<T> &rhs)
397 {
398  TRACED_VALUE_DEBUG (">=x");
399  return lhs >= rhs.Get ();
400 }
401 
403 template <typename T, typename U>
404 bool operator < (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
405 {
406  TRACED_VALUE_DEBUG ("x<x");
407  return lhs.Get () < rhs.Get ();
408 }
410 template <typename T, typename U>
411 bool operator < (const TracedValue<T> &lhs, const U &rhs)
412 {
413  TRACED_VALUE_DEBUG ("x<");
414  return lhs.Get () < rhs;
415 }
417 template <typename T, typename U>
418 bool operator < (const U &lhs, const TracedValue<T> &rhs)
419 {
420  TRACED_VALUE_DEBUG ("<x");
421  return lhs < rhs.Get ();
422 }
424 template <typename T, typename U>
425 bool operator > (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
426 {
427  TRACED_VALUE_DEBUG ("x>x");
428  return lhs.Get () > rhs.Get ();
429 }
431 template <typename T, typename U>
432 bool operator > (const TracedValue<T> &lhs, const U &rhs)
433 {
434  TRACED_VALUE_DEBUG ("x>");
435  return lhs.Get () > rhs;
436 }
438 template <typename T, typename U>
439 bool operator > (const U &lhs, const TracedValue<T> &rhs)
440 {
441  TRACED_VALUE_DEBUG (">x");
442  return lhs > rhs.Get ();
443 }
444 
445 
459 template <typename T, typename U>
460 auto operator + (const TracedValue<T> &lhs, const TracedValue<U> &rhs)->TracedValue<decltype(lhs.Get () + rhs.Get ())>
461 {
462  TRACED_VALUE_DEBUG ("x+x");
463  return TracedValue<decltype(lhs.Get () + rhs.Get ())> (lhs.Get () + rhs.Get ());
464 }
466 template <typename T, typename U>
467 auto operator + (const TracedValue<T> &lhs, const U &rhs)->TracedValue<decltype(lhs.Get () + rhs)>
468 {
469  TRACED_VALUE_DEBUG ("x+");
470  return TracedValue<decltype(lhs.Get () + rhs)> (lhs.Get () + rhs);
471 }
473 template <typename T, typename U>
474 auto operator + (const U &lhs, const TracedValue<T> &rhs)->TracedValue<decltype(lhs + rhs.Get ())>
475 {
476  TRACED_VALUE_DEBUG ("+x");
477  return TracedValue<decltype(lhs + rhs.Get ())> (lhs + rhs.Get ());
478 }
479 
481 template <typename T, typename U>
482 auto operator - (const TracedValue<T> &lhs, const TracedValue<U> &rhs)->TracedValue<decltype(lhs.Get () - rhs.Get ())>
483 {
484  TRACED_VALUE_DEBUG ("x-x");
485  return TracedValue<decltype(lhs.Get () - rhs.Get ())> (lhs.Get () - rhs.Get ());
486 }
488 template <typename T, typename U>
489 auto operator - (const TracedValue<T> &lhs, const U &rhs)->TracedValue<decltype(lhs.Get () - rhs)>
490 {
491  TRACED_VALUE_DEBUG ("x-");
492  return TracedValue<decltype(lhs.Get () - rhs)> (lhs.Get () - rhs);
493 }
495 template <typename T, typename U>
496 auto operator - (const U &lhs, const TracedValue<T> &rhs)->TracedValue<decltype(lhs - rhs.Get ())>
497 {
498  TRACED_VALUE_DEBUG ("-x");
499  return TracedValue<decltype(lhs - rhs.Get ())> (lhs - rhs.Get ());
500 }
501 
503 template <typename T, typename U>
504 auto operator * (const TracedValue<T> &lhs, const TracedValue<U> &rhs)->TracedValue<decltype(lhs.Get () * rhs.Get ())>
505 {
506  TRACED_VALUE_DEBUG ("x*x");
507  return TracedValue<decltype(lhs.Get () * rhs.Get ())> (lhs.Get () * rhs.Get ());
508 }
510 template <typename T, typename U>
511 auto operator * (const TracedValue<T> &lhs, const U &rhs)->TracedValue<decltype(lhs.Get () * rhs)>
512 {
513  TRACED_VALUE_DEBUG ("x*");
514  return TracedValue<decltype(lhs.Get () * rhs)> (lhs.Get () * rhs);
515 }
517 template <typename T, typename U>
518 auto operator * (const U &lhs, const TracedValue<T> &rhs)->TracedValue<decltype(lhs + rhs.Get ())>
519 {
520  TRACED_VALUE_DEBUG ("*x");
521  return TracedValue<decltype(lhs + rhs.Get ())> (lhs * rhs.Get ());
522 }
523 
525 template <typename T, typename U>
526 auto operator / (const TracedValue<T> &lhs, const TracedValue<U> &rhs)->TracedValue<decltype(lhs.Get () / rhs.Get ())>
527 {
528  TRACED_VALUE_DEBUG ("x/x");
529  return TracedValue<decltype(lhs.Get () / rhs.Get ())> (lhs.Get () / rhs.Get ());
530 }
532 template <typename T, typename U>
533 auto operator / (const TracedValue<T> &lhs, const U &rhs)->TracedValue<decltype(lhs.Get () / rhs)>
534 {
535  TRACED_VALUE_DEBUG ("x/");
536  return TracedValue<decltype(lhs.Get () / rhs)> (lhs.Get () / rhs);
537 }
539 template <typename T, typename U>
540 auto operator / (const U &lhs, const TracedValue<T> &rhs)->TracedValue<decltype(lhs / rhs.Get ())>
541 {
542  TRACED_VALUE_DEBUG ("/x");
543  return TracedValue<decltype(lhs / rhs.Get ())> (lhs / rhs.Get ());
544 }
545 
547 template <typename T, typename U>
548 auto operator % (const TracedValue<T> &lhs, const TracedValue<U> &rhs)->TracedValue<decltype(lhs.Get () % rhs.Get ())>
549 {
550  TRACED_VALUE_DEBUG ("x%x");
551  return TracedValue<decltype(lhs.Get () % rhs.Get ())> (lhs.Get () % rhs.Get ());
552 }
554 template <typename T, typename U>
555 auto operator % (const TracedValue<T> &lhs, const U &rhs)->TracedValue<decltype(lhs.Get () % rhs)>
556 {
557  TRACED_VALUE_DEBUG ("x%");
558  return TracedValue<decltype(lhs.Get () % rhs)> (lhs.Get () % rhs);
559 }
561 template <typename T, typename U>
562 auto operator % (const U &lhs, const TracedValue<T> &rhs)->TracedValue<decltype(lhs % rhs.Get ())>
563 {
564  TRACED_VALUE_DEBUG ("%x");
565  return TracedValue<decltype(lhs % rhs.Get ())> (lhs % rhs.Get ());
566 }
567 
569 template <typename T, typename U>
570 auto operator ^ (const TracedValue<T> &lhs, const TracedValue<U> &rhs)->TracedValue<decltype(lhs.Get () ^ rhs.Get ())>
571 {
572  TRACED_VALUE_DEBUG ("x^x");
573  return TracedValue<decltype(lhs.Get () ^ rhs.Get ())> (lhs.Get () ^ rhs.Get ());
574 }
576 template <typename T, typename U>
577 auto operator ^ (const TracedValue<T> &lhs, const U &rhs)->TracedValue<decltype(lhs.Get () ^ rhs)>
578 {
579  TRACED_VALUE_DEBUG ("x^");
580  return TracedValue<decltype(lhs.Get () ^ rhs)> (lhs.Get () ^ rhs);
581 }
583 template <typename T, typename U>
584 auto operator ^ (const U &lhs, const TracedValue<T> &rhs)->TracedValue<decltype(lhs ^ rhs.Get ())>
585 {
586  TRACED_VALUE_DEBUG ("^x");
587  return TracedValue<decltype(lhs ^ rhs.Get ())> (lhs ^ rhs.Get ());
588 }
589 
591 template <typename T, typename U>
592 auto operator | (const TracedValue<T> &lhs, const TracedValue<U> &rhs)->TracedValue<decltype(lhs.Get () | rhs.Get ())>
593 {
594  TRACED_VALUE_DEBUG ("x|x");
595  return TracedValue<decltype(lhs.Get () | rhs.Get ())> (lhs.Get () | rhs.Get ());
596 }
598 template <typename T, typename U>
599 auto operator | (const TracedValue<T> &lhs, const U &rhs)->TracedValue<decltype(lhs.Get () | rhs)>
600 {
601  TRACED_VALUE_DEBUG ("x|");
602  return TracedValue<decltype(lhs.Get () | rhs)> (lhs.Get () | rhs);
603 }
605 template <typename T, typename U>
606 auto operator | (const U &lhs, const TracedValue<T> &rhs)->TracedValue<decltype(lhs | rhs.Get ())>
607 {
608  TRACED_VALUE_DEBUG ("|x");
609  return TracedValue<decltype(lhs | rhs.Get ())> (lhs | rhs.Get ());
610 }
611 
613 template <typename T, typename U>
614 auto operator & (const TracedValue<T> &lhs, const TracedValue<U> &rhs)->TracedValue<decltype(lhs.Get () & rhs.Get ())>
615 {
616  TRACED_VALUE_DEBUG ("x&x");
617  return TracedValue<decltype(lhs.Get () & rhs.Get ())> (lhs.Get () & rhs.Get ());
618 }
620 template <typename T, typename U>
621 auto operator & (const TracedValue<T> &lhs, const U &rhs)->TracedValue<decltype(lhs.Get () & rhs)>
622 {
623  TRACED_VALUE_DEBUG ("x&");
624  return TracedValue<decltype(lhs.Get () & rhs)> (lhs.Get () & rhs);
625 }
627 template <typename T, typename U>
628 auto operator & (const U &lhs, const TracedValue<T> &rhs)->TracedValue<decltype(lhs & rhs.Get ())>
629 {
630  TRACED_VALUE_DEBUG ("&x");
631  return TracedValue<decltype(lhs & rhs.Get ())> (lhs & rhs.Get ());
632 }
633 
635 template <typename T, typename U>
636 auto operator << (const TracedValue<T> &lhs, const TracedValue<U> &rhs)->TracedValue<decltype(lhs.Get () << rhs.Get ())>
637 {
638  TRACED_VALUE_DEBUG ("x<<x");
639  return TracedValue<decltype(lhs.Get () << rhs.Get ())> (lhs.Get () << rhs.Get ());
640 }
642 template <typename T, typename U>
643 auto operator << (const TracedValue<T> &lhs, const U &rhs)->TracedValue<decltype(lhs.Get () << rhs)>
644 {
645  TRACED_VALUE_DEBUG ("x<<");
646  return TracedValue<decltype(lhs.Get () << rhs)> (lhs.Get () << rhs);
647 }
649 template <typename T, typename U>
650 auto operator << (const U &lhs, const TracedValue<T> &rhs)->TracedValue<decltype(lhs << rhs.Get ())>
651 {
652  TRACED_VALUE_DEBUG ("<<x");
653  return TracedValue<decltype(lhs << rhs.Get ())> (lhs << rhs.Get ());
654 }
655 
657 template <typename T, typename U>
658 auto operator >> (const TracedValue<T> &lhs, const TracedValue<U> &rhs)->TracedValue<decltype(lhs.Get () >> rhs.Get ())>
659 {
660  TRACED_VALUE_DEBUG ("x>>x");
661  return TracedValue<decltype(lhs.Get () >> rhs.Get ())> (lhs.Get () >> rhs.Get ());
662 }
664 template <typename T, typename U>
665 auto operator >> (const TracedValue<T> &lhs, const U &rhs)->TracedValue<decltype(lhs.Get () >> rhs)>
666 {
667  TRACED_VALUE_DEBUG ("x>>");
668  return TracedValue<decltype(lhs.Get () >> rhs)> (lhs.Get () >> rhs);
669 }
671 template <typename T, typename U>
672 auto operator >> (const U &lhs, const TracedValue<T> &rhs)->TracedValue<decltype(lhs >> rhs.Get ())>
673 {
674  TRACED_VALUE_DEBUG (">>x");
675  return TracedValue<decltype(lhs >> rhs.Get ())> (lhs >> rhs.Get ());
676 }
677 
692 template <typename T, typename U>
693 TracedValue<T> &operator += (TracedValue<T> &lhs, const U &rhs)
694 {
695  TRACED_VALUE_DEBUG ("x+=");
696  T tmp = lhs.Get ();
697  tmp += rhs;
698  lhs.Set (tmp);
699  return lhs;
700 }
702 template <typename T, typename U>
703 TracedValue<T> &operator -= (TracedValue<T> &lhs, const U &rhs)
704 {
705  TRACED_VALUE_DEBUG ("x-=");
706  T tmp = lhs.Get ();
707  tmp -= rhs;
708  lhs.Set (tmp);
709  return lhs;
710 }
712 template <typename T, typename U>
713 TracedValue<T> &operator *= (TracedValue<T> &lhs, const U &rhs)
714 {
715  TRACED_VALUE_DEBUG ("x*=");
716  T tmp = lhs.Get ();
717  tmp *= rhs;
718  lhs.Set (tmp);
719  return lhs;
720 }
722 template <typename T, typename U>
723 TracedValue<T> &operator /= (TracedValue<T> &lhs, const U &rhs)
724 {
725  TRACED_VALUE_DEBUG ("x/=");
726  T tmp = lhs.Get ();
727  tmp /= rhs;
728  lhs.Set (tmp);
729  return lhs;
730 }
732 template <typename T, typename U>
733 TracedValue<T> &operator %= (TracedValue<T> &lhs, const U &rhs)
734 {
735  TRACED_VALUE_DEBUG ("x%=");
736  T tmp = lhs.Get ();
737  tmp %= rhs;
738  lhs.Set (tmp);
739  return lhs;
740 }
742 template <typename T, typename U>
743 TracedValue<T> &operator <<= (TracedValue<T> &lhs, const U &rhs)
744 {
745  TRACED_VALUE_DEBUG ("x<<=");
746  T tmp = lhs.Get ();
747  tmp <<= rhs;
748  lhs.Set (tmp);
749  return lhs;
750 }
752 template <typename T, typename U>
753 TracedValue<T> &operator >>= (TracedValue<T> &lhs, const U &rhs)
754 {
755  TRACED_VALUE_DEBUG ("x>>=");
756  T tmp = lhs.Get ();
757  tmp >>= rhs;
758  lhs.Set (tmp);
759  return lhs;
760 }
762 template <typename T, typename U>
763 TracedValue<T> &operator &= (TracedValue<T> &lhs, const U &rhs)
764 {
765  TRACED_VALUE_DEBUG ("x&=");
766  T tmp = lhs.Get ();
767  tmp &= rhs;
768  lhs.Set (tmp);
769  return lhs;
770 }
772 template <typename T, typename U>
773 TracedValue<T> &operator |= (TracedValue<T> &lhs, const U &rhs)
774 {
775  TRACED_VALUE_DEBUG ("x|=");
776  T tmp = lhs.Get ();
777  tmp |= rhs;
778  lhs.Set (tmp);
779  return lhs;
780 }
782 template <typename T, typename U>
783 TracedValue<T> &operator ^= (TracedValue<T> &lhs, const U &rhs)
784 {
785  TRACED_VALUE_DEBUG ("x^=");
786  T tmp = lhs.Get ();
787  tmp ^= rhs;
788  lhs.Set (tmp);
789  return lhs;
790 }
791 
792 
801 template <typename T>
802 TracedValue<T> operator + (const TracedValue<T> &lhs)
803 {
804  TRACED_VALUE_DEBUG ("(+x)");
805  return TracedValue<T> (+lhs.Get ());
806 }
808 template <typename T>
809 TracedValue<T> operator - (const TracedValue<T> &lhs)
810 {
811  TRACED_VALUE_DEBUG ("(-x)");
812  return TracedValue<T> (-lhs.Get ());
813 }
815 template <typename T>
816 TracedValue<T> operator ~ (const TracedValue<T> &lhs)
817 {
818  TRACED_VALUE_DEBUG ("(~x)");
819  return TracedValue<T> (~lhs.Get ());
820 }
822 template <typename T>
823 TracedValue<T> operator ! (const TracedValue<T> &lhs)
824 {
825  TRACED_VALUE_DEBUG ("(!x)");
826  return TracedValue<T> (!lhs.Get ());
827 }
828  // \ingroup tracing
830 
831 } // namespace ns3
832 
833 #endif /* TRACED_VALUE_H */
boolean.h
ns3::BooleanValue attribute value declarations.
ns3::operator+=
int64x64_t & operator+=(int64x64_t &lhs, const int64x64_t &rhs)
Compound addition operator.
Definition: int64x64-128.h:412
double.h
ns3::DoubleValue 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:773
ns3::operator&
auto operator&(const TracedValue< T > &lhs, const TracedValue< U > &rhs) -> TracedValue< decltype(lhs.Get() &rhs.Get())>
Infix arithmetic operator for TracedValue.
Definition: traced-value.h:614
ns3::operator+
int64x64_t operator+(const int64x64_t &lhs)
Unary plus operator.
Definition: int64x64-128.h:460
ns3::TracedValue::m_v
T m_v
The underlying value.
Definition: traced-value.h:278
uinteger.h
ns3::UintegerValue attribute value declarations and template implementations.
ns3::TracedValue::operator=
TracedValue & operator=(const TracedValue &o)
Assignment.
Definition: traced-value.h:146
ns3::operator*=
int64x64_t & operator*=(int64x64_t &lhs, const int64x64_t &rhs)
Compound multiplication operator.
Definition: int64x64-128.h:436
ns3::operator-
int64x64_t operator-(const int64x64_t &lhs)
Unary negation operator (change sign operator).
Definition: int64x64-128.h:470
ns3::operator%
auto operator%(const TracedValue< T > &lhs, const TracedValue< U > &rhs) -> TracedValue< decltype(lhs.Get() % rhs.Get())>
Infix arithmetic operator for TracedValue.
Definition: traced-value.h:548
ns3::CallbackBase
Base class for Callback class.
Definition: callback.h:1195
ns3::TracedValue::Disconnect
void Disconnect(const CallbackBase &cb, std::string path)
Disconnect a Callback which was connected with context.
Definition: traced-value.h:207
ns3::TracedValueCallback::Uint8
void(* Uint8)(uint8_t oldValue, uint8_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:84
ns3::TracedValue::Set
void Set(const T &v)
Set the value of the underlying variable.
Definition: traced-value.h:217
ns3::TracedValue
Trace classes with value semantics.
Definition: traced-value.h:113
ns3::operator>=
bool operator>=(const int64x64_t &lhs, const int64x64_t &rhs)
Greater or equal operator.
Definition: int64x64.h:166
ns3::TracedValue::TracedValue
TracedValue(const TracedValue< U > &other)
Copy from a TracedValue of a compatible type.
Definition: traced-value.h:158
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:816
ns3::TracedCallback::Connect
void Connect(const CallbackBase &callback, std::string path)
Append a Callback to the chain with a context.
Definition: traced-callback.h:141
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:175
ns3::TracedCallback::DisconnectWithoutContext
void DisconnectWithoutContext(const CallbackBase &callback)
Remove from the chain a Callback which was connected without a context.
Definition: traced-callback.h:153
ns3::operator*
int64x64_t operator*(const int64x64_t &lhs, const int64x64_t &rhs)
Multiplication operator.
Definition: int64x64.h:117
ns3::TracedValue::Connect
void Connect(const CallbackBase &cb, std::string path)
Connect a Callback with a context string.
Definition: traced-value.h:188
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:170
ns3::TracedValue::TracedValue
TracedValue()
Default constructor.
Definition: traced-value.h:117
ns3::TracedValueCallback::Int8
void(* Int8)(int8_t oldValue, int8_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:83
enum.h
ns3::EnumValue attribute value declarations.
ns3::TracedValue::operator--
TracedValue & operator--()
Pre/post- increment/decrement operator.
Definition: traced-value.h:248
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:167
ns3::operator%=
TracedValue< T > & operator%=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:733
ns3::operator/
int64x64_t operator/(const int64x64_t &lhs, const int64x64_t &rhs)
Division operator.
Definition: int64x64.h:131
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:1606
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::operator>>=
TracedValue< T > & operator>>=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:753
ns3::operator^=
TracedValue< T > & operator^=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:783
ns3::TracedValue::TracedValue
TracedValue(const T &v)
Construct from an explicit variable.
Definition: traced-value.h:131
ns3::TracedValue::TracedValue
TracedValue(const TracedValue &o)
Copy constructor.
Definition: traced-value.h:124
ns3::TracedValueCallback::Double
void(* Double)(double oldValue, double newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:91
ns3::TracedValueCallback::Int64
void(* Int64)(int64_t oldValue, int64_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:89
ns3::TracedValue::Get
T Get(void) const
Get the underlying value.
Definition: traced-value.h:229
ns3::TracedValueCallback::Void
void(* Void)(void)
TracedValue Callback signature for POD.
Definition: traced-value.h:92
ns3::operator>
bool operator>(const int64x64_t &lhs, const int64x64_t &rhs)
Greater operator.
Definition: int64x64-128.h:400
ns3::operator==
bool operator==(const EventId &a, const EventId &b)
Definition: event-id.h:142
integer.h
ns3::IntegerValue 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:197
ns3::operator-=
int64x64_t & operator-=(int64x64_t &lhs, const int64x64_t &rhs)
Compound subtraction operator.
Definition: int64x64-128.h:424
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|
auto operator|(const TracedValue< T > &lhs, const TracedValue< U > &rhs) -> TracedValue< decltype(lhs.Get()|rhs.Get())>
Infix arithmetic operator for TracedValue.
Definition: traced-value.h:592
ns3::operator/=
int64x64_t & operator/=(int64x64_t &lhs, const int64x64_t &rhs)
Compound division operator.
Definition: int64x64-128.h:448
ns3::TracedValue::operator++
TracedValue & operator++()
Pre/post- increment/decrement operator.
Definition: traced-value.h:240
ns3::TracedValueCallback::Uint32
void(* Uint32)(uint32_t oldValue, uint32_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:88
ns3::TracedValueCallback::Uint64
void(* Uint64)(uint64_t oldValue, uint64_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:90
ns3::TracedValue::m_cb
TracedCallback< T, T > m_cb
The connected Callback.
Definition: traced-value.h:280
ns3::operator!
int64x64_t operator!(const int64x64_t &lhs)
Logical not operator.
Definition: int64x64-128.h:480
ns3::TracedValueCallback::Bool
void(* Bool)(bool oldValue, bool newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:82
ns3::operator^
auto operator^(const TracedValue< T > &lhs, const TracedValue< U > &rhs) -> TracedValue< decltype(lhs.Get() ^ rhs.Get())>
Infix arithmetic operator for TracedValue.
Definition: traced-value.h:570
ns3::TracedCallback::ConnectWithoutContext
void ConnectWithoutContext(const CallbackBase &callback)
Append a Callback to the chain (without a context).
Definition: traced-callback.h:130
ns3::operator&=
TracedValue< T > & operator&=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:763