Added Routing Table Structures
diff --git a/nlsr.cpp b/nlsr.cpp
index 99cc450..5a873df 100644
--- a/nlsr.cpp
+++ b/nlsr.cpp
@@ -56,7 +56,6 @@
int
main(int argc, char **argv){
-
nlsr nlsr;
string programName(argv[0]);
nlsr.setConfFileName("nlsr.conf");
diff --git a/nlsr.hpp b/nlsr.hpp
index f131ab6..52d5277 100644
--- a/nlsr.hpp
+++ b/nlsr.hpp
@@ -162,6 +162,26 @@
{
return apiPort;
}
+
+ int getIsRoutingTableCalculating()
+ {
+ return isRoutingTableCalculating;
+ }
+
+ void setIsRoutingTableCalculating(int irtc)
+ {
+ isRoutingTableCalculating=irtc;
+ }
+
+ int getIsRouteCalculationScheduled()
+ {
+ return isRouteCalculationScheduled;
+ }
+
+ void setIsRouteCalculationScheduled(int ircs)
+ {
+ isRouteCalculationScheduled=ircs;
+ }
private:
ConfParameter confParam;
diff --git a/nlsr_adl.cpp b/nlsr_adl.cpp
index 0f4be8f..55cbb29 100644
--- a/nlsr_adl.cpp
+++ b/nlsr_adl.cpp
@@ -147,7 +147,7 @@
}
}
-std::list<Adjacent>
+std::list<Adjacent>&
Adl::getAdjList(){
return adjList;
}
diff --git a/nlsr_adl.hpp b/nlsr_adl.hpp
index eac8245..70e250d 100644
--- a/nlsr_adl.hpp
+++ b/nlsr_adl.hpp
@@ -17,7 +17,7 @@
int insert(Adjacent& adj);
int updateAdjacentStatus(string adjName, int s);
int updateAdjacentLinkCost(string adjName, double lc);
- std::list<Adjacent> getAdjList();
+ std::list<Adjacent>& getAdjList();
bool isNeighbor(string adjName);
void incrementTimedOutInterestCount(string& neighbor);
int getTimedOutInterestCount(string& neighbor);
diff --git a/nlsr_lsdb.cpp b/nlsr_lsdb.cpp
index 062a2b1..ffd49b1 100644
--- a/nlsr_lsdb.cpp
+++ b/nlsr_lsdb.cpp
@@ -346,8 +346,13 @@
// add Adj LSA
addAdjLsa(alsa);
// schedule routing table calculation
- pnlsr.getScheduler().scheduleEvent(ndn::time::seconds(15),
- ndn::bind(&RoutingTable::calculate, &pnlsr.getRoutingTable()));
+ if ( pnlsr.getIsRouteCalculationScheduled() != 1 )
+ {
+ pnlsr.getScheduler().scheduleEvent(ndn::time::seconds(15),
+ ndn::bind(&RoutingTable::calculate,
+ &pnlsr.getRoutingTable(),boost::ref(pnlsr)));
+ pnlsr.setIsRouteCalculationScheduled(1);
+ }
}
else
{
@@ -403,6 +408,12 @@
return true;
}
+std::list<AdjLsa>&
+Lsdb::getAdjLsdb()
+{
+ return adjLsdb;
+}
+
void
Lsdb::printAdjLsdb()
{
diff --git a/nlsr_lsdb.hpp b/nlsr_lsdb.hpp
index 3451c71..1225969 100644
--- a/nlsr_lsdb.hpp
+++ b/nlsr_lsdb.hpp
@@ -29,12 +29,13 @@
bool removeCorLsa(string& key);
void printCorLsdb(); //debugging
- //function related to Cor LSDB
+ //function related to Adj LSDB
void scheduledAdjLsaBuild(nlsr& pnlsr);
bool buildAndInstallOwnAdjLsa(nlsr& pnlsr);
bool removeAdjLsa(string& key);
bool installAdjLsa(nlsr& pnlsr, AdjLsa &alsa);
AdjLsa& getAdjLsa(string key);
+ std::list<AdjLsa>& getAdjLsdb();
void printAdjLsdb();
private:
diff --git a/nlsr_map.cpp b/nlsr_map.cpp
new file mode 100644
index 0000000..3c4ee86
--- /dev/null
+++ b/nlsr_map.cpp
@@ -0,0 +1,117 @@
+#include<iostream>
+#include<list>
+
+#include "nlsr.hpp"
+#include "nlsr_adjacent.hpp"
+#include "nlsr_lsa.hpp"
+#include "nlsr_lsdb.hpp"
+#include "nlsr_map.hpp"
+
+
+using namespace std;
+
+ostream&
+operator<<(ostream& os, MapEntry& mpe)
+{
+ os<<"MapEntry: ( Router: "<<mpe.getRouter()<<" Mapping No: ";
+ os<<mpe.getMappingNumber()<<" )"<<endl;
+
+ return os;
+}
+
+static bool
+mapEntryCompareByRouter(MapEntry& mpe1, string& rtrName){
+ return mpe1.getRouter()==rtrName;
+}
+
+static bool
+mapEntryCompareByMappingNo(MapEntry& mpe1, int mappingNo){
+ return mpe1.getMappingNumber()==mappingNo;
+}
+
+void
+Map::addMapElement(string& rtrName)
+{
+ MapEntry me(rtrName,mappingIndex);
+ if ( addMapElement(me) )
+ {
+ mappingIndex++;
+ }
+}
+
+bool
+Map::addMapElement(MapEntry& mpe)
+{
+ //cout << mpe;
+ std::list<MapEntry >::iterator it = std::find_if( rMap.begin(),
+ rMap.end(),
+ bind(&mapEntryCompareByRouter, _1, mpe.getRouter()));
+ if ( it == rMap.end() ){
+ rMap.push_back(mpe);
+ return true;
+ }
+ return false;
+}
+
+string
+Map::getRouterNameByMappingNo(int mn)
+{
+ std::list<MapEntry >::iterator it = std::find_if( rMap.begin(),
+ rMap.end(),
+ bind(&mapEntryCompareByMappingNo, _1, mn));
+ if ( it != rMap.end() ){
+ return (*it).getRouter();
+ }
+ return "";
+}
+
+int
+Map::getMappingNoByRouterName(string& rName)
+{
+ std::list<MapEntry >::iterator it = std::find_if( rMap.begin(),
+ rMap.end(),
+ bind(&mapEntryCompareByRouter, _1, rName));
+ if ( it != rMap.end() ){
+ return (*it).getMappingNumber();
+ }
+ return -1;
+}
+
+void
+Map::createMapFromAdjLsdb(nlsr& pnlsr)
+{
+ std::list<AdjLsa> adjLsdb=pnlsr.getLsdb().getAdjLsdb();
+ for( std::list<AdjLsa>::iterator it=adjLsdb.begin();
+ it!= adjLsdb.end() ; it++)
+ {
+ string linkStartRouter=(*it).getOrigRouter();
+ addMapElement(linkStartRouter);
+ std::list<Adjacent> adl=(*it).getAdl().getAdjList();
+ for( std::list<Adjacent>::iterator itAdl=adl.begin();
+ itAdl!= adl.end() ; itAdl++)
+ {
+ string linkEndRouter=(*itAdl).getAdjacentName();
+ addMapElement(linkEndRouter);
+ }
+
+ }
+}
+
+void
+Map::resetMap()
+{
+ rMap.clear();
+ mappingIndex=0;
+}
+
+ostream&
+operator<<(ostream& os, Map& rMap)
+{
+ os<<"---------------Map----------------------"<<endl;
+ std::list< MapEntry > ml=rMap.getMapList();
+ for( std::list<MapEntry>::iterator it=ml.begin(); it!= ml.end() ; it++){
+ os<< (*it);
+ }
+
+ return os;
+}
diff --git a/nlsr_map.hpp b/nlsr_map.hpp
new file mode 100644
index 0000000..c02104a
--- /dev/null
+++ b/nlsr_map.hpp
@@ -0,0 +1,84 @@
+#ifndef NLSR_MAP_HPP
+#define NLSR_MAP_HPP
+
+#include <iostream>
+#include <list>
+
+#include <ndn-cpp-dev/face.hpp>
+
+class nlsr;
+
+using namespace std;
+
+class MapEntry
+{
+public:
+ MapEntry()
+ : router()
+ , mappingNumber(-1)
+ {
+ }
+
+ ~MapEntry()
+ {
+ }
+
+ MapEntry(string rtr, int mn)
+ {
+ router=rtr;
+ mappingNumber=mn;
+ }
+
+ string getRouter()
+ {
+ return router;
+ }
+
+ int getMappingNumber()
+ {
+ return mappingNumber;
+ }
+private:
+ string router;
+ int mappingNumber;
+};
+
+ostream&
+operator<<(ostream& os, MapEntry& mpe);
+
+class Map
+{
+public:
+ Map()
+ : mappingIndex(0)
+ {
+ }
+
+
+ void addMapElement(string& rtrName);
+ void createMapFromAdjLsdb(nlsr& pnlsr);
+ string getRouterNameByMappingNo(int mn);
+ int getMappingNoByRouterName(string& rName);
+ void resetMap();
+ std::list< MapEntry >& getMapList()
+ {
+ return rMap;
+ }
+
+ int getMapSize()
+ {
+ return rMap.size();
+ }
+
+
+private:
+ bool addMapElement(MapEntry& mpe);
+
+ int mappingIndex;
+ std::list< MapEntry > rMap;
+};
+
+ostream&
+operator<<(ostream& os, Map& rMap);
+
+#endif
diff --git a/nlsr_rt.cpp b/nlsr_rt.cpp
index bcf5af0..b2cc8b9 100644
--- a/nlsr_rt.cpp
+++ b/nlsr_rt.cpp
@@ -1,10 +1,112 @@
#include<iostream>
#include<string>
+#include<list>
#include "nlsr_rt.hpp"
#include "nlsr.hpp"
+#include "nlsr_map.hpp"
+#include "nlsr_rtc.hpp"
using namespace std;
+void
+RoutingTable::calculate(nlsr& pnlsr)
+{
+ if ( pnlsr.getIsRoutingTableCalculating() == 0 )
+ {
+ pnlsr.setIsRoutingTableCalculating(1); //setting routing table calculation
+
+ if ( pnlsr.getLsdb().doesLsaExist(
+ pnlsr.getConfParameter().getRouterPrefix()+"/"+"2",2) )
+ {
+ if(pnlsr.getIsBuildAdjLsaSheduled() != 1)
+ {
+ clearRoutingTable();
+ clearDryRoutingTable(); // for dry run options
+ // calculate Link State routing
+ if( (pnlsr.getConfParameter().getIsHyperbolicCalc() == 0 )
+ || (pnlsr.getConfParameter().getIsHyperbolicCalc() == 2 ) )
+ {
+ calculateLsRoutingTable(pnlsr);
+ }
+ //calculate hyperbolic routing
+ if ( pnlsr.getConfParameter().getIsHyperbolicCalc() == 1 )
+ {
+ calculateHypRoutingTable(pnlsr);
+ }
+ //calculate dry hyperbolic routing
+ if ( pnlsr.getConfParameter().getIsHyperbolicCalc() == 2 )
+ {
+ calculateHypDryRoutingTable(pnlsr);
+ }
+
+ //need to update NPT here
+ }
+ else
+ {
+ cout<<"Adjacency building is scheduled, so ";
+ cout<<"routing table can not be calculated :("<<endl;
+ }
+ }
+ else
+ {
+ cout<<"No Adj LSA of router itself,";
+ cout<< " so Routint table can not be calculated :("<<endl;
+ clearRoutingTable();
+ clearDryRoutingTable(); // for dry run options
+ // need to update NPT here
+ }
+
+ pnlsr.setIsRouteCalculationScheduled(0); //clear scheduled flag
+ pnlsr.setIsRoutingTableCalculating(0); //unsetting routing table calculation
+ }
+ else
+ {
+ pnlsr.getScheduler().scheduleEvent(ndn::time::seconds(15),
+ ndn::bind(&RoutingTable::calculate,this,boost::ref(pnlsr)));
+ pnlsr.setIsRouteCalculationScheduled(1);
+ }
+}
+
+
+void
+RoutingTable::calculateLsRoutingTable(nlsr& pnlsr)
+{
+ Map vMap;
+ vMap.createMapFromAdjLsdb(pnlsr);
+ int numOfRouter=vMap.getMapSize();
+
+ LinkStateRoutingTableCalculator lsrtc(numOfRouter);
+ lsrtc.allocateAdjMatrix();
+ lsrtc.makeAdjMatrix(pnlsr,vMap);
+ lsrtc.calculatePath(vMap,boost::ref(*this),pnlsr);
+ lsrtc.freeAdjMatrix();
+
+
+}
+
+void
+RoutingTable::calculateHypRoutingTable(nlsr& pnlsr)
+{
+
+}
+
+void
+RoutingTable::calculateHypDryRoutingTable(nlsr&pnlsr)
+{
+
+}
+
+void
+RoutingTable::clearRoutingTable()
+{
+ rTable.clear();
+}
+
+void
+RoutingTable::clearDryRoutingTable()
+{
+ dryTable.clear();
+}
diff --git a/nlsr_rt.hpp b/nlsr_rt.hpp
index ac9ccfa..05beda4 100644
--- a/nlsr_rt.hpp
+++ b/nlsr_rt.hpp
@@ -6,6 +6,8 @@
#include "nlsr_rte.hpp"
+class nlsr;
+
using namespace std;
class RoutingTable
@@ -14,13 +16,18 @@
RoutingTable()
{
}
- void calculate()
- {
- cout<<"Routing Table Calculating......"<<endl;
- }
+ void calculate(nlsr& pnlsr);
private:
+ void calculateLsRoutingTable(nlsr& pnlsr);
+ void calculateHypRoutingTable(nlsr& pnlsr);
+ void calculateHypDryRoutingTable(nlsr&pnlsr);
+
+ void clearRoutingTable();
+ void clearDryRoutingTable();
+
std::list< RoutingTableEntry > rTable;
+ std::list< RoutingTableEntry > dryTable;
};
#endif
diff --git a/nlsr_rtc.cpp b/nlsr_rtc.cpp
new file mode 100644
index 0000000..fecc6bc
--- /dev/null
+++ b/nlsr_rtc.cpp
@@ -0,0 +1,69 @@
+#include <iostream>
+#include "nlsr_lsdb.hpp"
+#include "nlsr_rtc.hpp"
+#include "nlsr_map.hpp"
+#include "nlsr_lsa.hpp"
+#include "nlsr.hpp"
+
+using namespace std;
+
+void
+RoutingTableCalculator::allocateAdjMatrix()
+{
+ adjMatrix = new double*[numOfRouter];
+ for(int i = 0; i < numOfRouter; ++i)
+ {
+ adjMatrix[i] = new double[numOfRouter];
+ }
+}
+
+void
+RoutingTableCalculator::makeAdjMatrix(nlsr& pnlsr, Map pMap)
+{
+ std::list<AdjLsa> adjLsdb=pnlsr.getLsdb().getAdjLsdb();
+ for( std::list<AdjLsa>::iterator it=adjLsdb.begin();
+ it!= adjLsdb.end() ; it++)
+ {
+ string linkStartRouter=(*it).getOrigRouter();
+ int row=pMap.getMappingNoByRouterName(linkStartRouter);
+ std::list<Adjacent> adl=(*it).getAdl().getAdjList();
+ for( std::list<Adjacent>::iterator itAdl=adl.begin();
+ itAdl!= adl.end() ; itAdl++)
+ {
+ string linkEndRouter=(*itAdl).getAdjacentName();
+ int col=pMap.getMappingNoByRouterName(linkEndRouter);
+ double cost=(*itAdl).getLinkCost();
+ if ( (row >= 0 && row<numOfRouter) && (col >= 0 && col<numOfRouter) )
+ {
+ adjMatrix[row][col]=cost;
+ }
+ }
+
+ }
+}
+
+void
+RoutingTableCalculator::freeAdjMatrix()
+{
+ for(int i = 0; i < numOfRouter; ++i)
+ {
+ delete [] adjMatrix[i];
+ }
+ delete [] adjMatrix;
+}
+
+void
+LinkStateRoutingTableCalculator::calculatePath(Map& pMap, RoutingTable& rt, nlsr& pnlsr)
+{
+}
+
+void
+HypRoutingTableCalculator::calculatePath(Map& pMap, RoutingTable& rt, nlsr& pnlsr)
+{
+}
+
+void
+HypDryRoutingTableCalculator::calculatePath(Map& pMap, RoutingTable& rt, nlsr& pnlsr)
+{
+}
+
diff --git a/nlsr_rtc.hpp b/nlsr_rtc.hpp
new file mode 100644
index 0000000..5b5cc3b
--- /dev/null
+++ b/nlsr_rtc.hpp
@@ -0,0 +1,72 @@
+#ifndef NLSR_RTC_HPP
+#define NLSR_RTC_HPP
+
+#include <list>
+#include <iostream>
+
+
+
+class Map;
+class RoutingTable;
+class nlsr;
+
+
+using namespace std;
+
+class RoutingTableCalculator
+{
+public:
+ RoutingTableCalculator()
+ {
+ }
+ RoutingTableCalculator(int rn)
+ {
+ numOfRouter=rn;
+ }
+
+ void allocateAdjMatrix();
+ void makeAdjMatrix(nlsr& pnlsr,Map pMap);
+ void freeAdjMatrix();
+
+protected:
+ double ** adjMatrix;
+ int numOfRouter;
+};
+
+class LinkStateRoutingTableCalculator: public RoutingTableCalculator
+{
+public:
+ LinkStateRoutingTableCalculator(int rn)
+ {
+ numOfRouter=rn;
+ }
+
+ void calculatePath(Map& pMap, RoutingTable& rt, nlsr& pnlsr);
+
+};
+
+class HypRoutingTableCalculator: public RoutingTableCalculator
+{
+public:
+ HypRoutingTableCalculator(int rn)
+ {
+ numOfRouter=rn;
+ }
+
+ void calculatePath(Map& pMap, RoutingTable& rt, nlsr& pnlsr);
+
+};
+
+class HypDryRoutingTableCalculator: public RoutingTableCalculator
+{
+ public:
+ HypDryRoutingTableCalculator(int rn)
+ {
+ numOfRouter=rn;
+ }
+
+ void calculatePath(Map& pMap, RoutingTable& rt, nlsr& pnlsr);
+
+};
+
+#endif
diff --git a/nlsr_rte.hpp b/nlsr_rte.hpp
index eeaf48c..6f64836 100644
--- a/nlsr_rte.hpp
+++ b/nlsr_rte.hpp
@@ -17,6 +17,10 @@
}
+ ~RoutingTableEntry()
+ {
+ }
+
RoutingTableEntry(string dest)
: nhl()
{