use the Object::GetTraceResolver tracing support rather than the old adhoc tracing code

src/node/net-device.cc

@@ -184,12 +184,6 @@ NetDevice::Send(Packet& p, const Address& dest, uint16_t protocolNumber)
     }
 }
 
-Ptr<TraceResolver>
-NetDevice::CreateTraceResolver (void)
-{
-  return DoCreateTraceResolver ();
-}
-
 Ptr<Channel>
 NetDevice::GetChannel (void) const
 {

src/node/net-device.h

@@ -62,14 +62,6 @@ public:
   static const InterfaceId iid;
   virtual ~NetDevice();
 
-  /**
-   * \param context the trace context to use to construct the
-   *        TraceResolver to return
-   * \returns a TraceResolver which can resolve all traces
-   *          performed in this object. The caller must
-   *          delete the returned object.
-   */
-  Ptr<TraceResolver> CreateTraceResolver (void);
 
   /**
    * \return the channel this NetDevice is connected to. The value
@@ -282,15 +274,6 @@ public:
    * Subclasses must implement this method.
    */
   virtual bool DoNeedsArp (void) const = 0;
-  /**
-   * \param context the trace context to associated to the
-   *        trace resolver.
-   * \returns a trace resolver associated to the input context.
-   *          the caller takes ownership of the pointer returned.
-   *
-   * Subclasses must implement this method.
-   */
-  virtual Ptr<TraceResolver> DoCreateTraceResolver (void) = 0;
   /**
    * \returns the channel associated to this NetDevice.
    *

src/node/node-list.cc

@@ -33,7 +33,7 @@ static class Initialization
 public:
   Initialization ()
   {
-    ns3::TraceRoot::Register ("nodes", ns3::MakeCallback (&ns3::NodeList::CreateTraceResolver));
+    ns3::TraceRoot::Register ("nodes", ns3::MakeCallback (&ns3::NodeList::GetTraceResolver));
   }
 } g_initialization;
 }
@@ -76,7 +76,7 @@ public:
   uint32_t Add (Ptr<Node> node);
   NodeList::Iterator Begin (void);
   NodeList::Iterator End (void);
-  Ptr<TraceResolver> CreateTraceResolver (void);
+  Ptr<TraceResolver> GetTraceResolver (void);
   Ptr<Node> GetNode (uint32_t n);
   uint32_t GetNNodes (void);
 
@@ -131,12 +131,11 @@ NodeListPriv::GetNode (uint32_t n)
 
 
 Ptr<TraceResolver>
-NodeListPriv::CreateTraceResolver (void)
+NodeListPriv::GetTraceResolver (void)
 {
-  Ptr<ArrayTraceResolver<Ptr<Node>, NodeListIndex> >resolver =
-    Create<ArrayTraceResolver<Ptr<Node>, NodeListIndex> >
-    (MakeCallback (&NodeListPriv::GetNNodes, this),
-     MakeCallback (&NodeListPriv::GetNode, this));
+  Ptr<ArrayTraceResolver<NodeListIndex> >resolver =
+    Create<ArrayTraceResolver<NodeListIndex> > ();
+  resolver->SetIterators (Begin (), End ());
   return resolver;
 }
 
@@ -165,9 +164,9 @@ NodeList::End (void)
   return SimulationSingleton<NodeListPriv>::Get ()->End ();
 }
 Ptr<TraceResolver>
-NodeList::CreateTraceResolver (void)
+NodeList::GetTraceResolver (void)
 {
-  return SimulationSingleton<NodeListPriv>::Get ()->CreateTraceResolver ();
+  return SimulationSingleton<NodeListPriv>::Get ()->GetTraceResolver ();
 }
 Ptr<Node>
 NodeList::GetNode (uint32_t n)

src/node/node-list.h

@@ -79,7 +79,7 @@ public:
    * \returns the requested trace resolver. The caller
    *          takes ownership of the returned pointer.
    */
-  static Ptr<TraceResolver> CreateTraceResolver (void);
+  static Ptr<TraceResolver> GetTraceResolver (void);
 
   /**
    * \param n index of requested node.

src/node/node.cc

@@ -25,7 +25,6 @@
 #include "packet-socket-factory.h"
 #include "ns3/simulator.h"
 #include "ns3/composite-trace-resolver.h"
-#include "ns3/array-trace-resolver.h"
 
 namespace ns3{
 
@@ -83,10 +82,11 @@ Node::~Node ()
 {}
 
 Ptr<TraceResolver>
-Node::CreateTraceResolver (void)
+Node::GetTraceResolver (void)
 {
   Ptr<CompositeTraceResolver> resolver = Create<CompositeTraceResolver> ();
-  DoFillTraceResolver (*PeekPointer (resolver));
+  resolver->AddArray ("devices", m_devices.begin (), m_devices.end (), NodeNetDeviceIndex ());
+  resolver->SetParent (Object::GetTraceResolver ());
   return resolver;
 }
 
@@ -141,24 +141,6 @@ Node::GetNApplications (void) const
   return m_applications.size ();
 }
 
-Ptr<TraceResolver>
-Node::CreateDevicesTraceResolver (void)
-{
-  Ptr<ArrayTraceResolver<Ptr<NetDevice>,NodeNetDeviceIndex> >resolver = 
-    Create<ArrayTraceResolver<Ptr<NetDevice>,NodeNetDeviceIndex> >
-    (MakeCallback (&Node::GetNDevices, this), 
-     MakeCallback (&Node::GetDevice, this));
-  
-  return resolver;
-}
-
-void
-Node::DoFillTraceResolver (CompositeTraceResolver &resolver)
-{
-  resolver.Add ("devices", 
-                MakeCallback (&Node::CreateDevicesTraceResolver, this));
-}
-
 void 
 Node::DoDispose()
 {

src/node/node.h

@@ -84,16 +84,6 @@ public:
 
   virtual ~Node();
 
-  /**
-   * \returns a newly-created TraceResolver. The caller takes
-   *          ownership of the returned pointer.
-   *
-   * Request the Node to create a trace resolver. This method
-   * could be used directly by a user who needs access to very low-level
-   * trace configuration.
-   */
-  Ptr<TraceResolver> CreateTraceResolver (void);
-
   /**
    * \returns the unique id of this node.
    * 
@@ -182,23 +172,15 @@ public:
   void UnregisterProtocolHandler (ProtocolHandler handler);
 
 protected:
+  virtual Ptr<TraceResolver> GetTraceResolver (void);
   /**
    * The dispose method. Subclasses must override this method
    * and must chain up to it by calling Node::DoDispose at the
    * end of their own DoDispose method.
    */
   virtual void DoDispose (void);
-  /**
-   * \param resolver the resolver to store trace sources in.
-   *
-   * If a subclass wants to add new traces to a Node, it needs
-   * to override this method and record the new trace sources
-   * in the input resolver. Subclasses also _must_ chain up to
-   * their parent's DoFillTraceResolver method prior
-   * to recording they own trace sources.
-   */
-  virtual void DoFillTraceResolver (CompositeTraceResolver &resolver);
 private:
+
   /**
    * \param device the device added to this Node.
    *
@@ -212,7 +194,6 @@ private:
   bool ReceiveFromDevice (Ptr<NetDevice> device, const Packet &packet, 
                           uint16_t protocol, const Address &from);
   void Construct (void);
-  Ptr<TraceResolver> CreateDevicesTraceResolver (void);
 
   struct ProtocolHandlerEntry {
     ProtocolHandler handler;

src/node/queue.cc

@@ -95,12 +95,13 @@ Queue::~Queue()
 }
 
 Ptr<TraceResolver>
-Queue::CreateTraceResolver (void)
+Queue::GetTraceResolver (void)
 {
   Ptr<CompositeTraceResolver> resolver = Create<CompositeTraceResolver> ();
   resolver->Add ("enqueue", m_traceEnqueue, QueueTraceType (QueueTraceType::ENQUEUE));
   resolver->Add ("dequeue", m_traceDequeue, QueueTraceType (QueueTraceType::DEQUEUE));
   resolver->Add ("drop", m_traceDrop, QueueTraceType (QueueTraceType::DROP));
+  resolver->SetParent (Object::GetTraceResolver ());
   return resolver;
 }
 

src/node/queue.h

@@ -69,8 +69,6 @@ public:
 
   Queue ();
   virtual ~Queue ();
-
-  Ptr<TraceResolver> CreateTraceResolver (void);
   
   /**
    * \return true if the queue is empty; false otherwise
@@ -167,6 +165,7 @@ private:
   virtual bool DoPeek (Packet &p) = 0;
 
 protected:
+  Ptr<TraceResolver> GetTraceResolver (void);
   // called by subclasses to notify parent of packet drops.
   void Drop (const Packet& p);