forwarder.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ndn/common.hpp"
#include "ndn/cs.hpp"
#include "ndn/data.hpp"
#include "ndn/face.hpp"
#include "ndn/fib.hpp"
#include "ndn/interest.hpp"
#include "ndn/pit.hpp"
 
namespace ndn {
 
using InterestCallback = std::function<void(const Interest&, FaceId)>;
 
using DataCallback = std::function<void(const Data&)>;
 
using TimeoutCallback = std::function<void(const Interest&)>;
 
constexpr size_t FORWARDER_MAX_FACES = 8;
 
constexpr size_t FORWARDER_MAX_PREFIXES = 16;
 
class Forwarder {
public:
    Forwarder();
 
    Error init(size_t csMaxEntries = CS_DEFAULT_ENTRIES);
 
    Error addFace(Face* face);
 
    void removeFace(FaceId faceId);
    Error expressInterest(const Interest& interest, DataCallback onData,
                          TimeoutCallback onTimeout = nullptr);
 
    Error sendInterest(const Interest& interest);
    Error registerPrefix(const Name& prefix, InterestCallback callback);
 
    Error registerPrefix(std::string_view prefixUri, InterestCallback callback);
 
    void unregisterPrefix(const Name& prefix);
 
    Error putData(const Data& data);
    Error addRoute(const Name& prefix, FaceId faceId, uint8_t cost = 0);
 
    Error addRoute(std::string_view prefixUri, FaceId faceId, uint8_t cost = 0);
    void processEvents();
    struct Stats {
        uint32_t interestsReceived = 0;  
        uint32_t interestsSent = 0;      
        uint32_t dataReceived = 0;       
        uint32_t dataSent = 0;           
        uint32_t cacheHits = 0;          
        uint32_t cacheMisses = 0;        
    };
 
    const Stats& stats() const { return stats_; }
    Pit& pit() { return pit_; }
 
    ContentStore& cs() { return cs_; }
 
    Fib& fib() { return fib_; }
private:
    void onPacketReceived(FaceId faceId, const uint8_t* data, size_t len);
 
    void onInterestReceived(FaceId faceId, const Interest& interest);
 
    void onDataReceived(FaceId faceId, const Data& data);
 
    void forwardInterest(const Interest& interest, FaceId incomingFace);
 
    void forwardData(const Data& data, PitEntry* pitEntry);
 
    Pit pit_;          
    ContentStore cs_;  
    Fib fib_;          
 
    std::array<Face*, FORWARDER_MAX_FACES> faces_{};  
    size_t numFaces_ = 0;                             
 
    struct PrefixRegistration {
        Name prefix;                
        InterestCallback callback;  
        bool inUse = false;         
    };
    std::array<PrefixRegistration, FORWARDER_MAX_PREFIXES> prefixRegs_{};  
 
    struct PendingInterest {
        Interest interest;                
        DataCallback dataCallback;        
        TimeoutCallback timeoutCallback;  
        bool inUse = false;               
    };
    std::array<PendingInterest, PIT_MAX_ENTRIES> pendingInterests_{};  
 
    Stats stats_{};             
    bool initialized_ = false;  
};
 
}  // namespace ndn