F5/unison
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename TracedVariable to VariableTracer

Browse Source
This commit is contained in:
Mathieu Lacage
2006-09-04 15:06:09 +02:00
parent 05cbced73d
commit 62e1051d4c
7 changed files with 118 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
samples/main-trace.cc
View File

@@ -10,7 +10,7 @@
using namespace ns3;
CallbackTracer<Packet> a;
UiTracedVariable<unsigned short> b;
UiVariableTracer<unsigned short> b;
StreamTracer c;
CallbackTracer<double, int> d;

16
src/common/f-traced-variable.tcc
View File

@@ -19,25 +19,25 @@
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#ifndef F_TRACED_VARIABLE_TCC
#define F_TRACED_VARIABLE_TCC
#ifndef F_VARIABLE_TRACER_H
#define F_VARIABLE_TRACER_H
#include "ns3/callback.h"
#include <stdint.h>
namespace ns3 {
class FTracedVariableBase {
class FVariableTracerBase {
public:
typedef Callback<void,double, double> ChangeNotifyCallback;
FTracedVariableBase () {}
FTracedVariableBase (FTracedVariableBase const &o) {}
FTracedVariableBase &operator = (FTracedVariableBase const &o) {
FVariableTracerBase () {}
FVariableTracerBase (FVariableTracerBase const &o) {}
FVariableTracerBase &operator = (FVariableTracerBase const &o) {
return *this;
}
~FTracedVariableBase () {}
~FVariableTracerBase () {}
void set_callback(ChangeNotifyCallback callback) {
m_callback = callback;
@@ -55,4 +55,4 @@ private:
}; // namespace ns3
#endif /* F_TRACED_VARIABLE_TCC */
#endif /* F_VARIABLE_TRACER_H */

82
src/common/si-traced-variable.tcc
View File

@@ -19,25 +19,25 @@
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#ifndef SI_TRACED_VARIABLE_TCC
#define SI_TRACED_VARIABLE_TCC
#ifndef SI_VARIABLE_TRACER_H
#define SI_VARIABLE_TRACER_H
#include "ns3/callback.h"
#include <stdint.h>
namespace ns3 {
class SiTracedVariableBase {
class SiVariableTracerBase {
public:
typedef Callback<void,int64_t, int64_t> ChangeNotifyCallback;
SiTracedVariableBase () {}
SiTracedVariableBase (SiTracedVariableBase const &o) {}
SiTracedVariableBase &operator = (SiTracedVariableBase const &o) {
SiVariableTracerBase () {}
SiVariableTracerBase (SiVariableTracerBase const &o) {}
SiVariableTracerBase &operator = (SiVariableTracerBase const &o) {
return *this;
}
~SiTracedVariableBase () {}
~SiVariableTracerBase () {}
void set_callback(ChangeNotifyCallback callback) {
m_callback = callback;
@@ -53,7 +53,7 @@ private:
};
template <typename T>
class UiTracedVariable;
class UiVariableTracer;
/**
@@ -66,12 +66,12 @@ class UiTracedVariable;
*
* To instantiate a 32-bit signed variable (to store
* a TCP counter for example), you would create a variable of type
* ns3::UiTracedVariable<int32_t> :
* ns3::UiVariableTracer<int32_t> :
\code
#include <stdint.h>
#include "ns3/si-traced-variable.tcc"
ns3::SiTracedVariable<uint16_t> var;
ns3::SiVariableTracer<uint16_t> var;
\endcode
* and you would use it like any other variable of type int32_t:
\code
@@ -81,44 +81,44 @@ class UiTracedVariable;
\endcode
*/
template <typename T>
class SiTracedVariable : public SiTracedVariableBase {
class SiVariableTracer : public SiVariableTracerBase {
public:
SiTracedVariable ()
SiVariableTracer ()
: m_var (0)
{}
SiTracedVariable (T const &var)
SiVariableTracer (T const &var)
: m_var (var)
{}
SiTracedVariable &operator = (SiTracedVariable const &o) {
SiVariableTracer &operator = (SiVariableTracer const &o) {
assign (o.get ());
return *this;
}
template <typename TT>
SiTracedVariable &operator = (SiTracedVariable<TT> const &o) {
SiVariableTracer &operator = (SiVariableTracer<TT> const &o) {
assign (o.get ());
return *this;
}
template <typename TT>
SiTracedVariable &operator = (UiTracedVariable<TT> const &o) {
SiVariableTracer &operator = (UiVariableTracer<TT> const &o) {
assign (o.get ());
return *this;
}
SiTracedVariable &operator++ () {
SiVariableTracer &operator++ () {
assign (get () + 1);
return *this;
}
SiTracedVariable &operator-- () {
SiVariableTracer &operator-- () {
assign (get () - 1);
return *this;
}
SiTracedVariable operator++ (int) {
SiTracedVariable old (*this);
SiVariableTracer operator++ (int) {
SiVariableTracer old (*this);
++*this;
return old;
}
SiTracedVariable operator-- (int) {
SiTracedVariable old (*this);
SiVariableTracer operator-- (int) {
SiVariableTracer old (*this);
--*this;
return old;
}
@@ -140,98 +140,98 @@ private:
};
template <typename T>
SiTracedVariable<T> &operator += (SiTracedVariable<T> &lhs, SiTracedVariable<T> const &rhs) {
SiVariableTracer<T> &operator += (SiVariableTracer<T> &lhs, SiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () + rhs.get ());
return lhs;
}
template <typename T>
SiTracedVariable<T> &operator -= (SiTracedVariable<T> &lhs, SiTracedVariable<T> const &rhs) {
SiVariableTracer<T> &operator -= (SiVariableTracer<T> &lhs, SiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () - rhs.get ());
return lhs;
}
template <typename T>
SiTracedVariable<T> &operator *= (SiTracedVariable<T> &lhs, SiTracedVariable<T> const &rhs) {
SiVariableTracer<T> &operator *= (SiVariableTracer<T> &lhs, SiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () * rhs.get ());
return lhs;
}
template <typename T>
SiTracedVariable<T> &operator /= (SiTracedVariable<T> &lhs, SiTracedVariable<T> const &rhs) {
SiVariableTracer<T> &operator /= (SiVariableTracer<T> &lhs, SiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () / rhs.get ());
return lhs;
}
template <typename T>
SiTracedVariable<T> &operator <<= (SiTracedVariable<T> &lhs, SiTracedVariable<T> const &rhs) {
SiVariableTracer<T> &operator <<= (SiVariableTracer<T> &lhs, SiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () << rhs.get ());
return lhs;
}
template <typename T>
SiTracedVariable<T> &operator >>= (SiTracedVariable<T> &lhs, SiTracedVariable<T> const &rhs) {
SiVariableTracer<T> &operator >>= (SiVariableTracer<T> &lhs, SiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () >> rhs.get ());
return lhs;
}
template <typename T>
SiTracedVariable<T> &operator &= (SiTracedVariable<T> &lhs, SiTracedVariable<T> const &rhs) {
SiVariableTracer<T> &operator &= (SiVariableTracer<T> &lhs, SiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () & rhs.get ());
return lhs;
}
template <typename T>
SiTracedVariable<T> &operator |= (SiTracedVariable<T> &lhs, SiTracedVariable<T> const &rhs) {
SiVariableTracer<T> &operator |= (SiVariableTracer<T> &lhs, SiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () | rhs.get ());
return lhs;
}
template <typename T>
SiTracedVariable<T> &operator ^= (SiTracedVariable<T> &lhs, SiTracedVariable<T> const &rhs) {
SiVariableTracer<T> &operator ^= (SiVariableTracer<T> &lhs, SiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () ^ rhs.get ());
return lhs;
}
template <typename T, typename U>
SiTracedVariable<T> &operator += (SiTracedVariable<T> &lhs, U const &rhs) {
SiVariableTracer<T> &operator += (SiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () + rhs);
return lhs;
}
template <typename T, typename U>
SiTracedVariable<T> &operator -= (SiTracedVariable<T> &lhs, U const &rhs) {
SiVariableTracer<T> &operator -= (SiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () - rhs);
return lhs;
}
template <typename T, typename U>
SiTracedVariable<T> &operator *= (SiTracedVariable<T> &lhs, U const &rhs) {
SiVariableTracer<T> &operator *= (SiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () * rhs);
return lhs;
}
template <typename T, typename U>
SiTracedVariable<T> &operator /= (SiTracedVariable<T> &lhs, U const &rhs) {
SiVariableTracer<T> &operator /= (SiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () / rhs);
return lhs;
}
template <typename T, typename U>
SiTracedVariable<T> &operator <<= (SiTracedVariable<T> &lhs, U const &rhs) {
SiVariableTracer<T> &operator <<= (SiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () << rhs);
return lhs;
}
template <typename T, typename U>
SiTracedVariable<T> &operator >>= (SiTracedVariable<T> &lhs, U const &rhs) {
SiVariableTracer<T> &operator >>= (SiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () >> rhs);
return lhs;
}
template <typename T, typename U>
SiTracedVariable<T> &operator &= (SiTracedVariable<T> &lhs, U const &rhs) {
SiVariableTracer<T> &operator &= (SiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () & rhs);
return lhs;
}
template <typename T, typename U>
SiTracedVariable<T> &operator |= (SiTracedVariable<T> &lhs, U const &rhs) {
SiVariableTracer<T> &operator |= (SiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () | rhs);
return lhs;
}
template <typename T, typename U>
SiTracedVariable<T> &operator ^= (SiTracedVariable<T> &lhs, U const &rhs) {
SiVariableTracer<T> &operator ^= (SiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () ^ rhs);
return lhs;
}
}; // namespace ns3
#endif /* TRACED_VARIABLE_TCC */
#endif /* SI_VARIABLE_TRACER_H */

6
src/common/trace-container.cc
View File

@@ -75,7 +75,7 @@ TraceContainer::set_stream (char const *name, std::ostream *os)
}
void
TraceContainer::register_ui_variable (char const *name, UiTracedVariableBase *var)
TraceContainer::register_ui_variable (char const *name, UiVariableTracerBase *var)
{
// ensure unicity
for (UiListI i = m_ui_list.begin (); i != m_ui_list.end (); i++) {
@@ -87,7 +87,7 @@ TraceContainer::register_ui_variable (char const *name, UiTracedVariableBase *va
m_ui_list.push_back (std::make_pair (var, name));
}
void
TraceContainer::register_si_variable (char const *name, SiTracedVariableBase *var)
TraceContainer::register_si_variable (char const *name, SiVariableTracerBase *var)
{
// ensure unicity
for (SiListI i = m_si_list.begin (); i != m_si_list.end (); i++) {
@@ -99,7 +99,7 @@ TraceContainer::register_si_variable (char const *name, SiTracedVariableBase *va
m_si_list.push_back (std::make_pair (var, name));
}
void
TraceContainer::register_f_variable (char const *name, FTracedVariableBase *var)
TraceContainer::register_f_variable (char const *name, FVariableTracerBase *var)
{
assert (false);
}

22
src/common/trace-container.h
View File

@@ -45,8 +45,8 @@ class StreamTracer;
* TraceContainer can be used to register the following event sources:
* - ns3::StreamTracer : can be connected to any std::ostream
* - ns3::CallbackTracer: can be connected to any ns3::Callback
* - ns3::UiTracedVariable
* - ns3::SiTracedVariable
* - ns3::UiVariableTracer
* - ns3::SiVariableTracer
* - ns3::FTracedVariable
*
* The following sample code shows how you can:
@@ -140,21 +140,21 @@ public:
*
* This method registers only event sources of type "unsigned integer".
*/
void register_ui_variable (char const *name, UiTracedVariableBase *var);
void register_ui_variable (char const *name, UiVariableTracerBase *var);
/**
* \param name the name of the registered event source
* \param var the event source being registered
*
* This method registers only event sources of type "signed integer".
*/
void register_si_variable (char const *name, SiTracedVariableBase *var);
void register_si_variable (char const *name, SiVariableTracerBase *var);
/**
* \param name the name of the registered event source
* \param var the event source being registered
*
* This method registers only event sources of type "double".
*/
void register_f_variable (char const *name, FTracedVariableBase *var);
void register_f_variable (char const *name, FVariableTracerBase *var);
/**
* \param name the name of the registered event source
* \param stream the event source being registered
@@ -176,12 +176,12 @@ public:
*/
void print_debug (void);
private:
typedef std::list<std::pair<UiTracedVariableBase *, std::string> > UiList;
typedef std::list<std::pair<UiTracedVariableBase *, std::string> >::iterator UiListI;
typedef std::list<std::pair<SiTracedVariableBase *, std::string> > SiList;
typedef std::list<std::pair<SiTracedVariableBase *, std::string> >::iterator SiListI;
typedef std::list<std::pair<FTracedVariableBase *, std::string> > FList;
typedef std::list<std::pair<FTracedVariableBase *, std::string> >::iterator FListI;
typedef std::list<std::pair<UiVariableTracerBase *, std::string> > UiList;
typedef std::list<std::pair<UiVariableTracerBase *, std::string> >::iterator UiListI;
typedef std::list<std::pair<SiVariableTracerBase *, std::string> > SiList;
typedef std::list<std::pair<SiVariableTracerBase *, std::string> >::iterator SiListI;
typedef std::list<std::pair<FVariableTracerBase *, std::string> > FList;
typedef std::list<std::pair<FVariableTracerBase *, std::string> >::iterator FListI;
typedef std::list<std::pair<StreamTracer *, std::string> > StreamTracerList;
typedef std::list<std::pair<StreamTracer *, std::string> >::iterator StreamTracerListI;
typedef std::list<std::pair<CallbackTracerBase *, std::string> > CallbackList;

26
src/common/traced-variable-test.cc
View File

@@ -32,17 +32,17 @@ public:
void notify (uint64_t old_val, uint64_t new_val) {}
};
class TracedVariableTest: public Test {
class VariableTracerTest: public Test {
public:
TracedVariableTest ();
VariableTracerTest ();
void run_unsigned_tests (void);
void run_signed_unsigned_tests (void);
virtual bool run_tests (void);
};
void
TracedVariableTest::run_unsigned_tests (void)
VariableTracerTest::run_unsigned_tests (void)
{
UiTracedVariable<uint32_t> var, ovar, tmp;
UiVariableTracer<uint32_t> var, ovar, tmp;
uint32_t utmp;
Foo *foo = new Foo ();
@@ -198,7 +198,7 @@ TracedVariableTest::run_unsigned_tests (void)
}
void
TracedVariableTest::run_signed_unsigned_tests (void)
VariableTracerTest::run_signed_unsigned_tests (void)
{
unsigned short utmp = 10;
unsigned int uitmp = 7;
@@ -208,10 +208,10 @@ TracedVariableTest::run_signed_unsigned_tests (void)
uitmp = utmp;
utmp = uitmp;
UiTracedVariable<unsigned short> uvar = 10;
UiTracedVariable<unsigned int> uivar = 5;
SiTracedVariable<short> svar = 5;
SiTracedVariable<int> sivar = 5;
UiVariableTracer<unsigned short> uvar = 10;
UiVariableTracer<unsigned int> uivar = 5;
SiVariableTracer<short> svar = 5;
SiVariableTracer<int> sivar = 5;
uvar = svar;
svar = uvar;
uvar += svar;
@@ -234,7 +234,7 @@ TracedVariableTest::run_signed_unsigned_tests (void)
}
bool
TracedVariableTest::run_tests (void)
VariableTracerTest::run_tests (void)
{
run_unsigned_tests ();
run_signed_unsigned_tests ();
@@ -242,10 +242,10 @@ TracedVariableTest::run_tests (void)
return true;
}
TracedVariableTest::TracedVariableTest ()
: Test ("TracedVariable") {}
VariableTracerTest::VariableTracerTest ()
: Test ("VariableTracer") {}
static TracedVariableTest g_traced_variable_test;
static VariableTracerTest g_variable_tracer_test;
}; // namespace ns3

82
src/common/ui-traced-variable.tcc
View File

@@ -19,28 +19,28 @@
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#ifndef UI_TRACED_VARIABLE_TCC
#define UI_TRACED_VARIABLE_TCC
#ifndef UI_VARIABLE_TRACER_H
#define UI_VARIABLE_TRACER_H
#include "ns3/callback.h"
#include <stdint.h>
namespace ns3 {
class UiTracedVariableBase {
class UiVariableTracerBase {
public:
typedef Callback<void, uint64_t, uint64_t> ChangeNotifyCallback;
UiTracedVariableBase ()
UiVariableTracerBase ()
: m_callback () {}
/* We don't want to copy the base callback. Only set_callback on
* a specific instance will do something to it. */
UiTracedVariableBase (UiTracedVariableBase const &o)
UiVariableTracerBase (UiVariableTracerBase const &o)
: m_callback () {}
UiTracedVariableBase &operator = (UiTracedVariableBase const &o) {
UiVariableTracerBase &operator = (UiVariableTracerBase const &o) {
return *this;
}
~UiTracedVariableBase () {}
~UiVariableTracerBase () {}
void set_callback(ChangeNotifyCallback callback) {
m_callback = callback;
@@ -56,7 +56,7 @@ private:
};
template <typename T>
class SiTracedVariable;
class SiVariableTracer;
/**
@@ -69,12 +69,12 @@ class SiTracedVariable;
*
* To instantiate a 32-bit unsigned variable (to store
* a TCP counter for example), you would create a variable of type
* ns3::UiTracedVariable<uint32_t> :
* ns3::UiVariableTracer<uint32_t> :
\code
#include <stdint.h>
#include "ns3/ui-traced-variable.tcc"
ns3::UiTracedVariable<uint32_t> var;
ns3::UiVariableTracer<uint32_t> var;
\endcode
* and you would use it like any other variable of type uint32_t:
\code
@@ -83,44 +83,44 @@ class SiTracedVariable;
\endcode
*/
template <typename T>
class UiTracedVariable : public UiTracedVariableBase {
class UiVariableTracer : public UiVariableTracerBase {
public:
UiTracedVariable ()
UiVariableTracer ()
: m_var ()
{}
UiTracedVariable (T const &var)
UiVariableTracer (T const &var)
: m_var (var)
{}
UiTracedVariable &operator = (UiTracedVariable const &o) {
UiVariableTracer &operator = (UiVariableTracer const &o) {
assign (o.get ());
return *this;
}
template <typename TT>
UiTracedVariable &operator = (UiTracedVariable<TT> const &o) {
UiVariableTracer &operator = (UiVariableTracer<TT> const &o) {
assign (o.get ());
return *this;
}
template <typename TT>
UiTracedVariable &operator = (SiTracedVariable<TT> const &o) {
UiVariableTracer &operator = (SiVariableTracer<TT> const &o) {
assign (o.get ());
return *this;
}
UiTracedVariable &operator++ () {
UiVariableTracer &operator++ () {
assign (get () + 1);
return *this;
}
UiTracedVariable &operator-- () {
UiVariableTracer &operator-- () {
assign (get () - 1);
return *this;
}
UiTracedVariable operator++ (int) {
UiTracedVariable old (*this);
UiVariableTracer operator++ (int) {
UiVariableTracer old (*this);
++*this;
return old;
}
UiTracedVariable operator-- (int) {
UiTracedVariable old (*this);
UiVariableTracer operator-- (int) {
UiVariableTracer old (*this);
--*this;
return old;
}
@@ -142,98 +142,98 @@ private:
};
template <typename T>
UiTracedVariable<T> &operator += (UiTracedVariable<T> &lhs, UiTracedVariable<T> const &rhs) {
UiVariableTracer<T> &operator += (UiVariableTracer<T> &lhs, UiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () + rhs.get ());
return lhs;
}
template <typename T>
UiTracedVariable<T> &operator -= (UiTracedVariable<T> &lhs, UiTracedVariable<T> const &rhs) {
UiVariableTracer<T> &operator -= (UiVariableTracer<T> &lhs, UiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () - rhs.get ());
return lhs;
}
template <typename T>
UiTracedVariable<T> &operator *= (UiTracedVariable<T> &lhs, UiTracedVariable<T> const &rhs) {
UiVariableTracer<T> &operator *= (UiVariableTracer<T> &lhs, UiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () * rhs.get ());
return lhs;
}
template <typename T>
UiTracedVariable<T> &operator /= (UiTracedVariable<T> &lhs, UiTracedVariable<T> const &rhs) {
UiVariableTracer<T> &operator /= (UiVariableTracer<T> &lhs, UiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () / rhs.get ());
return lhs;
}
template <typename T>
UiTracedVariable<T> &operator <<= (UiTracedVariable<T> &lhs, UiTracedVariable<T> const &rhs) {
UiVariableTracer<T> &operator <<= (UiVariableTracer<T> &lhs, UiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () << rhs.get ());
return lhs;
}
template <typename T>
UiTracedVariable<T> &operator >>= (UiTracedVariable<T> &lhs, UiTracedVariable<T> const &rhs) {
UiVariableTracer<T> &operator >>= (UiVariableTracer<T> &lhs, UiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () >> rhs.get ());
return lhs;
}
template <typename T>
UiTracedVariable<T> &operator &= (UiTracedVariable<T> &lhs, UiTracedVariable<T> const &rhs) {
UiVariableTracer<T> &operator &= (UiVariableTracer<T> &lhs, UiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () & rhs.get ());
return lhs;
}
template <typename T>
UiTracedVariable<T> &operator |= (UiTracedVariable<T> &lhs, UiTracedVariable<T> const &rhs) {
UiVariableTracer<T> &operator |= (UiVariableTracer<T> &lhs, UiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () | rhs.get ());
return lhs;
}
template <typename T>
UiTracedVariable<T> &operator ^= (UiTracedVariable<T> &lhs, UiTracedVariable<T> const &rhs) {
UiVariableTracer<T> &operator ^= (UiVariableTracer<T> &lhs, UiVariableTracer<T> const &rhs) {
lhs.assign (lhs.get () ^ rhs.get ());
return lhs;
}
template <typename T, typename U>
UiTracedVariable<T> &operator += (UiTracedVariable<T> &lhs, U const &rhs) {
UiVariableTracer<T> &operator += (UiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () + rhs);
return lhs;
}
template <typename T, typename U>
UiTracedVariable<T> &operator -= (UiTracedVariable<T> &lhs, U const &rhs) {
UiVariableTracer<T> &operator -= (UiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () - rhs);
return lhs;
}
template <typename T, typename U>
UiTracedVariable<T> &operator *= (UiTracedVariable<T> &lhs, U const &rhs) {
UiVariableTracer<T> &operator *= (UiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () * rhs);
return lhs;
}
template <typename T, typename U>
UiTracedVariable<T> &operator /= (UiTracedVariable<T> &lhs, U const &rhs) {
UiVariableTracer<T> &operator /= (UiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () / rhs);
return lhs;
}
template <typename T, typename U>
UiTracedVariable<T> &operator <<= (UiTracedVariable<T> &lhs, U const &rhs) {
UiVariableTracer<T> &operator <<= (UiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () << rhs);
return lhs;
}
template <typename T, typename U>
UiTracedVariable<T> &operator >>= (UiTracedVariable<T> &lhs, U const &rhs) {
UiVariableTracer<T> &operator >>= (UiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () >> rhs);
return lhs;
}
template <typename T, typename U>
UiTracedVariable<T> &operator &= (UiTracedVariable<T> &lhs, U const &rhs) {
UiVariableTracer<T> &operator &= (UiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () & rhs);
return lhs;
}
template <typename T, typename U>
UiTracedVariable<T> &operator |= (UiTracedVariable<T> &lhs, U const &rhs) {
UiVariableTracer<T> &operator |= (UiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () | rhs);
return lhs;
}
template <typename T, typename U>
UiTracedVariable<T> &operator ^= (UiTracedVariable<T> &lhs, U const &rhs) {
UiVariableTracer<T> &operator ^= (UiVariableTracer<T> &lhs, U const &rhs) {
lhs.assign (lhs.get () ^ rhs);
return lhs;
}
}; // namespace ns3
#endif /* UI_TRACED_VARIABLE_TCC */
#endif /* UI_VARIABLE_TRACER_H */