EventTraceSource -> TracedCallback, ValueTraceSource -> TracedValue.

src/core/attribute-test.cc

@@ -8,7 +8,7 @@
 #include "random-variable.h"
 #include "double.h"
 #include "object-vector.h"
-#include "value-trace-source.h"
+#include "traced-value.h"
 #include "trace-source-accessor.h"
 
 namespace ns3 {
@@ -203,10 +203,10 @@ private:
   RandomVariable m_random;
   std::vector<Ptr<Derived> > m_vector1;
   std::vector<Ptr<Derived> > m_vector2;
-  ValueTraceSource<int8_t> m_intSrc1;
-  ValueTraceSource<int8_t> m_intSrc2;
-  EventTraceSource<double, int, float> m_cb;
-  ValueTraceSource<ValueClassTest> m_valueSrc;
+  TracedValue<int8_t> m_intSrc1;
+  TracedValue<int8_t> m_intSrc2;
+  TracedCallback<double, int, float> m_cb;
+  TracedValue<ValueClassTest> m_valueSrc;
 };
 
 

src/core/traced-callback.cc

@@ -18,7 +18,7 @@
  *
  * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
  */
-#include "event-trace-source.h"
+#include "traced-callback.h"
 
 #ifdef RUN_SELF_TESTS
 
@@ -26,11 +26,11 @@
 
 namespace ns3 {
 
-class EventTraceSourceTest : public Test 
+class TracedCallbackTest : public Test 
 {
 public:
-  EventTraceSourceTest ();
-  virtual ~EventTraceSourceTest ();
+  TracedCallbackTest ();
+  virtual ~TracedCallbackTest ();
   virtual bool RunTests (void);
 private:
   void CbOne (uint8_t a, double b);
@@ -40,50 +40,50 @@ private:
   bool m_two;
 };
 
-EventTraceSourceTest::EventTraceSourceTest ()
-  : Test ("EventTraceSource")
+TracedCallbackTest::TracedCallbackTest ()
+  : Test ("TracedCallback")
 {}
-EventTraceSourceTest::~EventTraceSourceTest ()
+TracedCallbackTest::~TracedCallbackTest ()
 {}
 void
-EventTraceSourceTest::CbOne (uint8_t a, double b)
+TracedCallbackTest::CbOne (uint8_t a, double b)
 {
   m_one = true;
 }
 void
-EventTraceSourceTest::CbTwo (uint8_t a, double b)
+TracedCallbackTest::CbTwo (uint8_t a, double b)
 {
   m_two = true;
 }
 bool 
-EventTraceSourceTest::RunTests (void)
+TracedCallbackTest::RunTests (void)
 {
   bool result = true;
 
-  EventTraceSource<uint8_t,double> trace;
-  trace.Connect (MakeCallback (&EventTraceSourceTest::CbOne, this));
-  trace.Connect (MakeCallback (&EventTraceSourceTest::CbTwo, this));
+  TracedCallback<uint8_t,double> trace;
+  trace.Connect (MakeCallback (&TracedCallbackTest::CbOne, this));
+  trace.Connect (MakeCallback (&TracedCallbackTest::CbTwo, this));
   m_one = false;
   m_two = false;
   trace (1, 2);
   NS_TEST_ASSERT (m_one);
   NS_TEST_ASSERT (m_two);
 
-  trace.Disconnect (MakeCallback (&EventTraceSourceTest::CbOne, this));
+  trace.Disconnect (MakeCallback (&TracedCallbackTest::CbOne, this));
   m_one = false;
   m_two = false;
   trace (1, 2);
   NS_TEST_ASSERT (!m_one);
   NS_TEST_ASSERT (m_two);
-  trace.Disconnect (MakeCallback (&EventTraceSourceTest::CbTwo, this));
+  trace.Disconnect (MakeCallback (&TracedCallbackTest::CbTwo, this));
   m_one = false;
   m_two = false;
   trace (1, 2);
   NS_TEST_ASSERT (!m_one);
   NS_TEST_ASSERT (!m_two);
 
-  trace.Connect (MakeCallback (&EventTraceSourceTest::CbOne, this));
-  trace.Connect (MakeCallback (&EventTraceSourceTest::CbTwo, this));
+  trace.Connect (MakeCallback (&TracedCallbackTest::CbOne, this));
+  trace.Connect (MakeCallback (&TracedCallbackTest::CbTwo, this));
   m_one = false;
   m_two = false;
   trace (1, 2);
@@ -93,7 +93,7 @@ EventTraceSourceTest::RunTests (void)
   return result;
 }
 
-static EventTraceSourceTest g_eventTraceTest;
+static TracedCallbackTest g_eventTraceTest;
 
 }//namespace ns3
 

src/core/traced-callback.h

@@ -19,8 +19,8 @@
  * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
  */
 
-#ifndef EVENT_TRACE_SOURCE_H
-#define EVENT_TRACE_SOURCE_H
+#ifndef TRACED_CALLBACK_H
+#define TRACED_CALLBACK_H
 
 #include <list>
 #include "callback.h"
@@ -36,10 +36,10 @@ namespace ns3 {
  */
 template<typename T1 = empty, typename T2 = empty, 
          typename T3 = empty, typename T4 = empty>
-class EventTraceSource 
+class TracedCallback 
 {
 public:
-  EventTraceSource ();
+  TracedCallback ();
   void Connect (const CallbackBase & callback);
   void Disconnect (const CallbackBase & callback);
   void operator() (void) const;
@@ -62,13 +62,13 @@ namespace ns3 {
 
 template<typename T1, typename T2, 
          typename T3, typename T4>
-EventTraceSource<T1,T2,T3,T4>::EventTraceSource ()
+TracedCallback<T1,T2,T3,T4>::TracedCallback ()
   : m_callbackList () 
 {}
 template<typename T1, typename T2, 
          typename T3, typename T4>
 void 
-EventTraceSource<T1,T2,T3,T4>::Connect (const CallbackBase & callback)
+TracedCallback<T1,T2,T3,T4>::Connect (const CallbackBase & callback)
 {
   Callback<void,T1,T2,T3,T4> cb;
   cb.Assign (callback);
@@ -77,7 +77,7 @@ EventTraceSource<T1,T2,T3,T4>::Connect (const CallbackBase & callback)
 template<typename T1, typename T2, 
          typename T3, typename T4>
 void 
-EventTraceSource<T1,T2,T3,T4>::Disconnect (const CallbackBase & callback)
+TracedCallback<T1,T2,T3,T4>::Disconnect (const CallbackBase & callback)
 {
   for (typename CallbackList::iterator i = m_callbackList.begin ();
        i != m_callbackList.end (); /* empty */)
@@ -95,7 +95,7 @@ EventTraceSource<T1,T2,T3,T4>::Disconnect (const CallbackBase & callback)
 template<typename T1, typename T2, 
          typename T3, typename T4>
 void 
-EventTraceSource<T1,T2,T3,T4>::operator() (void) const
+TracedCallback<T1,T2,T3,T4>::operator() (void) const
 {
   for (typename CallbackList::const_iterator i = m_callbackList.begin ();
        i != m_callbackList.end (); i++)
@@ -106,7 +106,7 @@ EventTraceSource<T1,T2,T3,T4>::operator() (void) const
 template<typename T1, typename T2, 
          typename T3, typename T4>
 void 
-EventTraceSource<T1,T2,T3,T4>::operator() (T1 a1) const
+TracedCallback<T1,T2,T3,T4>::operator() (T1 a1) const
 {
   for (typename CallbackList::const_iterator i = m_callbackList.begin ();
        i != m_callbackList.end (); i++)
@@ -117,7 +117,7 @@ EventTraceSource<T1,T2,T3,T4>::operator() (T1 a1) const
 template<typename T1, typename T2, 
          typename T3, typename T4>
 void 
-EventTraceSource<T1,T2,T3,T4>::operator() (T1 a1, T2 a2) const
+TracedCallback<T1,T2,T3,T4>::operator() (T1 a1, T2 a2) const
 {
   for (typename CallbackList::const_iterator i = m_callbackList.begin ();
        i != m_callbackList.end (); i++)
@@ -128,7 +128,7 @@ EventTraceSource<T1,T2,T3,T4>::operator() (T1 a1, T2 a2) const
 template<typename T1, typename T2, 
          typename T3, typename T4>
 void 
-EventTraceSource<T1,T2,T3,T4>::operator() (T1 a1, T2 a2, T3 a3) const
+TracedCallback<T1,T2,T3,T4>::operator() (T1 a1, T2 a2, T3 a3) const
 {
   for (typename CallbackList::const_iterator i = m_callbackList.begin ();
        i != m_callbackList.end (); i++)
@@ -139,7 +139,7 @@ EventTraceSource<T1,T2,T3,T4>::operator() (T1 a1, T2 a2, T3 a3) const
 template<typename T1, typename T2, 
          typename T3, typename T4>
 void 
-EventTraceSource<T1,T2,T3,T4>::operator() (T1 a1, T2 a2, T3 a3, T4 a4) const
+TracedCallback<T1,T2,T3,T4>::operator() (T1 a1, T2 a2, T3 a3, T4 a4) const
 {
   for (typename CallbackList::const_iterator i = m_callbackList.begin ();
        i != m_callbackList.end (); i++)
@@ -150,4 +150,4 @@ EventTraceSource<T1,T2,T3,T4>::operator() (T1 a1, T2 a2, T3 a3, T4 a4) const
 
 }//namespace ns3
 
-#endif /* CALLBACK_TRACE_H */
+#endif /* TRACED_CALLBACK_H */

src/core/traced-value.h

@@ -0,0 +1,480 @@
+#ifndef TRACED_VALUE_H
+#define TRACED_VALUE_H
+
+#include "traced-callback.h"
+#include "integer.h"
+#include "uinteger.h"
+#include "boolean.h"
+#include "double.h"
+#include "enum.h"
+
+#define TRACE(x)
+
+namespace ns3 {
+
+template <typename T>
+class TracedValue
+{
+public:
+  TracedValue ()
+    : m_v () {}
+  TracedValue (const TracedValue &o)
+    : m_v (o.m_v) {}
+  TracedValue (const T &v)
+    : m_v (v) {}
+  operator T () const {
+    return m_v;
+  }
+  TracedValue &operator = (const TracedValue &o) {
+    TRACE ("x=");
+    Set (o.m_v);
+    return *this;
+  }
+  TracedValue (const Integer &value) 
+    : m_v (value.Get ()) {}
+  operator Integer () const {
+    return Integer (m_v);
+  }
+  TracedValue (const Uinteger &value)
+    : m_v (value.Get ()) {}
+  operator Uinteger () const {
+    return Uinteger (m_v);
+  }
+  TracedValue (const Boolean &value)
+    : m_v (value.Get ()) {}
+  operator Boolean () const {
+    return Boolean (m_v);
+  }
+  TracedValue (const Enum &value)
+    : m_v (value.Get ()) {}
+  operator Enum () const {
+    return Enum (m_v);
+  }
+  void Connect (const CallbackBase &cb) {
+    m_cb.Connect (cb);
+  }
+  void Disconnect (const CallbackBase &cb) {
+    m_cb.Disconnect (cb);
+  }
+  void Set (const T &v) {
+    if (m_v != v)
+      {
+	m_cb (m_v, v);
+	m_v = v;
+      }
+  }
+  T Get (void) const {
+    return m_v;
+  }
+  TracedValue &operator++ () {
+    TRACE ("++x");
+    T tmp = Get ();
+    ++tmp;
+    Set (tmp);
+    return *this;
+  }
+  TracedValue &operator-- () {
+    TRACE ("--x");
+    T tmp = Get ();
+    --tmp;
+    Set (tmp);
+    return *this;
+  }
+  TracedValue operator++ (int) {
+    TRACE ("x++");
+    TracedValue old (*this);
+    T tmp = Get ();
+    tmp++;
+    Set (tmp);
+    return old;
+  }
+  TracedValue operator-- (int) {
+    TRACE ("x--");
+    TracedValue old (*this);
+    T tmp = Get ();
+    tmp--;
+    Set (tmp);
+    return old;
+  }
+private:
+  T m_v;
+  TracedCallback<T,T> m_cb;
+};
+
+template <typename T, typename U>
+bool operator == (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
+{
+  TRACE ("x==x");
+  return lhs.Get () == rhs.Get ();
+}
+template <typename T, typename U>
+bool operator == (const TracedValue<T> &lhs, const U &rhs)
+{
+  TRACE ("x==");
+  return lhs.Get () == rhs;
+}
+template <typename T, typename U>
+bool operator == (const U &lhs, const TracedValue<T> &rhs)
+{
+  TRACE ("==x");
+  return lhs == rhs.Get ();
+}
+
+template <typename T, typename U>
+bool operator != (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
+{
+  TRACE ("x!=x");
+  return lhs.Get () != rhs.Get ();
+}
+template <typename T, typename U>
+bool operator != (const TracedValue<T> &lhs, const U &rhs)
+{
+  TRACE ("x!=");
+  return lhs.Get () != rhs;
+}
+template <typename T, typename U>
+bool operator != (const U &lhs, const TracedValue<T> &rhs)
+{
+  TRACE ("!=x");
+  return lhs != rhs.Get ();
+}
+
+template <typename T, typename U>
+bool operator <= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
+{
+  TRACE ("x<=x");
+  return lhs.Get () <= rhs.Get ();
+}
+template <typename T, typename U>
+bool operator <= (const TracedValue<T> &lhs, const U &rhs)
+{
+  TRACE ("x<=");
+  return lhs.Get () <= rhs;
+}
+template <typename T, typename U>
+bool operator <= (const U &lhs, const TracedValue<T> &rhs)
+{
+  TRACE ("<=x");
+  return lhs <= rhs.Get ();
+}
+template <typename T, typename U>
+bool operator >= (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
+{
+  TRACE ("x>=x");
+  return lhs.Get () >= rhs.Get ();
+}
+template <typename T, typename U>
+bool operator >= (const TracedValue<T> &lhs, const U &rhs)
+{
+  TRACE ("x>=");
+  return lhs.Get () >= rhs;
+}
+template <typename T, typename U>
+bool operator >= (const U &lhs, const TracedValue<T> &rhs)
+{
+  TRACE (">=x");
+  return lhs >= rhs.Get ();
+}
+
+template <typename T, typename U>
+bool operator < (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
+{
+  TRACE ("x<x");
+  return lhs.Get () < rhs.Get ();
+}
+template <typename T, typename U>
+bool operator < (const TracedValue<T> &lhs, const U &rhs)
+{
+  TRACE ("x<");
+  return lhs.Get () < rhs;
+}
+template <typename T, typename U>
+bool operator < (const U &lhs, const TracedValue<T> &rhs)
+{
+  TRACE ("<x");
+  return lhs < rhs.Get ();
+}
+template <typename T, typename U>
+bool operator > (const TracedValue<T> &lhs, const TracedValue<U> &rhs)
+{
+  TRACE ("x>x");
+  return lhs.Get () > rhs.Get ();
+}
+template <typename T, typename U>
+bool operator > (const TracedValue<T> &lhs, const U &rhs)
+{
+  TRACE ("x>");
+  return lhs.Get () > rhs;
+}
+template <typename T, typename U>
+bool operator > (const U &lhs, const TracedValue<T> &rhs)
+{
+  TRACE (">x");
+  return lhs > rhs.Get ();
+}
+template <typename T, typename U>
+TracedValue<T> &operator += (TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x+=");
+  T tmp = lhs.Get ();
+  tmp += rhs;
+  lhs.Set (tmp);
+  return lhs;
+}
+template <typename T, typename U>
+TracedValue<T> &operator -= (TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x-=");
+  T tmp = lhs.Get ();
+  tmp -= rhs;
+  lhs.Set (tmp);
+  return lhs;
+}
+template <typename T, typename U>
+TracedValue<T> &operator *= (TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x*=");
+  T tmp = lhs.Get ();
+  tmp *= rhs;
+  lhs.Set (tmp);
+  return lhs;
+}
+template <typename T, typename U>
+TracedValue<T> &operator /= (TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x/=");
+  T tmp = lhs.Get ();
+  tmp /= rhs;
+  lhs.Set (tmp);
+  return lhs;
+}
+template <typename T, typename U>
+TracedValue<T> &operator %= (TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x%=");
+  T tmp = lhs.Get ();
+  tmp %= rhs;
+  lhs.Set (tmp);
+  return lhs;
+}
+template <typename T, typename U>
+TracedValue<T> &operator <<= (TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x<<=");
+  T tmp = lhs.Get ();
+  tmp <<= rhs;
+  lhs.Set (tmp);
+  return lhs;
+}
+template <typename T, typename U>
+TracedValue<T> &operator >>= (TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x>>=");
+  T tmp = lhs.Get ();
+  tmp >>= rhs;
+  lhs.Set (tmp);
+  return lhs;
+}
+template <typename T, typename U>
+TracedValue<T> &operator &= (TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x&=");
+  T tmp = lhs.Get ();
+  tmp &= rhs;
+  lhs.Set (tmp);
+  return lhs;
+}
+template <typename T, typename U>
+TracedValue<T> &operator |= (TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x|=");
+  T tmp = lhs.Get ();
+  tmp |= rhs;
+  lhs.Set (tmp);
+  return lhs;
+}
+template <typename T, typename U>
+TracedValue<T> &operator ^= (TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x^=");
+  T tmp = lhs.Get ();
+  tmp ^= rhs;
+  lhs.Set (tmp);
+  return lhs;
+}
+template <typename T, typename U>
+TracedValue<T> operator + (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
+  TRACE ("x+x");
+  return TracedValue<T> (lhs.Get () + rhs.Get ());
+}
+template <typename T, typename U>
+TracedValue<T> operator + (const TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x+");
+  return TracedValue<T> (lhs.Get () + rhs);
+}
+template <typename T, typename U>
+TracedValue<T> operator + (const U &lhs, const TracedValue<T> &rhs) {
+  TRACE ("+x");
+  return TracedValue<T> (lhs + rhs.Get ());
+}
+
+template <typename T, typename U>
+TracedValue<T> operator - (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
+  TRACE ("x-x");
+  return TracedValue<T> (lhs.Get () - rhs.Get ());
+}
+template <typename T, typename U>
+TracedValue<T> operator - (const TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x-");
+  return TracedValue<T> (lhs.Get () - rhs);
+}
+template <typename T, typename U>
+TracedValue<T> operator - (const U &lhs, const TracedValue<T> &rhs) {
+  TRACE ("-x");
+  return TracedValue<T> (lhs - rhs.Get ());
+}
+
+template <typename T, typename U>
+TracedValue<T> operator * (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
+  TRACE ("x*x");
+  return TracedValue<T> (lhs.Get () * rhs.Get ());
+}
+template <typename T, typename U>
+TracedValue<T> operator * (const TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x*");
+  return TracedValue<T> (lhs.Get () * rhs);
+}
+template <typename T, typename U>
+TracedValue<T> operator * (const U &lhs, const TracedValue<T> &rhs) {
+  TRACE ("*x");
+  return TracedValue<T> (lhs - rhs.Get ());
+}
+
+template <typename T, typename U>
+TracedValue<T> operator / (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
+  TRACE ("x/x");
+  return TracedValue<T> (lhs.Get () / rhs.Get ());
+}
+template <typename T, typename U>
+TracedValue<T> operator / (const TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x/");
+  return TracedValue<T> (lhs.Get () / rhs);
+}
+template <typename T, typename U>
+TracedValue<T> operator / (const U &lhs, const TracedValue<T> &rhs) {
+  TRACE ("/x");
+  return TracedValue<T> (lhs / rhs.Get ());
+}
+
+template <typename T, typename U>
+TracedValue<T> operator % (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
+  TRACE ("x%x");
+  return TracedValue<T> (lhs.Get () % rhs.Get ());
+}
+template <typename T, typename U>
+TracedValue<T> operator % (const TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x%");
+  return TracedValue<T> (lhs.Get () % rhs);
+}
+template <typename T, typename U>
+TracedValue<T> operator % (const U &lhs, const TracedValue<T> &rhs) {
+  TRACE ("%x");
+  return TracedValue<T> (lhs % rhs.Get ());
+}
+
+template <typename T, typename U>
+TracedValue<T> operator ^ (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
+  TRACE ("x^x");
+  return TracedValue<T> (lhs.Get () ^ rhs.Get ());
+}
+template <typename T, typename U>
+TracedValue<T> operator ^ (const TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x^");
+  return TracedValue<T> (lhs.Get () ^ rhs);
+}
+template <typename T, typename U>
+TracedValue<T> operator ^ (const U &lhs, const TracedValue<T> &rhs) {
+  TRACE ("^x");
+  return TracedValue<T> (lhs ^ rhs.Get ());
+}
+
+template <typename T, typename U>
+TracedValue<T> operator | (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
+  TRACE ("x|x");
+  return TracedValue<T> (lhs.Get () | rhs.Get ());
+}
+template <typename T, typename U>
+TracedValue<T> operator | (const TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x|");
+  return TracedValue<T> (lhs.Get () | rhs);
+}
+template <typename T, typename U>
+TracedValue<T> operator | (const U &lhs, const TracedValue<T> &rhs) {
+  TRACE ("|x");
+  return TracedValue<T> (lhs | rhs.Get ());
+}
+
+template <typename T, typename U>
+TracedValue<T> operator & (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
+  TRACE ("x&x");
+  return TracedValue<T> (lhs.Get () & rhs.Get ());
+}
+template <typename T, typename U>
+TracedValue<T> operator & (const TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x&");
+  return TracedValue<T> (lhs.Get () & rhs);
+}
+template <typename T, typename U>
+TracedValue<T> operator & (const U &lhs, const TracedValue<T> &rhs) {
+  TRACE ("&x");
+  return TracedValue<T> (lhs & rhs.Get ());
+}
+
+template <typename T, typename U>
+TracedValue<T> operator << (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
+  TRACE ("x<<x");
+  return TracedValue<T> (lhs.Get () << rhs.Get ());
+}
+template <typename T, typename U>
+TracedValue<T> operator << (const TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x<<");
+  return TracedValue<T> (lhs.Get () << rhs);
+}
+template <typename T, typename U>
+TracedValue<T> operator << (const U &lhs, const TracedValue<T> &rhs) {
+  TRACE ("<<x");
+  return TracedValue<T> (lhs << rhs.Get ());
+}
+
+template <typename T, typename U>
+TracedValue<T> operator >> (const TracedValue<T> &lhs, const TracedValue<U> &rhs) {
+  TRACE ("x>>x");
+  return TracedValue<T> (lhs.Get () >> rhs.Get ());
+}
+template <typename T, typename U>
+TracedValue<T> operator >> (const TracedValue<T> &lhs, const U &rhs) {
+  TRACE ("x>>");
+  return TracedValue<T> (lhs.Get () >> rhs);
+}
+template <typename T, typename U>
+TracedValue<T> operator >> (const U &lhs, const TracedValue<T> &rhs) {
+  TRACE (">>x");
+  return TracedValue<T> (lhs >> rhs.Get ());
+}
+
+
+template <typename T>
+TracedValue<T> operator + (const TracedValue<T> &lhs) {
+  TRACE ("(+x)");
+  return TracedValue<T> (+lhs.Get ());
+}
+template <typename T>
+TracedValue<T> operator - (const TracedValue<T> &lhs) {
+  TRACE ("(-x)");
+  return TracedValue<T> (-lhs.Get ());
+}
+template <typename T>
+TracedValue<T> operator ~ (const TracedValue<T> &lhs) {
+  TRACE ("(~x)");
+  return TracedValue<T> (~lhs.Get ());
+}
+template <typename T>
+TracedValue<T> operator ! (const TracedValue<T> &lhs) {
+  TRACE ("(!x)");
+  return TracedValue<T> (!lhs.Get ());
+}
+
+
+} // namespace ns3
+
+#endif /* TRACED_VALUE_H */

src/core/value-trace-source.h

@@ -1,480 +0,0 @@
-#ifndef VALUE_TRACE_SOURCE_H
-#define VALUE_TRACE_SOURCE_H
-
-#include "event-trace-source.h"
-#include "integer.h"
-#include "uinteger.h"
-#include "boolean.h"
-#include "double.h"
-#include "enum.h"
-
-#define TRACE(x)
-
-namespace ns3 {
-
-template <typename T>
-class ValueTraceSource
-{
-public:
-  ValueTraceSource ()
-    : m_v () {}
-  ValueTraceSource (const ValueTraceSource &o)
-    : m_v (o.m_v) {}
-  ValueTraceSource (const T &v)
-    : m_v (v) {}
-  operator T () const {
-    return m_v;
-  }
-  ValueTraceSource &operator = (const ValueTraceSource &o) {
-    TRACE ("x=");
-    Set (o.m_v);
-    return *this;
-  }
-  ValueTraceSource (const Integer &value) 
-    : m_v (value.Get ()) {}
-  operator Integer () const {
-    return Integer (m_v);
-  }
-  ValueTraceSource (const Uinteger &value)
-    : m_v (value.Get ()) {}
-  operator Uinteger () const {
-    return Uinteger (m_v);
-  }
-  ValueTraceSource (const Boolean &value)
-    : m_v (value.Get ()) {}
-  operator Boolean () const {
-    return Boolean (m_v);
-  }
-  ValueTraceSource (const Enum &value)
-    : m_v (value.Get ()) {}
-  operator Enum () const {
-    return Enum (m_v);
-  }
-  void Connect (const CallbackBase &cb) {
-    m_cb.Connect (cb);
-  }
-  void Disconnect (const CallbackBase &cb) {
-    m_cb.Disconnect (cb);
-  }
-  void Set (const T &v) {
-    if (m_v != v)
-      {
-	m_cb (m_v, v);
-	m_v = v;
-      }
-  }
-  T Get (void) const {
-    return m_v;
-  }
-  ValueTraceSource &operator++ () {
-    TRACE ("++x");
-    T tmp = Get ();
-    ++tmp;
-    Set (tmp);
-    return *this;
-  }
-  ValueTraceSource &operator-- () {
-    TRACE ("--x");
-    T tmp = Get ();
-    --tmp;
-    Set (tmp);
-    return *this;
-  }
-  ValueTraceSource operator++ (int) {
-    TRACE ("x++");
-    ValueTraceSource old (*this);
-    T tmp = Get ();
-    tmp++;
-    Set (tmp);
-    return old;
-  }
-  ValueTraceSource operator-- (int) {
-    TRACE ("x--");
-    ValueTraceSource old (*this);
-    T tmp = Get ();
-    tmp--;
-    Set (tmp);
-    return old;
-  }
-private:
-  T m_v;
-  EventTraceSource<T,T> m_cb;
-};
-
-template <typename T, typename U>
-bool operator == (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs)
-{
-  TRACE ("x==x");
-  return lhs.Get () == rhs.Get ();
-}
-template <typename T, typename U>
-bool operator == (const ValueTraceSource<T> &lhs, const U &rhs)
-{
-  TRACE ("x==");
-  return lhs.Get () == rhs;
-}
-template <typename T, typename U>
-bool operator == (const U &lhs, const ValueTraceSource<T> &rhs)
-{
-  TRACE ("==x");
-  return lhs == rhs.Get ();
-}
-
-template <typename T, typename U>
-bool operator != (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs)
-{
-  TRACE ("x!=x");
-  return lhs.Get () != rhs.Get ();
-}
-template <typename T, typename U>
-bool operator != (const ValueTraceSource<T> &lhs, const U &rhs)
-{
-  TRACE ("x!=");
-  return lhs.Get () != rhs;
-}
-template <typename T, typename U>
-bool operator != (const U &lhs, const ValueTraceSource<T> &rhs)
-{
-  TRACE ("!=x");
-  return lhs != rhs.Get ();
-}
-
-template <typename T, typename U>
-bool operator <= (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs)
-{
-  TRACE ("x<=x");
-  return lhs.Get () <= rhs.Get ();
-}
-template <typename T, typename U>
-bool operator <= (const ValueTraceSource<T> &lhs, const U &rhs)
-{
-  TRACE ("x<=");
-  return lhs.Get () <= rhs;
-}
-template <typename T, typename U>
-bool operator <= (const U &lhs, const ValueTraceSource<T> &rhs)
-{
-  TRACE ("<=x");
-  return lhs <= rhs.Get ();
-}
-template <typename T, typename U>
-bool operator >= (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs)
-{
-  TRACE ("x>=x");
-  return lhs.Get () >= rhs.Get ();
-}
-template <typename T, typename U>
-bool operator >= (const ValueTraceSource<T> &lhs, const U &rhs)
-{
-  TRACE ("x>=");
-  return lhs.Get () >= rhs;
-}
-template <typename T, typename U>
-bool operator >= (const U &lhs, const ValueTraceSource<T> &rhs)
-{
-  TRACE (">=x");
-  return lhs >= rhs.Get ();
-}
-
-template <typename T, typename U>
-bool operator < (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs)
-{
-  TRACE ("x<x");
-  return lhs.Get () < rhs.Get ();
-}
-template <typename T, typename U>
-bool operator < (const ValueTraceSource<T> &lhs, const U &rhs)
-{
-  TRACE ("x<");
-  return lhs.Get () < rhs;
-}
-template <typename T, typename U>
-bool operator < (const U &lhs, const ValueTraceSource<T> &rhs)
-{
-  TRACE ("<x");
-  return lhs < rhs.Get ();
-}
-template <typename T, typename U>
-bool operator > (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs)
-{
-  TRACE ("x>x");
-  return lhs.Get () > rhs.Get ();
-}
-template <typename T, typename U>
-bool operator > (const ValueTraceSource<T> &lhs, const U &rhs)
-{
-  TRACE ("x>");
-  return lhs.Get () > rhs;
-}
-template <typename T, typename U>
-bool operator > (const U &lhs, const ValueTraceSource<T> &rhs)
-{
-  TRACE (">x");
-  return lhs > rhs.Get ();
-}
-template <typename T, typename U>
-ValueTraceSource<T> &operator += (ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x+=");
-  T tmp = lhs.Get ();
-  tmp += rhs;
-  lhs.Set (tmp);
-  return lhs;
-}
-template <typename T, typename U>
-ValueTraceSource<T> &operator -= (ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x-=");
-  T tmp = lhs.Get ();
-  tmp -= rhs;
-  lhs.Set (tmp);
-  return lhs;
-}
-template <typename T, typename U>
-ValueTraceSource<T> &operator *= (ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x*=");
-  T tmp = lhs.Get ();
-  tmp *= rhs;
-  lhs.Set (tmp);
-  return lhs;
-}
-template <typename T, typename U>
-ValueTraceSource<T> &operator /= (ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x/=");
-  T tmp = lhs.Get ();
-  tmp /= rhs;
-  lhs.Set (tmp);
-  return lhs;
-}
-template <typename T, typename U>
-ValueTraceSource<T> &operator %= (ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x%=");
-  T tmp = lhs.Get ();
-  tmp %= rhs;
-  lhs.Set (tmp);
-  return lhs;
-}
-template <typename T, typename U>
-ValueTraceSource<T> &operator <<= (ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x<<=");
-  T tmp = lhs.Get ();
-  tmp <<= rhs;
-  lhs.Set (tmp);
-  return lhs;
-}
-template <typename T, typename U>
-ValueTraceSource<T> &operator >>= (ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x>>=");
-  T tmp = lhs.Get ();
-  tmp >>= rhs;
-  lhs.Set (tmp);
-  return lhs;
-}
-template <typename T, typename U>
-ValueTraceSource<T> &operator &= (ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x&=");
-  T tmp = lhs.Get ();
-  tmp &= rhs;
-  lhs.Set (tmp);
-  return lhs;
-}
-template <typename T, typename U>
-ValueTraceSource<T> &operator |= (ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x|=");
-  T tmp = lhs.Get ();
-  tmp |= rhs;
-  lhs.Set (tmp);
-  return lhs;
-}
-template <typename T, typename U>
-ValueTraceSource<T> &operator ^= (ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x^=");
-  T tmp = lhs.Get ();
-  tmp ^= rhs;
-  lhs.Set (tmp);
-  return lhs;
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator + (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs) {
-  TRACE ("x+x");
-  return ValueTraceSource<T> (lhs.Get () + rhs.Get ());
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator + (const ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x+");
-  return ValueTraceSource<T> (lhs.Get () + rhs);
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator + (const U &lhs, const ValueTraceSource<T> &rhs) {
-  TRACE ("+x");
-  return ValueTraceSource<T> (lhs + rhs.Get ());
-}
-
-template <typename T, typename U>
-ValueTraceSource<T> operator - (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs) {
-  TRACE ("x-x");
-  return ValueTraceSource<T> (lhs.Get () - rhs.Get ());
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator - (const ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x-");
-  return ValueTraceSource<T> (lhs.Get () - rhs);
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator - (const U &lhs, const ValueTraceSource<T> &rhs) {
-  TRACE ("-x");
-  return ValueTraceSource<T> (lhs - rhs.Get ());
-}
-
-template <typename T, typename U>
-ValueTraceSource<T> operator * (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs) {
-  TRACE ("x*x");
-  return ValueTraceSource<T> (lhs.Get () * rhs.Get ());
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator * (const ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x*");
-  return ValueTraceSource<T> (lhs.Get () * rhs);
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator * (const U &lhs, const ValueTraceSource<T> &rhs) {
-  TRACE ("*x");
-  return ValueTraceSource<T> (lhs - rhs.Get ());
-}
-
-template <typename T, typename U>
-ValueTraceSource<T> operator / (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs) {
-  TRACE ("x/x");
-  return ValueTraceSource<T> (lhs.Get () / rhs.Get ());
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator / (const ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x/");
-  return ValueTraceSource<T> (lhs.Get () / rhs);
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator / (const U &lhs, const ValueTraceSource<T> &rhs) {
-  TRACE ("/x");
-  return ValueTraceSource<T> (lhs / rhs.Get ());
-}
-
-template <typename T, typename U>
-ValueTraceSource<T> operator % (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs) {
-  TRACE ("x%x");
-  return ValueTraceSource<T> (lhs.Get () % rhs.Get ());
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator % (const ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x%");
-  return ValueTraceSource<T> (lhs.Get () % rhs);
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator % (const U &lhs, const ValueTraceSource<T> &rhs) {
-  TRACE ("%x");
-  return ValueTraceSource<T> (lhs % rhs.Get ());
-}
-
-template <typename T, typename U>
-ValueTraceSource<T> operator ^ (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs) {
-  TRACE ("x^x");
-  return ValueTraceSource<T> (lhs.Get () ^ rhs.Get ());
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator ^ (const ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x^");
-  return ValueTraceSource<T> (lhs.Get () ^ rhs);
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator ^ (const U &lhs, const ValueTraceSource<T> &rhs) {
-  TRACE ("^x");
-  return ValueTraceSource<T> (lhs ^ rhs.Get ());
-}
-
-template <typename T, typename U>
-ValueTraceSource<T> operator | (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs) {
-  TRACE ("x|x");
-  return ValueTraceSource<T> (lhs.Get () | rhs.Get ());
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator | (const ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x|");
-  return ValueTraceSource<T> (lhs.Get () | rhs);
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator | (const U &lhs, const ValueTraceSource<T> &rhs) {
-  TRACE ("|x");
-  return ValueTraceSource<T> (lhs | rhs.Get ());
-}
-
-template <typename T, typename U>
-ValueTraceSource<T> operator & (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs) {
-  TRACE ("x&x");
-  return ValueTraceSource<T> (lhs.Get () & rhs.Get ());
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator & (const ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x&");
-  return ValueTraceSource<T> (lhs.Get () & rhs);
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator & (const U &lhs, const ValueTraceSource<T> &rhs) {
-  TRACE ("&x");
-  return ValueTraceSource<T> (lhs & rhs.Get ());
-}
-
-template <typename T, typename U>
-ValueTraceSource<T> operator << (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs) {
-  TRACE ("x<<x");
-  return ValueTraceSource<T> (lhs.Get () << rhs.Get ());
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator << (const ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x<<");
-  return ValueTraceSource<T> (lhs.Get () << rhs);
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator << (const U &lhs, const ValueTraceSource<T> &rhs) {
-  TRACE ("<<x");
-  return ValueTraceSource<T> (lhs << rhs.Get ());
-}
-
-template <typename T, typename U>
-ValueTraceSource<T> operator >> (const ValueTraceSource<T> &lhs, const ValueTraceSource<U> &rhs) {
-  TRACE ("x>>x");
-  return ValueTraceSource<T> (lhs.Get () >> rhs.Get ());
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator >> (const ValueTraceSource<T> &lhs, const U &rhs) {
-  TRACE ("x>>");
-  return ValueTraceSource<T> (lhs.Get () >> rhs);
-}
-template <typename T, typename U>
-ValueTraceSource<T> operator >> (const U &lhs, const ValueTraceSource<T> &rhs) {
-  TRACE (">>x");
-  return ValueTraceSource<T> (lhs >> rhs.Get ());
-}
-
-
-template <typename T>
-ValueTraceSource<T> operator + (const ValueTraceSource<T> &lhs) {
-  TRACE ("(+x)");
-  return ValueTraceSource<T> (+lhs.Get ());
-}
-template <typename T>
-ValueTraceSource<T> operator - (const ValueTraceSource<T> &lhs) {
-  TRACE ("(-x)");
-  return ValueTraceSource<T> (-lhs.Get ());
-}
-template <typename T>
-ValueTraceSource<T> operator ~ (const ValueTraceSource<T> &lhs) {
-  TRACE ("(~x)");
-  return ValueTraceSource<T> (~lhs.Get ());
-}
-template <typename T>
-ValueTraceSource<T> operator ! (const ValueTraceSource<T> &lhs) {
-  TRACE ("(!x)");
-  return ValueTraceSource<T> (!lhs.Get ());
-}
-
-
-} // namespace ns3
-
-#endif /* VALUE_TRACE_SOURCE_H */

src/core/wscript

@@ -63,7 +63,7 @@ def build(bld):
         'object-factory.cc',
         'object-vector.cc',
         'global-value.cc',
-        'event-trace-source.cc',
+        'traced-callback.cc',
         'trace-source-accessor.cc',
         'config.cc',
         ]
@@ -120,8 +120,8 @@ def build(bld):
         'object-factory.h',
         'attribute-helper.h',
         'global-value.h',
-        'event-trace-source.h',
-        'value-trace-source.h',
+        'traced-callback.h',
+        'traced-value.h',
         'trace-source-accessor.h',
         'config.h',
         'object-vector.h',