ndn-consumer.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#ifndef NDN_CONSUMER_H
#define NDN_CONSUMER_H
 
#include "ns3/ndnSIM/model/ndn-common.hpp"
 
#include "ndn-app.hpp"
 
#include "ns3/random-variable-stream.h"
#include "ns3/nstime.h"
#include "ns3/data-rate.h"
 
#include "ns3/ndnSIM/model/ndn-common.hpp"
#include "ns3/ndnSIM/utils/ndn-rtt-estimator.hpp"
 
#include <set>
#include <map>
 
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/tag.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/member.hpp>
 
namespace ns3 {
namespace ndn {
 
class Consumer : public App {
public:
  static TypeId
  GetTypeId();
 
  Consumer();
  virtual ~Consumer(){};
 
  // From App
  virtual void
  OnData(shared_ptr<const Data> contentObject);
 
  // From App
  virtual void
  OnNack(shared_ptr<const lp::Nack> nack);
 
  virtual void
  OnTimeout(uint32_t sequenceNumber);
 
  void
  SendPacket();
 
  virtual void
  WillSendOutInterest(uint32_t sequenceNumber);
 
public:
  typedef void (*LastRetransmittedInterestDataDelayCallback)(Ptr<App> app, uint32_t seqno, Time delay, int32_t hopCount);
  typedef void (*FirstInterestDataDelayCallback)(Ptr<App> app, uint32_t seqno, Time delay, uint32_t retxCount, int32_t hopCount);
 
protected:
  // from App
  virtual void
  StartApplication();
 
  virtual void
  StopApplication();
 
  virtual void
  ScheduleNextPacket() = 0;
 
  void
  CheckRetxTimeout();
 
  void
  SetRetxTimer(Time retxTimer);
 
  Time
  GetRetxTimer() const;
 
protected:
  Ptr<UniformRandomVariable> m_rand; 
 
  uint32_t m_seq;      
  uint32_t m_seqMax;   
  EventId m_sendEvent; 
  Time m_retxTimer;    
  EventId m_retxEvent; 
 
  Ptr<RttEstimator> m_rtt; 
 
  Time m_offTime;          
  Name m_interestName;     
  Time m_interestLifeTime; 
 
 
  struct RetxSeqsContainer : public std::set<uint32_t> {
  };
 
  RetxSeqsContainer m_retxSeqs; 
 
  struct SeqTimeout {
    SeqTimeout(uint32_t _seq, Time _time)
      : seq(_seq)
      , time(_time)
    {
    }
 
    uint32_t seq;
    Time time;
  };
 
  class i_seq {
  };
  class i_timestamp {
  };
 
 
  struct SeqTimeoutsContainer
    : public boost::multi_index::
        multi_index_container<SeqTimeout,
                              boost::multi_index::
                                indexed_by<boost::multi_index::
                                             ordered_unique<boost::multi_index::tag<i_seq>,
                                                            boost::multi_index::
                                                              member<SeqTimeout, uint32_t,
                                                                     &SeqTimeout::seq>>,
                                           boost::multi_index::
                                             ordered_non_unique<boost::multi_index::
                                                                  tag<i_timestamp>,
                                                                boost::multi_index::
                                                                  member<SeqTimeout, Time,
                                                                         &SeqTimeout::time>>>> {
  };
 
  SeqTimeoutsContainer m_seqTimeouts; 
 
  SeqTimeoutsContainer m_seqLastDelay;
  SeqTimeoutsContainer m_seqFullDelay;
  std::map<uint32_t, uint32_t> m_seqRetxCounts;
 
  TracedCallback<Ptr<App> /* app */, uint32_t /* seqno */, Time /* delay */, int32_t /*hop count*/>
    m_lastRetransmittedInterestDataDelay;
  TracedCallback<Ptr<App> /* app */, uint32_t /* seqno */, Time /* delay */,
                 uint32_t /*retx count*/, int32_t /*hop count*/> m_firstInterestDataDelay;
 
};
 
} // namespace ndn
} // namespace ns3
 
#endif