inet::PimNeighborTable Class Reference

Class holding informatation about neighboring PIM routers. More...

#include <PimNeighborTable.h>

Inheritance diagram for inet::PimNeighborTable:

Public Types
enum	TimerKind { NeighborLivenessTimer = 1 }

Public Member Functions
virtual	~PimNeighborTable ()
virtual bool	addNeighbor (PimNeighbor *neighbor, double holdTime)
	Adds the a neighbor to the table. More...
virtual bool	deleteNeighbor (PimNeighbor *neighbor)
	Deletes a neighbor from the table. More...
virtual void	restartLivenessTimer (PimNeighbor *neighbor, double holdTime)
	Restarts the Neighbor Liveness timer of the given neighbor. More...
virtual PimNeighbor *	findNeighbor (int interfaceId, Ipv4Address addr)
	Returns the neighbor that is identified by the given (interfaceId,addr), or nullptr if no such neighbor. More...
virtual int	getNumNeighbors (int interfaceId)
	Returns the number of neighbors on the given interface. More...
virtual PimNeighbor *	getNeighbor (int interfaceId, int index)
	Returns the neighbor on the given interface at the specified position. More...

Protected Types
typedef std::vector< PimNeighbor * >	PimNeighborVector
typedef std::map< int, PimNeighborVector >	InterfaceToNeighborsMap

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *) override
virtual void	processLivenessTimer (cMessage *timer)

Protected Attributes
InterfaceToNeighborsMap	neighbors

Friends
std::ostream &	operator<< (std::ostream &os, const PimNeighborVector &v)

Detailed Description

Class holding informatation about neighboring PIM routers.

Routers are identified by the link to which they are connected and their address.

Expired entries are automatically deleted.

Member Typedef Documentation

InterfaceToNeighborsMap

typedef std::map<int, PimNeighborVector> inet::PimNeighborTable::InterfaceToNeighborsMap

protected

PimNeighborVector

typedef std::vector<PimNeighbor *> inet::PimNeighborTable::PimNeighborVector

protected

Member Enumeration Documentation

TimerKind

enum inet::PimNeighborTable::TimerKind

Enumerator
NeighborLivenessTimer

                   {
        NeighborLivenessTimer = 1
    };

Constructor & Destructor Documentation

~PimNeighborTable()

inet::PimNeighborTable::~PimNeighborTable ( )

virtual

{
    for (auto& elem : neighbors) {
        for (auto& _it2 : elem.second) {
            cancelEvent((_it2)->getLivenessTimer());
            delete _it2;
        }
    }
}

Member Function Documentation

addNeighbor()

bool inet::PimNeighborTable::addNeighbor ( PimNeighbor *  neighbor, double  holdTime  )

virtual

Adds the a neighbor to the table.

The operation might fail if there is a neighbor with the same (ie,address) in the table. Success is indicated by the returned value.

{
    Enter_Method("addNeighbor");
 
    PimNeighborVector& neighborsOnInterface = neighbors[entry->getInterfaceId()];
 
    for (auto& elem : neighborsOnInterface)
        if ((elem)->getAddress() == entry->getAddress())
            return false;
 
    EV_DETAIL << "Added new neighbor to table: " << entry->str() << "\n";
    entry->nt = this;
    neighborsOnInterface.push_back(entry);
    take(entry->getLivenessTimer());
    restartLivenessTimer(entry, holdTime);
 
    emit(pimNeighborAddedSignal, entry);
 
    return true;
}

deleteNeighbor()

bool inet::PimNeighborTable::deleteNeighbor ( PimNeighbor *  neighbor )

virtual

Deletes a neighbor from the table.

If the neighbor was not found in the table then it is untouched, otherwise deleted. Returns true if the neighbor object was deleted.

{
    Enter_Method("deleteNeighbor");
 
    auto it = neighbors.find(neighbor->getInterfaceId());
    if (it != neighbors.end()) {
        PimNeighborVector& neighborsOnInterface = it->second;
        auto it2 = find(neighborsOnInterface, neighbor);
        if (it2 != neighborsOnInterface.end()) {
            neighborsOnInterface.erase(it2);
 
            emit(pimNeighborDeletedSignal, neighbor);
 
            neighbor->nt = nullptr;
            cancelEvent(neighbor->getLivenessTimer());
            delete neighbor;
 
            return true;
        }
    }
    return false;
}

Referenced by processLivenessTimer().

findNeighbor()

PimNeighbor * inet::PimNeighborTable::findNeighbor ( int  interfaceId, Ipv4Address  addr  )

virtual

Returns the neighbor that is identified by the given (interfaceId,addr), or nullptr if no such neighbor.

{
    auto neighborsOnInterface = neighbors.find(interfaceId);
    if (neighborsOnInterface != neighbors.end()) {
        for (auto& elem : neighborsOnInterface->second)
            if ((elem)->getAddress() == addr && (elem)->getInterfaceId() == interfaceId)
                return elem;
 
    }
    return nullptr;
}

getNeighbor()

PimNeighbor * inet::PimNeighborTable::getNeighbor ( int  interfaceId, int  index  )

virtual

Returns the neighbor on the given interface at the specified position.

{
    auto it = neighbors.find(interfaceId);
    return it != neighbors.end() ? it->second.at(index) : nullptr;
}

getNumNeighbors()

int inet::PimNeighborTable::getNumNeighbors ( int  interfaceId )

virtual

Returns the number of neighbors on the given interface.

{
    auto it = neighbors.find(interfaceId);
    return it != neighbors.end() ? it->second.size() : 0;
}

handleMessage()

void inet::PimNeighborTable::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    // self message (timer)
    if (msg->isSelfMessage()) {
        if (msg->getKind() == NeighborLivenessTimer) {
            processLivenessTimer(msg);
        }
        else
            ASSERT(false);
    }
    else
        throw cRuntimeError("PimNeighborTable received a message although it does not have gates.");
}

initialize()

void inet::PimNeighborTable::initialize ( int  stage )

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        WATCH_MAP(neighbors);
    }
}

numInitStages()

virtual int inet::PimNeighborTable::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

processLivenessTimer()

void inet::PimNeighborTable::processLivenessTimer ( cMessage *  timer )

protectedvirtual

{
    EV << "PimNeighborTable::processNLTimer\n";
    PimNeighbor *neighbor = check_and_cast<PimNeighbor *>((cObject *)livenessTimer->getContextPointer());
    Ipv4Address neighborAddress = neighbor->getAddress();
    deleteNeighbor(neighbor);
    EV << "PIM::processNLTimer: Neighbor " << neighborAddress << "was removed from PIM neighbor table.\n";
}

Referenced by handleMessage().

restartLivenessTimer()

void inet::PimNeighborTable::restartLivenessTimer ( PimNeighbor *  neighbor, double  holdTime  )

virtual

Restarts the Neighbor Liveness timer of the given neighbor.

When the timer expires, the neigbor is automatically deleted.

{
    Enter_Method("restartLivenessTimer");
    rescheduleAfter(holdTime, neighbor->getLivenessTimer());
}

Referenced by addNeighbor().

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  os, const PimNeighborVector &  v  )

friend

{
    for (unsigned int i = 0; i < v.size(); i++) {
        PimNeighbor *e = v[i];
        os << "[" << i << "]: "
           << "{ If: " << e->getInterfacePtr()->getInterfaceName() << " Addr: " << e->getAddress() << " Ver: " << e->getVersion()
           << " GenID: " << e->getGenerationId() << " DrPriority: " << e->getDRPriority() << " livenessTimer: " << e->getLivenessTimer()->getArrivalTime() << " }; ";
    }
    return os;
};

Member Data Documentation

neighbors

InterfaceToNeighborsMap inet::PimNeighborTable::neighbors

protected

Referenced by addNeighbor(), deleteNeighbor(), findNeighbor(), getNeighbor(), getNumNeighbors(), initialize(), and ~PimNeighborTable().

---

The documentation for this class was generated from the following files:

• PimNeighborTable.h
• PimNeighborTable.cc