ndn-stack-helper.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#ifndef NDNSIM_HELPER_NDN_STACK_HELPER_HPP
#define NDNSIM_HELPER_NDN_STACK_HELPER_HPP
 
#include "ns3/ndnSIM/model/ndn-common.hpp"
 
#include "ns3/ptr.h"
#include "ns3/object-factory.h"
#include "ns3/node.h"
#include "ns3/node-container.h"
 
#include "ndn-fib-helper.hpp"
#include "ndn-strategy-choice-helper.hpp"
 
namespace nfd {
namespace cs {
class Policy;
} // namespace cs
} // namespace nfd
 
namespace ns3 {
 
class Node;
 
namespace ndn {
 
class L3Protocol;
 
class StackHelper : boost::noncopyable {
public:
  StackHelper();
 
  virtual ~StackHelper();
 
  void
  SetStackAttributes(const std::string& attr1 = "", const std::string& value1 = "",
                     const std::string& attr2 = "", const std::string& value2 = "",
                     const std::string& attr3 = "", const std::string& value3 = "",
                     const std::string& attr4 = "", const std::string& value4 = "");
 
  void
  setCsSize(size_t maxSize);
 
  void
  setPolicy(const std::string& policy);
 
  typedef Callback<shared_ptr<Face>, Ptr<Node>, Ptr<L3Protocol>, Ptr<NetDevice>>
    FaceCreateCallback;
 
  void
  AddFaceCreateCallback(TypeId netDeviceType, FaceCreateCallback callback);
 
  void
  UpdateFaceCreateCallback(TypeId netDeviceType, FaceCreateCallback callback);
 
  void
  RemoveFaceCreateCallback(TypeId netDeviceType, FaceCreateCallback callback);
 
  void
  Install(const std::string& nodeName) const;
 
  void
  Install(Ptr<Node> node) const;
 
  void
  Install(const NodeContainer& c) const;
 
  void
  InstallAll() const;
 
  void
  SetDefaultRoutes(bool needSet);
 
  static KeyChain&
  getKeyChain();
 
  void
  Update(Ptr<Node> node);
 
  void
  Update(const NodeContainer& c);
 
  void
  Update(const std::string& nodeName);
 
  void
  UpdateAll();
 
  void
  disableStrategyChoiceManager();
 
  void
  disableForwarderStatusManager();
 
  static void
  SetLinkDelayAsFaceMetric();
 
  static void
  ProcessWarmupEvents();
 
private:
  void
  doInstall(Ptr<Node> node) const;
 
private:
  shared_ptr<Face>
  DefaultNetDeviceCallback(Ptr<Node> node, Ptr<L3Protocol> ndn, Ptr<NetDevice> netDevice) const;
 
  shared_ptr<Face>
  PointToPointNetDeviceCallback(Ptr<Node> node, Ptr<L3Protocol> ndn,
                                Ptr<NetDevice> netDevice) const;
  shared_ptr<Face>
  createAndRegisterFace(Ptr<Node> node, Ptr<L3Protocol> ndn, Ptr<NetDevice> device) const;
 
  bool m_isForwarderStatusManagerDisabled;
  bool m_isStrategyChoiceManagerDisabled;
 
public:
  void
  setCustomNdnCxxClocks();
 
private:
  ObjectFactory m_ndnFactory;
 
  bool m_needSetDefaultRoutes;
  size_t m_maxCsSize = 100;
 
  typedef std::function<std::unique_ptr<nfd::cs::Policy>()> PolicyCreationCallback;
  PolicyCreationCallback m_csPolicyCreationFunc;
 
  std::map<std::string, PolicyCreationCallback> m_csPolicies;
 
  typedef std::list<std::pair<TypeId, FaceCreateCallback>> NetDeviceCallbackList;
  NetDeviceCallbackList m_netDeviceCallbacks;
};
 
} // namespace ndn
} // namespace ns3
 
#endif // NDNSIM_HELPER_NDN_STACK_HELPER_HPP