diff --git a/apps/ndn-consumer.cpp b/apps/ndn-consumer.cpp
index e94f751..fabbe95 100644
--- a/apps/ndn-consumer.cpp
+++ b/apps/ndn-consumer.cpp
@@ -40,286 +40,276 @@
 
 #include "ns3/names.h"
 
-NS_LOG_COMPONENT_DEFINE ("ndn.Consumer");
+NS_LOG_COMPONENT_DEFINE("ndn.Consumer");
 
 namespace ns3 {
 namespace ndn {
 
-NS_OBJECT_ENSURE_REGISTERED (Consumer);
+NS_OBJECT_ENSURE_REGISTERED(Consumer);
 
 TypeId
-Consumer::GetTypeId (void)
+Consumer::GetTypeId(void)
 {
-  static TypeId tid = TypeId ("ns3::ndn::Consumer")
-    .SetGroupName ("Ndn")
-    .SetParent<App> ()
-    .AddAttribute ("StartSeq", "Initial sequence number",
-                   IntegerValue (0),
-                   MakeIntegerAccessor(&Consumer::m_seq),
-                   MakeIntegerChecker<int32_t>())
+  static TypeId tid =
+    TypeId("ns3::ndn::Consumer")
+      .SetGroupName("Ndn")
+      .SetParent<App>()
+      .AddAttribute("StartSeq", "Initial sequence number", IntegerValue(0),
+                    MakeIntegerAccessor(&Consumer::m_seq), MakeIntegerChecker<int32_t>())
 
-    .AddAttribute ("Prefix","Name of the Interest",
-                   StringValue ("/"),
-                   MakeNameAccessor (&Consumer::m_interestName),
-                   MakeNameChecker ())
-    .AddAttribute ("LifeTime", "LifeTime for interest packet",
-                   StringValue ("2s"),
-                   MakeTimeAccessor (&Consumer::m_interestLifeTime),
-                   MakeTimeChecker ())
+      .AddAttribute("Prefix", "Name of the Interest", StringValue("/"),
+                    MakeNameAccessor(&Consumer::m_interestName), MakeNameChecker())
+      .AddAttribute("LifeTime", "LifeTime for interest packet", StringValue("2s"),
+                    MakeTimeAccessor(&Consumer::m_interestLifeTime), MakeTimeChecker())
 
-    .AddAttribute ("RetxTimer",
-                   "Timeout defining how frequent retransmission timeouts should be checked",
-                   StringValue ("50ms"),
-                   MakeTimeAccessor (&Consumer::GetRetxTimer, &Consumer::SetRetxTimer),
-                   MakeTimeChecker ())
+      .AddAttribute("RetxTimer",
+                    "Timeout defining how frequent retransmission timeouts should be checked",
+                    StringValue("50ms"),
+                    MakeTimeAccessor(&Consumer::GetRetxTimer, &Consumer::SetRetxTimer),
+                    MakeTimeChecker())
 
-    .AddTraceSource ("LastRetransmittedInterestDataDelay", "Delay between last retransmitted Interest and received Data",
-                     MakeTraceSourceAccessor (&Consumer::m_lastRetransmittedInterestDataDelay))
+      .AddTraceSource("LastRetransmittedInterestDataDelay",
+                      "Delay between last retransmitted Interest and received Data",
+                      MakeTraceSourceAccessor(&Consumer::m_lastRetransmittedInterestDataDelay))
 
-    .AddTraceSource ("FirstInterestDataDelay", "Delay between first transmitted Interest and received Data",
-                     MakeTraceSourceAccessor (&Consumer::m_firstInterestDataDelay))
-    ;
+      .AddTraceSource("FirstInterestDataDelay",
+                      "Delay between first transmitted Interest and received Data",
+                      MakeTraceSourceAccessor(&Consumer::m_firstInterestDataDelay));
 
   return tid;
 }
 
-Consumer::Consumer ()
-  : m_rand (0, std::numeric_limits<uint32_t>::max ())
-  , m_seq (0)
-  , m_seqMax (0) // don't request anything
+Consumer::Consumer()
+  : m_rand(0, std::numeric_limits<uint32_t>::max())
+  , m_seq(0)
+  , m_seqMax(0) // don't request anything
 {
-  NS_LOG_FUNCTION_NOARGS ();
+  NS_LOG_FUNCTION_NOARGS();
 
-  m_rtt = CreateObject<RttMeanDeviation> ();
+  m_rtt = CreateObject<RttMeanDeviation>();
 }
 
 void
-Consumer::SetRetxTimer (Time retxTimer)
+Consumer::SetRetxTimer(Time retxTimer)
 {
   m_retxTimer = retxTimer;
-  if (m_retxEvent.IsRunning ())
-    {
-      // m_retxEvent.Cancel (); // cancel any scheduled cleanup events
-      Simulator::Remove (m_retxEvent); // slower, but better for memory
-    }
+  if (m_retxEvent.IsRunning()) {
+    // m_retxEvent.Cancel (); // cancel any scheduled cleanup events
+    Simulator::Remove(m_retxEvent); // slower, but better for memory
+  }
 
   // schedule even with new timeout
-  m_retxEvent = Simulator::Schedule (m_retxTimer,
-                                     &Consumer::CheckRetxTimeout, this);
+  m_retxEvent = Simulator::Schedule(m_retxTimer, &Consumer::CheckRetxTimeout, this);
 }
 
 Time
-Consumer::GetRetxTimer () const
+Consumer::GetRetxTimer() const
 {
   return m_retxTimer;
 }
 
 void
-Consumer::CheckRetxTimeout ()
+Consumer::CheckRetxTimeout()
 {
-  Time now = Simulator::Now ();
+  Time now = Simulator::Now();
 
-  Time rto = m_rtt->RetransmitTimeout ();
+  Time rto = m_rtt->RetransmitTimeout();
   // NS_LOG_DEBUG ("Current RTO: " << rto.ToDouble (Time::S) << "s");
 
-  while (!m_seqTimeouts.empty ())
+  while (!m_seqTimeouts.empty()) {
+    SeqTimeoutsContainer::index<i_timestamp>::type::iterator entry =
+      m_seqTimeouts.get<i_timestamp>().begin();
+    if (entry->time + rto <= now) // timeout expired?
     {
-      SeqTimeoutsContainer::index<i_timestamp>::type::iterator entry =
-        m_seqTimeouts.get<i_timestamp> ().begin ();
-      if (entry->time + rto <= now) // timeout expired?
-        {
-          uint32_t seqNo = entry->seq;
-          m_seqTimeouts.get<i_timestamp> ().erase (entry);
-          OnTimeout (seqNo);
-        }
-      else
-        break; // nothing else to do. All later packets need not be retransmitted
+      uint32_t seqNo = entry->seq;
+      m_seqTimeouts.get<i_timestamp>().erase(entry);
+      OnTimeout(seqNo);
     }
+    else
+      break; // nothing else to do. All later packets need not be retransmitted
+  }
 
-  m_retxEvent = Simulator::Schedule (m_retxTimer,
-                                     &Consumer::CheckRetxTimeout, this);
+  m_retxEvent = Simulator::Schedule(m_retxTimer, &Consumer::CheckRetxTimeout, this);
 }
 
 // Application Methods
 void
-Consumer::StartApplication () // Called at time specified by Start
+Consumer::StartApplication() // Called at time specified by Start
 {
-  NS_LOG_FUNCTION_NOARGS ();
+  NS_LOG_FUNCTION_NOARGS();
 
   // do base stuff
-  App::StartApplication ();
+  App::StartApplication();
 
-  ScheduleNextPacket ();
+  ScheduleNextPacket();
 }
 
 void
-Consumer::StopApplication () // Called at time specified by Stop
+Consumer::StopApplication() // Called at time specified by Stop
 {
-  NS_LOG_FUNCTION_NOARGS ();
+  NS_LOG_FUNCTION_NOARGS();
 
   // cancel periodic packet generation
-  Simulator::Cancel (m_sendEvent);
+  Simulator::Cancel(m_sendEvent);
 
   // cleanup base stuff
-  App::StopApplication ();
+  App::StopApplication();
 }
 
 void
-Consumer::SendPacket ()
+Consumer::SendPacket()
 {
-  if (!m_active) return;
+  if (!m_active)
+    return;
 
-  NS_LOG_FUNCTION_NOARGS ();
+  NS_LOG_FUNCTION_NOARGS();
 
-  uint32_t seq=std::numeric_limits<uint32_t>::max (); //invalid
+  uint32_t seq = std::numeric_limits<uint32_t>::max(); // invalid
 
-  while (m_retxSeqs.size ())
-    {
-      seq = *m_retxSeqs.begin ();
-      m_retxSeqs.erase (m_retxSeqs.begin ());
-      break;
+  while (m_retxSeqs.size()) {
+    seq = *m_retxSeqs.begin();
+    m_retxSeqs.erase(m_retxSeqs.begin());
+    break;
+  }
+
+  if (seq == std::numeric_limits<uint32_t>::max()) {
+    if (m_seqMax != std::numeric_limits<uint32_t>::max()) {
+      if (m_seq >= m_seqMax) {
+        return; // we are totally done
+      }
     }
 
-  if (seq == std::numeric_limits<uint32_t>::max ())
-    {
-      if (m_seqMax != std::numeric_limits<uint32_t>::max ())
-        {
-          if (m_seq >= m_seqMax)
-            {
-              return; // we are totally done
-            }
-        }
-
-      seq = m_seq++;
-    }
+    seq = m_seq++;
+  }
 
   //
-  Ptr<Name> nameWithSequence = Create<Name> (m_interestName);
-  nameWithSequence->appendSeqNum (seq);
+  Ptr<Name> nameWithSequence = Create<Name>(m_interestName);
+  nameWithSequence->appendSeqNum(seq);
   //
 
-  Ptr<Interest> interest = Create<Interest> ();
-  interest->SetNonce               (m_rand.GetValue ());
-  interest->SetName                (nameWithSequence);
-  interest->SetInterestLifetime    (m_interestLifeTime);
+  Ptr<Interest> interest = Create<Interest>();
+  interest->SetNonce(m_rand.GetValue());
+  interest->SetName(nameWithSequence);
+  interest->SetInterestLifetime(m_interestLifeTime);
 
   // NS_LOG_INFO ("Requesting Interest: \n" << *interest);
-  NS_LOG_INFO ("> Interest for " << seq);
+  NS_LOG_INFO("> Interest for " << seq);
 
-  WillSendOutInterest (seq);  
+  WillSendOutInterest(seq);
 
   FwHopCountTag hopCountTag;
-  interest->GetPayload ()->AddPacketTag (hopCountTag);
+  interest->GetPayload()->AddPacketTag(hopCountTag);
 
-  m_transmittedInterests (interest, this, m_face);
-  m_face->ReceiveInterest (interest);
+  m_transmittedInterests(interest, this, m_face);
+  m_face->ReceiveInterest(interest);
 
-  ScheduleNextPacket ();
+  ScheduleNextPacket();
 }
 
 ///////////////////////////////////////////////////
 //          Process incoming packets             //
 ///////////////////////////////////////////////////
 
-
 void
-Consumer::OnData (Ptr<const Data> data)
+Consumer::OnData(Ptr<const Data> data)
 {
-  if (!m_active) return;
+  if (!m_active)
+    return;
 
-  App::OnData (data); // tracing inside
+  App::OnData(data); // tracing inside
 
-  NS_LOG_FUNCTION (this << data);
+  NS_LOG_FUNCTION(this << data);
 
   // NS_LOG_INFO ("Received content object: " << boost::cref(*data));
 
-  uint32_t seq = data->GetName ().get (-1).toSeqNum ();
-  NS_LOG_INFO ("< DATA for " << seq);
+  uint32_t seq = data->GetName().get(-1).toSeqNum();
+  NS_LOG_INFO("< DATA for " << seq);
 
   int hopCount = -1;
   FwHopCountTag hopCountTag;
-  if (data->GetPayload ()->PeekPacketTag (hopCountTag))
-    {
-      hopCount = hopCountTag.Get ();
-    }
+  if (data->GetPayload()->PeekPacketTag(hopCountTag)) {
+    hopCount = hopCountTag.Get();
+  }
 
-  SeqTimeoutsContainer::iterator entry = m_seqLastDelay.find (seq);
-  if (entry != m_seqLastDelay.end ())
-    {
-      m_lastRetransmittedInterestDataDelay (this, seq, Simulator::Now () - entry->time, hopCount);
-    }
+  SeqTimeoutsContainer::iterator entry = m_seqLastDelay.find(seq);
+  if (entry != m_seqLastDelay.end()) {
+    m_lastRetransmittedInterestDataDelay(this, seq, Simulator::Now() - entry->time, hopCount);
+  }
 
-  entry = m_seqFullDelay.find (seq);
-  if (entry != m_seqFullDelay.end ())
-    {
-      m_firstInterestDataDelay (this, seq, Simulator::Now () - entry->time, m_seqRetxCounts[seq], hopCount);
-    }
+  entry = m_seqFullDelay.find(seq);
+  if (entry != m_seqFullDelay.end()) {
+    m_firstInterestDataDelay(this, seq, Simulator::Now() - entry->time, m_seqRetxCounts[seq],
+                             hopCount);
+  }
 
-  m_seqRetxCounts.erase (seq);
-  m_seqFullDelay.erase (seq);
-  m_seqLastDelay.erase (seq);
+  m_seqRetxCounts.erase(seq);
+  m_seqFullDelay.erase(seq);
+  m_seqLastDelay.erase(seq);
 
-  m_seqTimeouts.erase (seq);
-  m_retxSeqs.erase (seq);
+  m_seqTimeouts.erase(seq);
+  m_retxSeqs.erase(seq);
 
-  m_rtt->AckSeq (SequenceNumber32 (seq));
+  m_rtt->AckSeq(SequenceNumber32(seq));
 }
 
 void
-Consumer::OnNack (Ptr<const Interest> interest)
+Consumer::OnNack(Ptr<const Interest> interest)
 {
-  if (!m_active) return;
+  if (!m_active)
+    return;
 
-  App::OnNack (interest); // tracing inside
+  App::OnNack(interest); // tracing inside
 
   // NS_LOG_DEBUG ("Nack type: " << interest->GetNack ());
 
   // NS_LOG_FUNCTION (interest->GetName ());
 
   // NS_LOG_INFO ("Received NACK: " << boost::cref(*interest));
-  uint32_t seq = interest->GetName ().get (-1).toSeqNum ();
-  NS_LOG_INFO ("< NACK for " << seq);
+  uint32_t seq = interest->GetName().get(-1).toSeqNum();
+  NS_LOG_INFO("< NACK for " << seq);
   // std::cout << Simulator::Now ().ToDouble (Time::S) << "s -> " << "NACK for " << seq << "\n";
 
   // put in the queue of interests to be retransmitted
   // NS_LOG_INFO ("Before: " << m_retxSeqs.size ());
-  m_retxSeqs.insert (seq);
+  m_retxSeqs.insert(seq);
   // NS_LOG_INFO ("After: " << m_retxSeqs.size ());
 
-  m_seqTimeouts.erase (seq);
+  m_seqTimeouts.erase(seq);
 
-  m_rtt->IncreaseMultiplier ();             // Double the next RTO ??
-  ScheduleNextPacket ();
+  m_rtt->IncreaseMultiplier(); // Double the next RTO ??
+  ScheduleNextPacket();
 }
 
 void
-Consumer::OnTimeout (uint32_t sequenceNumber)
+Consumer::OnTimeout(uint32_t sequenceNumber)
 {
-  NS_LOG_FUNCTION (sequenceNumber);
-  // std::cout << Simulator::Now () << ", TO: " << sequenceNumber << ", current RTO: " << m_rtt->RetransmitTimeout ().ToDouble (Time::S) << "s\n";
+  NS_LOG_FUNCTION(sequenceNumber);
+  // std::cout << Simulator::Now () << ", TO: " << sequenceNumber << ", current RTO: " <<
+  // m_rtt->RetransmitTimeout ().ToDouble (Time::S) << "s\n";
 
-  m_rtt->IncreaseMultiplier ();             // Double the next RTO
-  m_rtt->SentSeq (SequenceNumber32 (sequenceNumber), 1); // make sure to disable RTT calculation for this sample
-  m_retxSeqs.insert (sequenceNumber);
-  ScheduleNextPacket ();
+  m_rtt->IncreaseMultiplier(); // Double the next RTO
+  m_rtt->SentSeq(SequenceNumber32(sequenceNumber),
+                 1); // make sure to disable RTT calculation for this sample
+  m_retxSeqs.insert(sequenceNumber);
+  ScheduleNextPacket();
 }
 
 void
-Consumer::WillSendOutInterest (uint32_t sequenceNumber)
+Consumer::WillSendOutInterest(uint32_t sequenceNumber)
 {
-  NS_LOG_DEBUG ("Trying to add " << sequenceNumber << " with " << Simulator::Now () << ". already " << m_seqTimeouts.size () << " items");
+  NS_LOG_DEBUG("Trying to add " << sequenceNumber << " with " << Simulator::Now() << ". already "
+                                << m_seqTimeouts.size() << " items");
 
-  m_seqTimeouts.insert (SeqTimeout (sequenceNumber, Simulator::Now ()));
-  m_seqFullDelay.insert (SeqTimeout (sequenceNumber, Simulator::Now ()));
+  m_seqTimeouts.insert(SeqTimeout(sequenceNumber, Simulator::Now()));
+  m_seqFullDelay.insert(SeqTimeout(sequenceNumber, Simulator::Now()));
 
-  m_seqLastDelay.erase (sequenceNumber);
-  m_seqLastDelay.insert (SeqTimeout (sequenceNumber, Simulator::Now ()));
+  m_seqLastDelay.erase(sequenceNumber);
+  m_seqLastDelay.insert(SeqTimeout(sequenceNumber, Simulator::Now()));
 
-  m_seqRetxCounts[sequenceNumber] ++;
+  m_seqRetxCounts[sequenceNumber]++;
 
-  m_rtt->SentSeq (SequenceNumber32 (sequenceNumber), 1);
+  m_rtt->SentSeq(SequenceNumber32(sequenceNumber), 1);
 }
 
-
 } // namespace ndn
 } // namespace ns3