packet-handler.hpp

Go to the documentation of this file.

#ifndef NDNPH_FACE_PACKET_HANDLER_HPP
#define NDNPH_FACE_PACKET_HANDLER_HPP
 
#include "../port/clock/port.hpp"
#include "face.hpp"
 
namespace ndnph {
 
class PacketHandler {
public:
  using PacketInfo = Face::PacketInfo;
 
  explicit PacketHandler() = default;
 
  explicit PacketHandler(Face& face, int8_t prio = 0) {
    face.addHandler(*this, prio);
  }
 
protected:
  virtual ~PacketHandler() {
    if (m_face != nullptr) {
      m_face->removeHandler(*this);
    }
  }
 
  Face* getFace() const {
    return m_face;
  }
 
  const PacketInfo* getCurrentPacketInfo() const {
    return m_face == nullptr ? nullptr : m_face->getCurrentPacketInfo();
  }
 
  template<typename Packet>
  bool send(Region& region, const Packet& packet, PacketInfo pi = {}) {
    return m_face != nullptr && m_face->send(region, packet, pi);
  }
 
  class WithEndpointId {
  public:
    explicit WithEndpointId(uint64_t endpointId)
      : endpointId(endpointId) {}
 
    void operator()(PacketInfo& pi) const {
      pi.endpointId = endpointId;
    }
 
  public:
    uint64_t endpointId = 0;
  };
 
  class WithPitToken {
  public:
    explicit WithPitToken(const lp::PitToken& pitToken)
      : pitToken(pitToken) {}
 
    void operator()(PacketInfo& pi) const {
      pi.pitToken = pitToken;
    }
 
  public:
    lp::PitToken pitToken;
  };
 
  template<typename Packet, typename... PacketInfoModifier>
  bool send(Region& region, const Packet& packet, const PacketInfoModifier&... pim) {
    return send(region, packet, PacketInfo(), pim...);
  }
 
  template<typename Packet, typename... Arg,
           typename = typename std::enable_if<
             !std::is_base_of<Region, typename std::decay<Packet>::type>::value>::type>
  bool send(const Packet& packet, Arg&&... arg) {
    return send(regionOf(packet), packet, std::forward<Arg>(arg)...);
  }
 
  template<typename... Arg>
  bool reply(Arg&&... arg) {
    const PacketInfo* pi = getCurrentPacketInfo();
    return pi != nullptr && send(std::forward<Arg>(arg)..., *pi);
  }
 
  class OutgoingPendingInterest {
  public:
    OutgoingPendingInterest(PacketHandler* ph)
      : m_ph(*ph) {
      port::RandomSource::generate(reinterpret_cast<uint8_t*>(&m_pitToken), sizeof(m_pitToken));
      expireNow();
    }
 
    template<typename Packet, typename... Arg>
    bool send(const Packet& interest, int timeout, Arg&&... arg) {
      m_expire = ndnph::port::Clock::add(ndnph::port::Clock::now(), timeout);
 
      do {
        ++m_pitToken;
      } while (m_pitToken == 0);
      auto token = lp::PitToken::from4(m_pitToken);
      return m_ph.send(interest, WithPitToken(token), std::forward<Arg>(arg)...);
    }
 
    template<typename Packet>
    bool send(const Packet& interest) {
      return send(interest, interest.getLifetime());
    }
 
    template<typename Packet, typename ArgFirst, typename... Arg,
             typename = typename std::enable_if<!std::is_integral<ArgFirst>::value>::type>
    bool send(const Packet& interest, ArgFirst&& arg1, Arg&&... arg) {
      return send(interest, interest.getLifetime(), std::forward<ArgFirst>(arg1),
                  std::forward<Arg>(arg)...);
    }
 
    bool matchPitToken() const {
      auto pi = m_ph.getCurrentPacketInfo();
      return pi != nullptr && pi->pitToken.to4() == m_pitToken;
    }
 
    bool match(const Data& data, const Interest& interest) const {
      return matchPitToken() && data.canSatisfy(interest);
    }
 
    bool match(const Data& data, const Name& name, bool canBePrefix = true) const {
      StaticRegion<128> region;
      auto interest = region.create<Interest>();
      NDNPH_ASSERT(!!interest);
      interest.setName(name);
      interest.setCanBePrefix(canBePrefix);
      return match(data, interest);
    }
 
    void expireNow() {
      m_expire = port::Clock::now();
    }
 
    bool expired() const {
      return ndnph::port::Clock::isBefore(m_expire, ndnph::port::Clock::now());
    }
 
  private:
    PacketHandler& m_ph;
    uint32_t m_pitToken = 0;
    port::Clock::Time m_expire;
  };
 
private:
  virtual void loop() {}
 
  virtual bool processInterest(Interest) {
    return false;
  }
 
  virtual bool processData(Data) {
    return false;
  }
 
  virtual bool processNack(Nack) {
    return false;
  }
 
  template<typename Packet, typename PimFirst, typename... PimRest>
  bool send(Region& region, const Packet& packet, PacketInfo pi, const PimFirst& pimFirst,
            const PimRest&... pimRest) {
    pimFirst(pi);
    return send(region, packet, pi, pimRest...);
  }
 
private:
  Face* m_face = nullptr;
  PacketHandler* m_next = nullptr;
  int8_t m_prio = 0;
  friend Face;
};
 
} // namespace ndnph
 
#define NDNPH_FACE_PACKET_HANDLER_HPP_END
#include "face-impl.inc"
 
#endif // NDNPH_FACE_PACKET_HANDLER_HPP