diff --git a/samples/main-trace.cc b/samples/main-trace.cc
index 101e84525..a38e00706 100644
--- a/samples/main-trace.cc
+++ b/samples/main-trace.cc
@@ -10,7 +10,7 @@
 using namespace ns3;
 
 CallbackTracer<Packet> a;
-UiTracedVariable<unsigned short> b;
+UiVariableTracer<unsigned short> b;
 StreamTracer c;
 CallbackTracer<double, int> d;
 
diff --git a/src/common/f-traced-variable.tcc b/src/common/f-traced-variable.tcc
index 4109c27c0..43233a5e1 100644
--- a/src/common/f-traced-variable.tcc
+++ b/src/common/f-traced-variable.tcc
@@ -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 */
diff --git a/src/common/si-traced-variable.tcc b/src/common/si-traced-variable.tcc
index 3221bf3fa..bd4c1527c 100644
--- a/src/common/si-traced-variable.tcc
+++ b/src/common/si-traced-variable.tcc
@@ -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 */
diff --git a/src/common/trace-container.cc b/src/common/trace-container.cc
index 907b57d9f..d21725a30 100644
--- a/src/common/trace-container.cc
+++ b/src/common/trace-container.cc
@@ -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);
 }
diff --git a/src/common/trace-container.h b/src/common/trace-container.h
index 422ca17be..8ac333f2d 100644
--- a/src/common/trace-container.h
+++ b/src/common/trace-container.h
@@ -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;
diff --git a/src/common/traced-variable-test.cc b/src/common/traced-variable-test.cc
index 5c8d6e5a2..4ae872b92 100644
--- a/src/common/traced-variable-test.cc
+++ b/src/common/traced-variable-test.cc
@@ -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
 
diff --git a/src/common/ui-traced-variable.tcc b/src/common/ui-traced-variable.tcc
index f8b575225..9db34bfcf 100644
--- a/src/common/ui-traced-variable.tcc
+++ b/src/common/ui-traced-variable.tcc
@@ -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 */