--- a/samples/main-serial-net-device-if.cc	Wed Feb 21 16:30:08 2007 +0100
+++ b/samples/main-serial-net-device-if.cc	Wed Feb 21 17:06:19 2007 +0100
@@ -44,27 +44,27 @@
 public:
   Logger ()
   {
-    NS_DEBUG_UNCOND("**** Logger()")
-  };
+    NS_DEBUG_UNCOND("**** Logger()");
+  }
 
   Logger (std::string const &filename) 
   {
-    NS_DEBUG_UNCOND("**** Logger(string const &)")
+    NS_DEBUG_UNCOND("**** Logger(string const &)");
     Open(filename);
-  };
+  }
 
   Logger (char const *filename) : m_tracer(filename)
   {
-    NS_DEBUG_UNCOND("**** Logger(char const *)")
+    NS_DEBUG_UNCOND("**** Logger(char const *)");
     Open(filename);
-  };
+  }
 
-  ~Logger () {};
+  ~Logger () {}
 
-  void Log (const char *s, const Packet &p)
+  void Log (std::string const &name, const Packet &p)
   {
-    NS_DEBUG_UNCOND("**** LogEnque ("<< s << &p << ")")
-    m_filestr << s << &p << std::endl;
+    NS_DEBUG_UNCOND("**** LogEnque ("<< name << " " << &p << ")");
+    m_filestr << name << " " << &p << std::endl;
   }
 
 protected:
@@ -73,7 +73,7 @@
 
 int main (int argc, char *argv[])
 {
-  NS_DEBUG_UNCOND("Serial Net Device Test")
+  NS_DEBUG_UNCOND("Serial Net Device Test");
 
   TraceContainer traceContainerA;
   TraceContainer traceContainerB;
@@ -94,7 +94,8 @@
   MacAddress addra("00:00:00:00:00:01");
   SerialNetDevice neta(&a, addra);
 
-  DropTailQueue dtqa (traceContainerA);
+  DropTailQueue dtqa ("a");
+  dtqa.RegisterTraces (traceContainerA);
 
   neta.AddQueue(&dtqa);
   neta.SetName("a.eth0"); 
@@ -102,7 +103,8 @@
   MacAddress addrb("00:00:00:00:00:02");
   SerialNetDevice netb(&b, addrb);
 
-  DropTailQueue dtqb (traceContainerB);
+  DropTailQueue dtqb ("b");
+  dtqb.RegisterTraces (traceContainerB);
 
   netb.AddQueue(&dtqb);
   netb.SetName("b.eth0"); 
@@ -113,10 +115,10 @@
   ch.Attach(&netb);
 
   // Some simple prints to see whether it is working
-  NS_DEBUG_UNCOND("neta.GetMtu() <= " << neta.GetMtu())
-  NS_DEBUG_UNCOND("netb.GetMtu() <= " << netb.GetMtu())
-  NS_DEBUG_UNCOND("neta.GetAddress() <= " << neta.GetAddress())
-  NS_DEBUG_UNCOND("netb.GetAddress() <= " << netb.GetAddress())
+  NS_DEBUG_UNCOND("neta.GetMtu() <= " << neta.GetMtu());
+  NS_DEBUG_UNCOND("netb.GetMtu() <= " << netb.GetMtu());
+  NS_DEBUG_UNCOND("neta.GetAddress() <= " << neta.GetAddress());
+  NS_DEBUG_UNCOND("netb.GetAddress() <= " << netb.GetAddress());
 
   // Note:  InternetNode constructor instantiates multiple Layer-3
   // protocols and registers them with the L3Demux object.
@@ -134,7 +136,7 @@
   // ii) add the Ipv4ArpInterface object to the InternetNode's internal
   //     vector of Ipv4Interfaces (keyed off of ifIndex)
 
-  NS_DEBUG_UNCOND("Adding ARP Interface to InternetNode a")
+  NS_DEBUG_UNCOND("Adding ARP Interface to InternetNode a");
   ArpIpv4Interface* arpipv4interfacep = new ArpIpv4Interface(&a, &neta);
   uint32_t indexA = (&a)->GetIpv4 ()->AddInterface (arpipv4interfacep);
   NS_DEBUG_UNCOND("Adding Interface " << indexA);
@@ -142,16 +144,16 @@
 
   // iii) give the interface an IP address
 
-  NS_DEBUG_UNCOND("Giving IP address to ARP Interface")
+  NS_DEBUG_UNCOND("Giving IP address to ARP Interface");
   arpipv4interfacep->SetAddress(Ipv4Address("10.1.1.1"));
   arpipv4interfacep->SetNetworkMask(Ipv4Mask("255.255.255.0"));
 
   // iv) set the interface's state to "UP"
 
-  NS_DEBUG_UNCOND("Setting ARP interface to UP")
+  NS_DEBUG_UNCOND("Setting ARP interface to UP");
   arpipv4interfacep->SetUp();
 
-  NS_DEBUG_UNCOND("Adding ARP Interface to InternetNode b")
+  NS_DEBUG_UNCOND("Adding ARP Interface to InternetNode b");
   ArpIpv4Interface* arpipv4interfacepb = new ArpIpv4Interface(&b, &netb);
   uint32_t indexB = (&b)->GetIpv4 ()->AddInterface (arpipv4interfacepb);
   NS_DEBUG_UNCOND("Adding Interface " << indexB);
@@ -159,25 +161,25 @@
 
   // iii) give the interface an IP address
 
-  NS_DEBUG_UNCOND("Giving IP address to ARP Interface")
+  NS_DEBUG_UNCOND("Giving IP address to ARP Interface");
   arpipv4interfacepb->SetAddress(Ipv4Address("10.1.1.2"));
   arpipv4interfacepb->SetNetworkMask(Ipv4Mask("255.255.255.0"));
 
   // iv) set the interface's state to "UP"
 
-  NS_DEBUG_UNCOND("Setting ARP interface to UP")
+  NS_DEBUG_UNCOND("Setting ARP interface to UP");
   arpipv4interfacepb->SetUp();
 
   Logger logger("serial-net-test.log");
 
   traceContainerA.SetCallback ("Queue::Enque", 
-    MakeCallback (&Logger::Log, &logger));
+                               MakeCallback (&Logger::Log, &logger));
 
   // create a packet on one node and send it through, reading it
   // on the other node
   Packet p;
 
-  NS_DEBUG_UNCOND("Sending Packet " << &p)
+  NS_DEBUG_UNCOND("Sending Packet " << &p);
   arpipv4interfacep->Send(p, Ipv4Address("10.1.1.2"));
 
   //neta.Send(p, MacAddress());  // Test that all-zero's MacAddress used

--- a/samples/ns-2/simple.tcl.cc	Wed Feb 21 16:30:08 2007 +0100
+++ b/samples/ns-2/simple.tcl.cc	Wed Feb 21 17:06:19 2007 +0100
@@ -133,7 +133,8 @@
     SerialChannel* channel = new SerialChannel();
 
     qName = name + "::Queue A";
-    DropTailQueue* dtqa = new DropTailQueue(qName, traceContainer);
+    DropTailQueue* dtqa = new DropTailQueue(qName);
+    dtqa->RegisterTraces (traceContainer);
 
     SerialNetDevice* neta = new SerialNetDevice(a, macaddra);
     neta->AddQueue(dtqa);
@@ -147,7 +148,8 @@
     interfA->SetUp ();
 
     qName = name + "::Queue B";
-    DropTailQueue* dtqb = new DropTailQueue(qName, traceContainer);
+    DropTailQueue* dtqb = new DropTailQueue(qName);
+    dtqb->RegisterTraces (traceContainer);
 
     SerialNetDevice* netb = new SerialNetDevice(b, macaddrb);
     netb->AddQueue(dtqb);

--- a/src/node/drop-tail.cc	Wed Feb 21 16:30:08 2007 +0100
+++ b/src/node/drop-tail.cc	Wed Feb 21 17:06:19 2007 +0100
@@ -25,48 +25,37 @@
 namespace ns3 {
 
 DropTailQueue::DropTailQueue () :
-    m_packets (),
-    m_maxPackets(DTQ_NPACKETS_MAX_DEFAULT)
+  Queue (""),
+  m_packets (),
+  m_maxPackets(DTQ_NPACKETS_MAX_DEFAULT)
 {
-  NS_DEBUG(
-    "DropTailQueue::DropTailQueue ()")
+  NS_DEBUG("DropTailQueue::DropTailQueue ()");
 }
 
-DropTailQueue::DropTailQueue (TraceContainer &traceContainer) :
+
+DropTailQueue::DropTailQueue (std::string const&name)
+  : Queue (name),
     m_packets(),
     m_maxPackets(DTQ_NPACKETS_MAX_DEFAULT)
 {
-  NS_DEBUG(
-    "DropTailQueue::DropTailQueue (" << &traceContainer << ")")
-
-  RegisterTraces(traceContainer);
-}
-
-DropTailQueue::DropTailQueue (
-    std::string &name, 
-    TraceContainer &traceContainer)
-  :
-    m_packets(),
-    m_maxPackets(DTQ_NPACKETS_MAX_DEFAULT)
-{
-  NS_DEBUG(
-    "DropTailQueue::DropTailQueue (" << &traceContainer << ")")
-
-  m_name = name;
-  RegisterTraces(traceContainer);
+  NS_DEBUG("DropTailQueue::DropTailQueue");
 }
 
 DropTailQueue::~DropTailQueue ()
 {
-  NS_DEBUG(
-    "DropTailQueue::~DropTailQueue ()")
+  NS_DEBUG("DropTailQueue::~DropTailQueue ()");
+}
+
+void 
+DropTailQueue::RegisterTraces (TraceContainer &traceContainer)
+{
+  Queue::QueueRegisterTraces (traceContainer);
 }
 
   void 
 DropTailQueue::SetMaxPackets (uint32_t npackets)
 {
-  NS_DEBUG(
-    "DropTailQueue::SetMaxPackets (" << npackets << ")")
+  NS_DEBUG("DropTailQueue::SetMaxPackets (" << npackets << ")");
 
   m_maxPackets = npackets;
 }
@@ -74,8 +63,7 @@
   uint32_t 
 DropTailQueue::GetMaxPackets (void)
 {
-  NS_DEBUG(
-    "DropTailQueue::GetMaxPackets () <= " << m_maxPackets)
+  NS_DEBUG("DropTailQueue::GetMaxPackets () <= " << m_maxPackets);
 
   return m_maxPackets;
 }
@@ -83,13 +71,11 @@
   bool 
 DropTailQueue::DoEnque (const Packet& p)
 {
-  NS_DEBUG(
-    "DropTailQueue::DoEnque (" << &p << ")")
+  NS_DEBUG("DropTailQueue::DoEnque (" << &p << ")");
 
-  if (m_nPackets >= m_maxPackets)
+  if (GetNPackets () >= m_maxPackets)
     {
-      NS_DEBUG(
-        "DropTailQueue::DoEnque (): Queue full -- droppping pkt")
+      NS_DEBUG("DropTailQueue::DoEnque (): Queue full -- droppping pkt");
       Drop (p);
       return false;
     }
@@ -101,21 +87,18 @@
   bool
 DropTailQueue::DoDeque (Packet& p)
 {
-  NS_DEBUG(
-    "DropTailQueue::DoDeque (" << &p << ")")
+  NS_DEBUG("DropTailQueue::DoDeque (" << &p << ")");
 
   if (m_packets.empty()) 
     {
-      NS_DEBUG(
-        "DropTailQueue::DoDeque (): Queue empty")
+      NS_DEBUG("DropTailQueue::DoDeque (): Queue empty")
       return false;
     }
 
   p = m_packets.front ();
   m_packets.pop ();
 
-  NS_DEBUG(
-    "DropTailQueue::DoDeque (): Popped " << &p << " <= true")
+  NS_DEBUG("DropTailQueue::DoDeque (): Popped " << &p << " <= true")
 
   return true;
 }

--- a/src/node/drop-tail.h	Wed Feb 21 16:30:08 2007 +0100
+++ b/src/node/drop-tail.h	Wed Feb 21 17:06:19 2007 +0100
@@ -26,23 +26,25 @@
 
 namespace ns3 {
 
+class TraceContainer;
+
 const int DTQ_NPACKETS_MAX_DEFAULT = 100;
 
 class DropTailQueue : public Queue {
 public:
   DropTailQueue ();
+  DropTailQueue (std::string const &name);
 
-  DropTailQueue (TraceContainer &traceContainer);
-  DropTailQueue (std::string &name, TraceContainer &traceContainer);
+  void RegisterTraces (TraceContainer &traceContainer);
 
   virtual ~DropTailQueue();
 
   void SetMaxPackets (uint32_t npackets);
   uint32_t GetMaxPackets (void);
 
-protected:
-  bool DoEnque (const Packet& p);
-  bool DoDeque (Packet &p);
+private:
+  virtual bool DoEnque (const Packet& p);
+  virtual bool DoDeque (Packet &p);
 
 private:
   std::queue<Packet> m_packets;

--- a/src/node/queue.cc	Wed Feb 21 16:30:08 2007 +0100
+++ b/src/node/queue.cc	Wed Feb 21 17:06:19 2007 +0100
@@ -24,31 +24,31 @@
 
 namespace ns3 {
 
-Queue::Queue() : 
+  Queue::Queue(std::string const &name) : 
   m_nBytes(0), 
   m_nTotalReceivedBytes(0),
   m_nPackets(0), 
   m_nTotalReceivedPackets(0),
   m_nTotalDroppedBytes(0),
-  m_nTotalDroppedPackets(0)
+  m_nTotalDroppedPackets(0),
+  m_name (name)
 {
-  NS_DEBUG("Queue::Queue ()")
+  NS_DEBUG("Queue::Queue ()");
 }
 
 Queue::~Queue()
 {
-  NS_DEBUG("Queue::~Queue ()")
+  NS_DEBUG("Queue::~Queue ()");
 }
 
-  bool 
+bool 
 Queue::Enque (const Packet& p)
 {
-  NS_DEBUG("Queue::Enque (" << &p << ")")
+  NS_DEBUG("Queue::Enque (" << &p << ")");
 
-  NS_DEBUG("Queue::Enque (): m_traceEnque (p)")
+  NS_DEBUG("Queue::Enque (): m_traceEnque (p)");
 
-  std::string buffer = m_name + " + <timestamp> ";
-  m_traceEnque (buffer.c_str(), p);
+  m_traceEnque (m_name, p);
 
   bool retval = DoEnque (p);
   if (retval)
@@ -59,10 +59,10 @@
   return retval;
 }
 
-  bool
+bool
 Queue::Deque (Packet &p)
 {
-  NS_DEBUG("Queue::Deque (" << &p << ")")
+  NS_DEBUG("Queue::Deque (" << &p << ")");
 
   bool retval = DoDeque (p);
 
@@ -74,100 +74,95 @@
       NS_ASSERT (m_nBytes >= 0);
       NS_ASSERT (m_nPackets >= 0);
 
-      NS_DEBUG("Queue::Deque (): m_traceDeque (p)")
+      NS_DEBUG("Queue::Deque (): m_traceDeque (p)");
 
-      std::string buffer = m_name + " - <timestamp> ";
-      m_traceDeque (buffer.c_str(), static_cast<const Packet &>(p));
+      const Packet packet = p;
+      m_traceDeque (m_name, packet);
     }
 
   return retval;
 }
 
-  void
+void
 Queue::DequeAll (void)
 {
-  NS_DEBUG("Queue::DequeAll ()")
+  NS_DEBUG("Queue::DequeAll ()");
 
   NS_ASSERT (!"Don't know what to do with dequeued packets!");
 }
 
-  uint32_t 
+uint32_t 
 Queue::GetNPackets (void)
 {
-  NS_DEBUG("Queue::GetNPackets () <= " << m_nPackets)
+  NS_DEBUG("Queue::GetNPackets () <= " << m_nPackets);
 
   return m_nPackets;
 }
 
-  uint32_t
+uint32_t
 Queue::GetNBytes (void)
 {
-  NS_DEBUG("Queue::GetNBytes () <= " << m_nBytes)
+  NS_DEBUG("Queue::GetNBytes () <= " << m_nBytes);
 
   return m_nBytes;
 }
 
 
-  bool
+bool
 Queue::IsEmpty (void)
 {
-  NS_DEBUG("Queue::IsEmpty () <= " << (m_nPackets == 0))
+  NS_DEBUG("Queue::IsEmpty () <= " << (m_nPackets == 0));
   return m_nPackets == 0;
 }
 
-  void
-Queue::RegisterTraces (TraceContainer &container)
+void
+Queue::QueueRegisterTraces (TraceContainer &container)
 {
-  NS_DEBUG("Queue::RegisterTraces (" << &container << ")")
+  NS_DEBUG("Queue::RegisterTraces (" << &container << ")");
 
-  container.RegisterCallback (
-    std::string(m_name + "::Queue::Enque"),
-    &m_traceEnque);
-  container.RegisterCallback (
-    std::string(m_name + "::Queue::Deque"),
-    &m_traceDeque);
-  container.RegisterCallback (
-    std::string(m_name + "::Queue::Drop"),
-    &m_traceDrop);
+  container.RegisterCallback ("Queue::Enque",
+                              &m_traceEnque);
+  container.RegisterCallback ("Queue::Deque",
+                              &m_traceDeque);
+  container.RegisterCallback ("Queue::Drop",
+                              &m_traceDrop);
 }
 
-  uint32_t
+uint32_t
 Queue::GetTotalReceivedBytes (void)
 {
-  NS_DEBUG(
-    "Queue::GetTotalReceivedBytes () <= " << m_nTotalReceivedBytes)
+  NS_DEBUG("Queue::GetTotalReceivedBytes () <= " << m_nTotalReceivedBytes);
 
   return m_nTotalReceivedBytes;
 }
 
-  uint32_t
+uint32_t
 Queue::GetTotalReceivedPackets (void)
 {
-  NS_DEBUG(
-    "Queue::GetTotalReceivedPackets () <= " << m_nTotalReceivedPackets)
+  NS_DEBUG("Queue::GetTotalReceivedPackets () <= " << m_nTotalReceivedPackets);
 
   return m_nTotalReceivedPackets;
 }
 
-  uint32_t
+uint32_t
 Queue:: GetTotalDroppedBytes (void)
 {
   NS_DEBUG(
     "Queue::GetTotalDroppedBytes () <= " << m_nTotalDroppedBytes
-)
+    );
   return m_nTotalDroppedBytes;
 }
 
-  uint32_t
+uint32_t
 Queue::GetTotalDroppedPackets (void)
 {
   NS_DEBUG(
-    "Queue::GetTotalDroppedPackets () <= " << m_nTotalDroppedPackets)
+           "Queue::GetTotalDroppedPackets () <= " << m_nTotalDroppedPackets);
 
   return m_nTotalDroppedPackets;
 }
 
-  void 
+void 
 Queue::ResetStatistics (void)
 {
   NS_DEBUG("Queue::ResetStatistics ()")
@@ -181,14 +176,13 @@
 void
 Queue::Drop (const Packet& p)
 {
-  NS_DEBUG("Queue::Drop (" << &p << ")")
+  NS_DEBUG("Queue::Drop (" << &p << ")");
 
   m_nTotalDroppedPackets++;
   m_nTotalDroppedBytes += p.GetSize ();
 
-  NS_DEBUG("Queue::Drop (): m_traceDrop (p)")
-  std::string buffer = m_name + " d <timestamp> ";
-  m_traceEnque (buffer.c_str(), p);
+  NS_DEBUG("Queue::Drop (): m_traceDrop (p)");
+  m_traceDrop (m_name, p);
 }
 
 }; // namespace ns3

--- a/src/node/queue.h	Wed Feb 21 16:30:08 2007 +0100
+++ b/src/node/queue.h	Wed Feb 21 17:06:19 2007 +0100
@@ -25,6 +25,7 @@
 #ifndef QUEUE_H
 #define QUEUE_H
 
+#include <string>
 #include "ns3/packet.h"
 #include "ns3/callback-tracer.h"
 #include "ns3/trace-container.h"
@@ -34,7 +35,7 @@
 class Queue
 {
 public:
-  Queue ();
+  Queue (std::string const &name);
   virtual ~Queue ();
 
   bool Enque (const Packet& p);
@@ -46,8 +47,6 @@
 
   bool IsEmpty (void);
 
-  void RegisterTraces (TraceContainer &container);
-
   uint32_t GetTotalReceivedBytes (void);
   uint32_t GetTotalReceivedPackets (void);
   uint32_t GetTotalDroppedBytes (void);
@@ -86,6 +85,12 @@
 protected:
   // called by subclasses to notify parent of packet drops.
   void Drop (const Packet& p);
+  void QueueRegisterTraces (TraceContainer &container);
+
+private:
+  CallbackTracer<std::string const &, const Packet &> m_traceEnque;
+  CallbackTracer<std::string const &, const Packet &> m_traceDeque;
+  CallbackTracer<std::string const &, const Packet &> m_traceDrop;
 
   uint32_t m_nBytes;
   uint32_t m_nTotalReceivedBytes;
@@ -93,12 +98,9 @@
   uint32_t m_nTotalReceivedPackets;
   uint32_t m_nTotalDroppedBytes;
   uint32_t m_nTotalDroppedPackets;
+
   std::string m_name;
 
-private:
-  CallbackTracer<const char *, const Packet &> m_traceEnque;
-  CallbackTracer<const char *, const Packet &> m_traceDeque;
-  CallbackTracer<const char *, const Packet &> m_traceDrop;
 
 #if 0
   // Static methods to manage queue default