replace Node::DoCreateTraceResolver with Node::DoFillTraceResolver

src/common/array-trace-resolver.h

@@ -81,11 +81,11 @@ public:
    */
   ArrayTraceResolver (TraceContext const &context,
                       Callback<uint32_t> getSize, 
-                      Callback<T *, uint32_t> get);
+                      Callback<T, uint32_t> get);
 private:
   virtual TraceResolverList DoLookup (std::string id) const;
   Callback<uint32_t> m_getSize;
-  Callback<T *, uint32_t> m_get;
+  Callback<T, uint32_t> m_get;
 };
 }//namespace ns3
 
@@ -108,7 +108,7 @@ ArrayTraceResolver<T>::Index::operator uint32_t ()
 template <typename T>
 ArrayTraceResolver<T>::ArrayTraceResolver (TraceContext const &context,
                                            Callback<uint32_t> getSize, 
-                                           Callback<T *, uint32_t> get)
+                                           Callback<T, uint32_t> get)
   : TraceResolver (context),
     m_getSize (getSize),
     m_get (get)
@@ -122,10 +122,10 @@ ArrayTraceResolver<T>::DoLookup (std::string id) const
   {
     for (uint32_t i = 0; i < m_getSize (); i++)
     {
-	  TraceContext context = GetContext ();
+      TraceContext context = GetContext ();
       typename ArrayTraceResolver<T>::Index index = typename ArrayTraceResolver<T>::Index (i);
-	  context.Add (index);
-	  list.push_back (m_get (i)->CreateTraceResolver (context));
+      context.Add (index);
+      list.push_back (m_get (i)->CreateTraceResolver (context));
     }
   }
   return list;

src/internet-node/ascii-trace.cc

@@ -47,14 +47,14 @@ void
 AsciiTrace::TraceAllQueues (void)
 {
   Packet::EnableMetadata ();
-  TraceRoot::Connect ("/nodes/*/ipv4/interfaces/*/netdevice/queue/*",
+  TraceRoot::Connect ("/nodes/*/devices/*/queue/*",
                       MakeCallback (&AsciiTrace::LogDevQueue, this));
 }
 void
 AsciiTrace::TraceAllNetDeviceRx (void)
 {
   Packet::EnableMetadata ();
-  TraceRoot::Connect ("/nodes/*/ipv4/interfaces/*/netdevice/rx",
+  TraceRoot::Connect ("/nodes/*/devices/*/rx",
                       MakeCallback (&AsciiTrace::LogDevRx, this));
 }
 

src/internet-node/internet-node.cc

@@ -76,16 +76,14 @@ InternetNode::Construct (void)
 }
 
 
-TraceResolver *
-InternetNode::DoCreateTraceResolver (TraceContext const &context)
+void
+InternetNode::DoFillTraceResolver (CompositeTraceResolver &resolver)
 {
-  CompositeTraceResolver *resolver = new CompositeTraceResolver (context);
+  Node::DoFillTraceResolver (resolver);
   Ptr<Ipv4L3Protocol> ipv4 = QueryInterface<Ipv4L3Protocol> (Ipv4L3Protocol::iid);
-  resolver->Add ("ipv4",
-                 MakeCallback (&Ipv4L3Protocol::CreateTraceResolver, PeekPointer (ipv4)),
-                 InternetNode::IPV4);
-
-  return resolver;
+  resolver.Add ("ipv4",
+                MakeCallback (&Ipv4L3Protocol::CreateTraceResolver, PeekPointer (ipv4)),
+                InternetNode::IPV4);
 }
 
 void 

src/internet-node/internet-node.h

@@ -46,7 +46,7 @@ public:
 protected:
   virtual void DoDispose(void);
 private:
-  virtual TraceResolver *DoCreateTraceResolver (TraceContext const &context);
+  virtual void DoFillTraceResolver (CompositeTraceResolver &resolver);
   bool ReceiveFromDevice (Ptr<NetDevice> device, const Packet &p, uint16_t protocolNumber) const;
   void Construct (void);
 };

src/internet-node/ipv4-l3-protocol.cc

@@ -99,8 +99,8 @@ Ipv4L3Protocol::CreateTraceResolver (TraceContext const &context)
 TraceResolver *
 Ipv4L3Protocol::InterfacesCreateTraceResolver (TraceContext const &context) const
 {
-  ArrayTraceResolver<Ipv4Interface> *resolver = 
-    new ArrayTraceResolver<Ipv4Interface> 
+  ArrayTraceResolver<Ipv4Interface *> *resolver = 
+    new ArrayTraceResolver<Ipv4Interface *> 
     (context,
      MakeCallback (&Ipv4L3Protocol::GetNInterfaces, this),
      MakeCallback (&Ipv4L3Protocol::GetInterface, this));

src/node/node-list.cc

@@ -53,7 +53,6 @@ public:
   NodeList::Iterator Begin (void);
   NodeList::Iterator End (void);
   TraceResolver *CreateTraceResolver (TraceContext const &context);
-  Node *PeekNode (uint32_t n);
   Ptr<Node> GetNode (uint32_t n);
   uint32_t GetNNodes (void);
 
@@ -99,11 +98,6 @@ NodeListPriv::GetNNodes (void)
 {
   return m_nodes.size ();
 }
-Node *
-NodeListPriv::PeekNode (uint32_t n)
-{
-  return PeekPointer (m_nodes[n]);
-}
 
 Ptr<Node>
 NodeListPriv::GetNode (uint32_t n)
@@ -115,11 +109,11 @@ NodeListPriv::GetNode (uint32_t n)
 TraceResolver *
 NodeListPriv::CreateTraceResolver (TraceContext const &context)
 {
-  ArrayTraceResolver<Node> *resolver =
-    new ArrayTraceResolver<Node>
+  ArrayTraceResolver<Ptr<Node> > *resolver =
+    new ArrayTraceResolver<Ptr<Node> >
     (context, 
      MakeCallback (&NodeListPriv::GetNNodes, this),
-     MakeCallback (&NodeListPriv::PeekNode, this));
+     MakeCallback (&NodeListPriv::GetNode, this));
   return resolver;
 }
 

src/node/node.cc

@@ -24,7 +24,7 @@
 #include "application.h"
 #include "packet-socket-factory.h"
 #include "ns3/simulator.h"
-#include "ns3/empty-trace-resolver.h"
+#include "ns3/composite-trace-resolver.h"
 
 namespace ns3{
 
@@ -59,7 +59,9 @@ Node::~Node ()
 TraceResolver *
 Node::CreateTraceResolver (TraceContext const &context)
 {
-  return DoCreateTraceResolver (context);
+  CompositeTraceResolver *resolver = new CompositeTraceResolver (context);
+  DoFillTraceResolver (*resolver);
+  return resolver;
 }
 
 uint32_t 
@@ -120,8 +122,27 @@ Node::GetNApplications (void) const
   return m_applications.size ();
 }
 
+TraceResolver *
+Node::CreateDevicesTraceResolver (const TraceContext &context)
+{
+  ArrayTraceResolver<Ptr<NetDevice> > *resolver = 
+    new ArrayTraceResolver<Ptr<NetDevice> > (context,
+                                             MakeCallback (&Node::GetNDevices, this), 
+                                             MakeCallback (&Node::GetDevice, this));
+  
+  return resolver;
+}
 
-void Node::DoDispose()
+void
+Node::DoFillTraceResolver (CompositeTraceResolver &resolver)
+{
+  resolver.Add ("devices", 
+                MakeCallback (&Node::CreateDevicesTraceResolver, this),
+                Node::DEVICES);
+}
+
+void 
+Node::DoDispose()
 {
   for (std::vector<Ptr<NetDevice> >::iterator i = m_devices.begin ();
        i != m_devices.end (); i++)
@@ -142,11 +163,6 @@ void Node::DoDispose()
   Object::DoDispose ();
 }
 
-TraceResolver *
-Node::DoCreateTraceResolver (TraceContext const &context)
-{
-  return new EmptyTraceResolver (context);
-}
 void 
 Node::NotifyDeviceAdded (Ptr<NetDevice> device)
 {}

src/node/node.h

@@ -34,6 +34,7 @@ class NetDevice;
 class Application;
 class Packet;
 class Address;
+class CompositeTraceResolver;
 
 /**
  * \brief A network Node.
@@ -175,14 +176,17 @@ protected:
    * end of their own DoDispose method.
    */
   virtual void DoDispose (void);
-private:
   /**
-   * \param context the trace context
-   * \returns a trace resolver to the user. The user must delete it.
+   * \param resolver the resolver to store trace sources in.
    *
-   * Subclasses must implement this method.
+   * 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 TraceResolver *DoCreateTraceResolver (TraceContext const &context);
+  virtual void DoFillTraceResolver (CompositeTraceResolver &resolver);
+private:
   /**
    * \param device the device added to this Node.
    *
@@ -196,7 +200,11 @@ private:
   bool ReceiveFromDevice (Ptr<NetDevice> device, const Packet &packet, 
                           uint16_t protocol, const Address &from);
   void Construct (void);
+  TraceResolver *CreateDevicesTraceResolver (const TraceContext &context);
 
+  enum TraceSource {
+    DEVICES
+  };
   struct ProtocolHandlerEntry {
     ProtocolHandler handler;
     uint16_t protocol;