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 
78 template <typename T>
79 class TracedValue
80 {
81 public:
83  TracedValue ()
84  : m_v () {}
89  TracedValue (const TracedValue &o)
90  : m_v (o.m_v) {}
95  TracedValue (const T &v)
96  : m_v (v) {}
101  operator T () const {
102  return m_v;
103  }
109  TracedValue &operator = (const TracedValue &o) {
110  TRACED_VALUE_DEBUG ("x=");
111  Set (o.m_v);
112  return *this;
113  }
119  template <typename U>
120  TracedValue (const TracedValue<U> &other)
121  : m_v (other.m_v)
122  {}
128  template <typename U>
129  TracedValue (const U &other)
130  : m_v ((T)other)
131  {}
137  void ConnectWithoutContext (const CallbackBase &cb) {
138  m_cb.ConnectWithoutContext (cb);
139  }
149  void Connect (const CallbackBase &cb, std::string path) {
150  m_cb.Connect (cb, path);
151  }
157  void DisconnectWithoutContext (const CallbackBase &cb) {
158  m_cb.DisconnectWithoutContext (cb);
159  }
166  void Disconnect (const CallbackBase &cb, std::string path) {
167  m_cb.Disconnect (cb, path);
168  }
175  void Set (const T &v) {
176  if (m_v != v)
177  {
178  m_cb (m_v, v);
179  m_v = v;
180  }
181  }
186  T Get (void) const {
187  return m_v;
188  }
196  TracedValue &operator++ () {
197  TRACED_VALUE_DEBUG ("++x");
198  T tmp = Get ();
199  ++tmp;
200  Set (tmp);
201  return *this;
202  }
203  TracedValue &operator-- () {
204  TRACED_VALUE_DEBUG ("--x");
205  T tmp = Get ();
206  --tmp;
207  Set (tmp);
208  return *this;
209  }
210  TracedValue operator++ (int) {
211  TRACED_VALUE_DEBUG ("x++");
212  TracedValue old (*this);
213  T tmp = Get ();
214  tmp++;
215  Set (tmp);
216  return old;
217  }
218  TracedValue operator-- (int) {
219  TRACED_VALUE_DEBUG ("x--");
220  TracedValue old (*this);
221  T tmp = Get ();
222  tmp--;
223  Set (tmp);
224  return old;
225  }
235  typedef void (* BoolCallback) (const bool oldValue, const bool newValue);
236  typedef void (* Int8Callback) (const int8_t oldValue, const int8_t newValue);
237  typedef void (* Uint8Callback) (const uint8_t oldValue, const uint8_t newValue);
238  typedef void (* Int16Callback) (const int16_t oldValue, const int16_t newValue);
239  typedef void (* Uint16Callback)(const uint16_t oldValue, const uint16_t newValue);
240  typedef void (* Int32Callback) (const int32_t oldValue, const int32_t newValue);
241  typedef void (* Uint32Callback)(const uint32_t oldValue, const uint32_t newValue);
242  typedef void (* DoubleCallback)(const double oldValue, const double newValue);
245 private:
247  T m_v;
249  TracedCallback<T,T> m_cb;
250 };
251 
252 
253 /********************************************************************
254  Operator implementations for TracedValue
255  ********************************************************************/
256 
271 template <typename T>
272 std::ostream& operator << (std::ostream& os, const TracedValue<T>& rhs)
273 {
274  return os<<rhs.Get ();
275 }
276 
285 template <typename T, typename U>
286 bool operator == (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
287 {
288  TRACED_VALUE_DEBUG ("x==x");
289  return lhs.Get () == rhs.Get ();
290 }
292 template <typename T, typename U>
293 bool operator == (const TracedValue<T> &lhs, const U &rhs)
294 {
295  TRACED_VALUE_DEBUG ("x==");
296  return lhs.Get () == rhs;
297 }
299 template <typename T, typename U>
300 bool operator == (const U &lhs, const TracedValue<T> &rhs)
301 {
302  TRACED_VALUE_DEBUG ("==x");
303  return lhs == rhs.Get ();
304 }
305 
307 template <typename T, typename U>
308 bool operator != (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
309 {
310  TRACED_VALUE_DEBUG ("x!=x");
311  return lhs.Get () != rhs.Get ();
312 }
314 template <typename T, typename U>
315 bool operator != (const TracedValue<T> &lhs, const U &rhs)
316 {
317  TRACED_VALUE_DEBUG ("x!=");
318  return lhs.Get () != rhs;
319 }
321 template <typename T, typename U>
322 bool operator != (const U &lhs, const TracedValue<T> &rhs)
323 {
324  TRACED_VALUE_DEBUG ("!=x");
325  return lhs != rhs.Get ();
326 }
327 
329 template <typename T, typename U>
330 bool operator <= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
331 {
332  TRACED_VALUE_DEBUG ("x<=x");
333  return lhs.Get () <= rhs.Get ();
334 }
336 template <typename T, typename U>
337 bool operator <= (const TracedValue<T> &lhs, const U &rhs)
338 {
339  TRACED_VALUE_DEBUG ("x<=");
340  return lhs.Get () <= rhs;
341 }
343 template <typename T, typename U>
344 bool operator <= (const U &lhs, const TracedValue<T> &rhs)
345 {
346  TRACED_VALUE_DEBUG ("<=x");
347  return lhs <= rhs.Get ();
348 }
350 template <typename T, typename U>
351 bool operator >= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
352 {
353  TRACED_VALUE_DEBUG ("x>=x");
354  return lhs.Get () >= rhs.Get ();
355 }
357 template <typename T, typename U>
358 bool operator >= (const TracedValue<T> &lhs, const U &rhs)
359 {
360  TRACED_VALUE_DEBUG ("x>=");
361  return lhs.Get () >= rhs;
362 }
364 template <typename T, typename U>
365 bool operator >= (const U &lhs, const TracedValue<T> &rhs)
366 {
367  TRACED_VALUE_DEBUG (">=x");
368  return lhs >= rhs.Get ();
369 }
370 
372 template <typename T, typename U>
373 bool operator < (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
374 {
375  TRACED_VALUE_DEBUG ("x<x");
376  return lhs.Get () < rhs.Get ();
377 }
379 template <typename T, typename U>
380 bool operator < (const TracedValue<T> &lhs, const U &rhs)
381 {
382  TRACED_VALUE_DEBUG ("x<");
383  return lhs.Get () < rhs;
384 }
386 template <typename T, typename U>
387 bool operator < (const U &lhs, const TracedValue<T> &rhs)
388 {
389  TRACED_VALUE_DEBUG ("<x");
390  return lhs < rhs.Get ();
391 }
393 template <typename T, typename U>
394 bool operator > (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
395 {
396  TRACED_VALUE_DEBUG ("x>x");
397  return lhs.Get () > rhs.Get ();
398 }
400 template <typename T, typename U>
401 bool operator > (const TracedValue<T> &lhs, const U &rhs)
402 {
403  TRACED_VALUE_DEBUG ("x>");
404  return lhs.Get () > rhs;
405 }
407 template <typename T, typename U>
408 bool operator > (const U &lhs, const TracedValue<T> &rhs)
409 {
410  TRACED_VALUE_DEBUG (">x");
411  return lhs > rhs.Get ();
412 }
413 
414 
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 }
434 template <typename T, typename U>
435 TracedValue<T> operator + (const TracedValue<T> &lhs, const U &rhs) {
436  TRACED_VALUE_DEBUG ("x+");
437  return TracedValue<T> (lhs.Get () + rhs);
438 }
440 template <typename T, typename U>
441 TracedValue<T> operator + (const U &lhs, const TracedValue<T> &rhs) {
442  TRACED_VALUE_DEBUG ("+x");
443  return TracedValue<T> (lhs + rhs.Get ());
444 }
445 
447 template <typename T, typename U>
448 TracedValue<T> operator - (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
449  TRACED_VALUE_DEBUG ("x-x");
450  return TracedValue<T> (lhs.Get () - rhs.Get ());
451 }
453 template <typename T, typename U>
454 TracedValue<T> operator - (const TracedValue<T> &lhs, const U &rhs) {
455  TRACED_VALUE_DEBUG ("x-");
456  return TracedValue<T> (lhs.Get () - rhs);
457 }
459 template <typename T, typename U>
460 TracedValue<T> operator - (const U &lhs, const TracedValue<T> &rhs) {
461  TRACED_VALUE_DEBUG ("-x");
462  return TracedValue<T> (lhs - rhs.Get ());
463 }
464 
466 template <typename T, typename U>
467 TracedValue<T> operator * (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
468  TRACED_VALUE_DEBUG ("x*x");
469  return TracedValue<T> (lhs.Get () * rhs.Get ());
470 }
472 template <typename T, typename U>
473 TracedValue<T> operator * (const TracedValue<T> &lhs, const U &rhs) {
474  TRACED_VALUE_DEBUG ("x*");
475  return TracedValue<T> (lhs.Get () * rhs);
476 }
478 template <typename T, typename U>
479 TracedValue<T> operator * (const U &lhs, const TracedValue<T> &rhs) {
480  TRACED_VALUE_DEBUG ("*x");
481  return TracedValue<T> (lhs * rhs.Get ());
482 }
483 
485 template <typename T, typename U>
486 TracedValue<T> operator / (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
487  TRACED_VALUE_DEBUG ("x/x");
488  return TracedValue<T> (lhs.Get () / rhs.Get ());
489 }
491 template <typename T, typename U>
492 TracedValue<T> operator / (const TracedValue<T> &lhs, const U &rhs) {
493  TRACED_VALUE_DEBUG ("x/");
494  return TracedValue<T> (lhs.Get () / rhs);
495 }
497 template <typename T, typename U>
498 TracedValue<T> operator / (const U &lhs, const TracedValue<T> &rhs) {
499  TRACED_VALUE_DEBUG ("/x");
500  return TracedValue<T> (lhs / rhs.Get ());
501 }
502 
504 template <typename T, typename U>
505 TracedValue<T> operator % (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
506  TRACED_VALUE_DEBUG ("x%x");
507  return TracedValue<T> (lhs.Get () % rhs.Get ());
508 }
510 template <typename T, typename U>
511 TracedValue<T> operator % (const TracedValue<T> &lhs, const U &rhs) {
512  TRACED_VALUE_DEBUG ("x%");
513  return TracedValue<T> (lhs.Get () % rhs);
514 }
516 template <typename T, typename U>
517 TracedValue<T> operator % (const U &lhs, const TracedValue<T> &rhs) {
518  TRACED_VALUE_DEBUG ("%x");
519  return TracedValue<T> (lhs % rhs.Get ());
520 }
521 
523 template <typename T, typename U>
524 TracedValue<T> operator ^ (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
525  TRACED_VALUE_DEBUG ("x^x");
526  return TracedValue<T> (lhs.Get () ^ rhs.Get ());
527 }
529 template <typename T, typename U>
530 TracedValue<T> operator ^ (const TracedValue<T> &lhs, const U &rhs) {
531  TRACED_VALUE_DEBUG ("x^");
532  return TracedValue<T> (lhs.Get () ^ rhs);
533 }
535 template <typename T, typename U>
536 TracedValue<T> operator ^ (const U &lhs, const TracedValue<T> &rhs) {
537  TRACED_VALUE_DEBUG ("^x");
538  return TracedValue<T> (lhs ^ rhs.Get ());
539 }
540 
542 template <typename T, typename U>
543 TracedValue<T> operator | (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
544  TRACED_VALUE_DEBUG ("x|x");
545  return TracedValue<T> (lhs.Get () | rhs.Get ());
546 }
548 template <typename T, typename U>
549 TracedValue<T> operator | (const TracedValue<T> &lhs, const U &rhs) {
550  TRACED_VALUE_DEBUG ("x|");
551  return TracedValue<T> (lhs.Get () | rhs);
552 }
554 template <typename T, typename U>
555 TracedValue<T> operator | (const U &lhs, const TracedValue<T> &rhs) {
556  TRACED_VALUE_DEBUG ("|x");
557  return TracedValue<T> (lhs | rhs.Get ());
558 }
559 
561 template <typename T, typename U>
562 TracedValue<T> operator & (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
563  TRACED_VALUE_DEBUG ("x&x");
564  return TracedValue<T> (lhs.Get () & rhs.Get ());
565 }
567 template <typename T, typename U>
568 TracedValue<T> operator & (const TracedValue<T> &lhs, const U &rhs) {
569  TRACED_VALUE_DEBUG ("x&");
570  return TracedValue<T> (lhs.Get () & rhs);
571 }
573 template <typename T, typename U>
574 TracedValue<T> operator & (const U &lhs, const TracedValue<T> &rhs) {
575  TRACED_VALUE_DEBUG ("&x");
576  return TracedValue<T> (lhs & rhs.Get ());
577 }
578 
580 template <typename T, typename U>
581 TracedValue<T> operator << (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
582  TRACED_VALUE_DEBUG ("x<<x");
583  return TracedValue<T> (lhs.Get () << rhs.Get ());
584 }
586 template <typename T, typename U>
587 TracedValue<T> operator << (const TracedValue<T> &lhs, const U &rhs) {
588  TRACED_VALUE_DEBUG ("x<<");
589  return TracedValue<T> (lhs.Get () << rhs);
590 }
592 template <typename T, typename U>
593 TracedValue<T> operator << (const U &lhs, const TracedValue<T> &rhs) {
594  TRACED_VALUE_DEBUG ("<<x");
595  return TracedValue<T> (lhs << rhs.Get ());
596 }
597 
599 template <typename T, typename U>
600 TracedValue<T> operator >> (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
601  TRACED_VALUE_DEBUG ("x>>x");
602  return TracedValue<T> (lhs.Get () >> rhs.Get ());
603 }
605 template <typename T, typename U>
606 TracedValue<T> operator >> (const TracedValue<T> &lhs, const U &rhs) {
607  TRACED_VALUE_DEBUG ("x>>");
608  return TracedValue<T> (lhs.Get () >> rhs);
609 }
611 template <typename T, typename U>
612 TracedValue<T> operator >> (const U &lhs, const TracedValue<T> &rhs) {
613  TRACED_VALUE_DEBUG (">>x");
614  return TracedValue<T> (lhs >> rhs.Get ());
615 }
616 
631 template <typename T, typename U>
632 TracedValue<T> &operator += (TracedValue<T> &lhs, const U &rhs) {
633  TRACED_VALUE_DEBUG ("x+=");
634  T tmp = lhs.Get ();
635  tmp += rhs;
636  lhs.Set (tmp);
637  return lhs;
638 }
640 template <typename T, typename U>
641 TracedValue<T> &operator -= (TracedValue<T> &lhs, const U &rhs) {
642  TRACED_VALUE_DEBUG ("x-=");
643  T tmp = lhs.Get ();
644  tmp -= rhs;
645  lhs.Set (tmp);
646  return lhs;
647 }
649 template <typename T, typename U>
650 TracedValue<T> &operator *= (TracedValue<T> &lhs, const U &rhs) {
651  TRACED_VALUE_DEBUG ("x*=");
652  T tmp = lhs.Get ();
653  tmp *= rhs;
654  lhs.Set (tmp);
655  return lhs;
656 }
658 template <typename T, typename U>
659 TracedValue<T> &operator /= (TracedValue<T> &lhs, const U &rhs) {
660  TRACED_VALUE_DEBUG ("x/=");
661  T tmp = lhs.Get ();
662  tmp /= rhs;
663  lhs.Set (tmp);
664  return lhs;
665 }
667 template <typename T, typename U>
668 TracedValue<T> &operator %= (TracedValue<T> &lhs, const U &rhs) {
669  TRACED_VALUE_DEBUG ("x%=");
670  T tmp = lhs.Get ();
671  tmp %= rhs;
672  lhs.Set (tmp);
673  return lhs;
674 }
676 template <typename T, typename U>
677 TracedValue<T> &operator <<= (TracedValue<T> &lhs, const U &rhs) {
678  TRACED_VALUE_DEBUG ("x<<=");
679  T tmp = lhs.Get ();
680  tmp <<= rhs;
681  lhs.Set (tmp);
682  return lhs;
683 }
685 template <typename T, typename U>
686 TracedValue<T> &operator >>= (TracedValue<T> &lhs, const U &rhs) {
687  TRACED_VALUE_DEBUG ("x>>=");
688  T tmp = lhs.Get ();
689  tmp >>= rhs;
690  lhs.Set (tmp);
691  return lhs;
692 }
694 template <typename T, typename U>
695 TracedValue<T> &operator &= (TracedValue<T> &lhs, const U &rhs) {
696  TRACED_VALUE_DEBUG ("x&=");
697  T tmp = lhs.Get ();
698  tmp &= rhs;
699  lhs.Set (tmp);
700  return lhs;
701 }
703 template <typename T, typename U>
704 TracedValue<T> &operator |= (TracedValue<T> &lhs, const U &rhs) {
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  TRACED_VALUE_DEBUG ("x^=");
715  T tmp = lhs.Get ();
716  tmp ^= rhs;
717  lhs.Set (tmp);
718  return lhs;
719 }
720 
721 
730 template <typename T>
731 TracedValue<T> operator + (const TracedValue<T> &lhs) {
732  TRACED_VALUE_DEBUG ("(+x)");
733  return TracedValue<T> (+lhs.Get ());
734 }
736 template <typename T>
737 TracedValue<T> operator - (const TracedValue<T> &lhs) {
738  TRACED_VALUE_DEBUG ("(-x)");
739  return TracedValue<T> (-lhs.Get ());
740 }
742 template <typename T>
743 TracedValue<T> operator ~ (const TracedValue<T> &lhs) {
744  TRACED_VALUE_DEBUG ("(~x)");
745  return TracedValue<T> (~lhs.Get ());
746 }
748 template <typename T>
749 TracedValue<T> operator ! (const TracedValue<T> &lhs) {
750  TRACED_VALUE_DEBUG ("(!x)");
751  return TracedValue<T> (!lhs.Get ());
752 }
753  // \ingroup tracing
755 
756 } // namespace ns3
757 
758 #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:704
ns3::operator+
int64x64_t operator+(const int64x64_t &lhs)
Unary plus operator.
Definition: int64x64-128.h:404
ns3::operator/=
int64x64_t & operator/=(int64x64_t &lhs, const int64x64_t &rhs)
Compound division operator.
Definition: int64x64-128.h:394
ns3::TracedValue::m_v
T m_v
The underlying value.
Definition: traced-value.h:247
uinteger.h
Unsigned integer attribute value declarations and template implementations.
ns3::TracedValue::Uint32Callback
void(* Uint32Callback)(const uint32_t oldValue, const uint32_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:241
ns3::TracedValue::operator=
TracedValue & operator=(const TracedValue &o)
Assignment.
Definition: traced-value.h:109
ns3::operator-
int64x64_t operator-(const int64x64_t &lhs)
Unary negation operator (change sign operator).
Definition: int64x64-128.h:412
ns3::operator&
TracedValue< T > operator&(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Infix arithmetic operator for TracedValue.
Definition: traced-value.h:562
ns3::CallbackBase
Base class for Callback class.
Definition: callback.h:900
ns3::TracedValue::Disconnect
void Disconnect(const CallbackBase &cb, std::string path)
Disconnect a Callback which was connected with context.
Definition: traced-value.h:166
ns3::operator+=
int64x64_t & operator+=(int64x64_t &lhs, const int64x64_t &rhs)
Compound addition operator.
Definition: int64x64-128.h:367
ns3::TracedValue::Set
void Set(const T &v)
Set the value of the underlying variable.
Definition: traced-value.h:175
ns3::TracedValue
Trace classes with value semantics.
Definition: traced-value.h:79
ns3::TracedValue::Get
T Get(void) const
Get the underlying value.
Definition: traced-value.h:186
ns3::operator>=
bool operator>=(const int64x64_t &lhs, const int64x64_t &rhs)
Greater or equal operator.
Definition: int64x64.h:139
ns3::TracedValue::TracedValue
TracedValue(const TracedValue< U > &other)
Copy from a TracedValue of a compatable type.
Definition: traced-value.h:120
ns3::TracedValue::Int16Callback
void(* Int16Callback)(const int16_t oldValue, const int16_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:238
ns3::operator~
TracedValue< T > operator~(const TracedValue< T > &lhs)
Unary arithmetic operator for TracedValue.
Definition: traced-value.h:743
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:137
ns3::operator*
int64x64_t operator*(const int64x64_t &lhs, const int64x64_t &rhs)
Multiplication operator.
Definition: int64x64.h:102
ns3::TracedValue::Connect
void Connect(const CallbackBase &cb, std::string path)
Connect a Callback with a context string.
Definition: traced-value.h:149
ns3::operator^
TracedValue< T > operator^(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Infix arithmetic operator for TracedValue.
Definition: traced-value.h:524
ns3::TracedValue::TracedValue
TracedValue()
Default constructor.
Definition: traced-value.h:83
ns3::TracedValue::DoubleCallback
void(* DoubleCallback)(const double oldValue, const double newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:242
ns3::TracedValue::Uint16Callback
void(* Uint16Callback)(const uint16_t oldValue, const uint16_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:239
ns3::TracedCallback::DisconnectWithoutContext
void DisconnectWithoutContext(const CallbackBase &callback)
Remove from the chain a Callback which was connected without a context.
Definition: traced-callback.h:287
enum.h
Enum attribute value declarations.
ns3::TracedValue::BoolCallback
void(* BoolCallback)(const bool oldValue, const bool newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:235
ns3::TracedValue::operator--
TracedValue & operator--()
Pre/post- increment/decrement operator.
Definition: traced-value.h:203
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:307
ns3::TracedValue::Int8Callback
void(* Int8Callback)(const int8_t oldValue, const int8_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:236
ns3::TracedValue::TracedValue
TracedValue(const U &other)
Copy from a variable type compatible with this underlying type.
Definition: traced-value.h:129
ns3::operator%=
TracedValue< T > & operator%=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:668
ns3::operator/
int64x64_t operator/(const int64x64_t &lhs, const int64x64_t &rhs)
Division operator.
Definition: int64x64.h:113
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:1272
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:385
ns3::operator>>=
TracedValue< T > & operator>>=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:686
ns3::TracedValue::Int32Callback
void(* Int32Callback)(const int32_t oldValue, const int32_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:240
ns3::operator%
TracedValue< T > operator%(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Infix arithmetic operator for TracedValue.
Definition: traced-value.h:505
ns3::operator^=
TracedValue< T > & operator^=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:713
ns3::TracedValue::TracedValue
TracedValue(const T &v)
Construct from an explicit variable.
Definition: traced-value.h:95
ns3::TracedCallback::Connect
void Connect(const CallbackBase &callback, std::string path)
Append a Callback to the chain with a context.
Definition: traced-callback.h:275
ns3::TracedValue::TracedValue
TracedValue(const TracedValue &o)
Copy constructor.
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::TracedValue::Uint8Callback
void(* Uint8Callback)(const uint8_t oldValue, const uint8_t newValue)
TracedValue Callback signature for POD.
Definition: traced-value.h:237
ns3::operator&=
TracedValue< T > & operator&=(TracedValue< T > &lhs, const U &rhs)
Operator assignment for TracedValue.
Definition: traced-value.h:695
ns3::operator>
bool operator>(const int64x64_t &lhs, const int64x64_t &rhs)
Greater operator.
Definition: int64x64-128.h:358
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:157
TRACED_VALUE_DEBUG
#define TRACED_VALUE_DEBUG(x)
Logging macro for TracedValue.
Definition: traced-value.h:48
ns3::operator|
TracedValue< T > operator|(const TracedValue< T > &lhs, const TracedValue< U > &rhs)
Infix arithmetic operator for TracedValue.
Definition: traced-value.h:543
ns3::TracedValue::operator++
TracedValue & operator++()
Pre/post- increment/decrement operator.
Definition: traced-value.h:196
ns3::TracedValue::m_cb
TracedCallback< T, T > m_cb
The connected Callback.
Definition: traced-value.h:249
ns3::operator!
int64x64_t operator!(const int64x64_t &lhs)
Logical not operator.
Definition: int64x64-128.h:420
ns3::operator-=
int64x64_t & operator-=(int64x64_t &lhs, const int64x64_t &rhs)
Compound subtraction operator.
Definition: int64x64-128.h:376