diff --git a/src/route/fib-entry.hpp b/src/route/fib-entry.hpp
index 88de53e..71ecb04 100644
--- a/src/route/fib-entry.hpp
+++ b/src/route/fib-entry.hpp
@@ -23,7 +23,7 @@
   {
   }
 
-  FibEntry(const std::string& name)
+  FibEntry(const ndn::Name& name)
     : m_timeToRefresh(0)
     , m_seqNo(0)
     , m_nexthopList()
@@ -31,7 +31,7 @@
     m_name = name;
   }
 
-  const std::string&
+  const ndn::Name&
   getName() const
   {
     return m_name;
@@ -83,7 +83,7 @@
   isEqualNextHops(NexthopList& nhlOther);
 
 private:
-  std::string m_name;
+  ndn::Name m_name;
   int32_t m_timeToRefresh;
   ndn::EventId m_expiringEventId;
   int32_t m_seqNo;
diff --git a/src/route/fib.cpp b/src/route/fib.cpp
index 1272ab1..fc823c1 100644
--- a/src/route/fib.cpp
+++ b/src/route/fib.cpp
@@ -14,32 +14,31 @@
 using namespace ndn;
 
 static bool
-fibEntryNameCompare(const FibEntry& fibEntry, const string& name)
+fibEntryNameCompare(const FibEntry& fibEntry, const ndn::Name& name)
 {
   return fibEntry.getName() == name ;
 }
 
 void
-Fib::cancelScheduledExpiringEvent(Nlsr& pnlsr, EventId eid)
+Fib::cancelScheduledExpiringEvent(EventId eid)
 {
-  pnlsr.getScheduler().cancelEvent(eid);
+  m_nlsr.getScheduler().cancelEvent(eid);
 }
 
 
 ndn::EventId
-Fib::scheduleEntryRefreshing(Nlsr& pnlsr, const string& name, int32_t feSeqNum,
+Fib::scheduleEntryRefreshing(const ndn::Name& name, int32_t feSeqNum,
                              int32_t refreshTime)
 {
   std::cout << "Fib::scheduleEntryRefreshing Called" << std::endl;
   std::cout << "Name: " << name << " Seq Num: " << feSeqNum << std::endl;
-  return pnlsr.getScheduler().scheduleEvent(ndn::time::seconds(refreshTime),
-                                            ndn::bind(&Fib::refreshEntry, this,
-                                                      boost::ref(pnlsr), 
-                                                      name, feSeqNum));
+  return m_nlsr.getScheduler().scheduleEvent(ndn::time::seconds(refreshTime),
+                                             ndn::bind(&Fib::refreshEntry, this,
+                                                       name, feSeqNum));
 }
 
 void
-Fib::refreshEntry(Nlsr& nlsr, const string& name, int32_t feSeqNum)
+Fib::refreshEntry(const ndn::Name& name, int32_t feSeqNum)
 {
   std::cout << "Fib::refreshEntry Called" << std::endl;
   std::cout << "Name: " << name << " Seq Num: " << feSeqNum << std::endl;
@@ -53,26 +52,24 @@
     {
       std::cout << "Refreshing the FIB entry" << std::endl;
       for (std::list<NextHop>::iterator nhit =
-           (*it).getNexthopList().getNextHops().begin();
-         nhit != (*it).getNexthopList().getNextHops().end(); nhit++)
+             (*it).getNexthopList().getNextHops().begin();
+           nhit != (*it).getNexthopList().getNextHops().end(); nhit++)
       {
         // add entry to NDN-FIB
-        registerPrefixInNfd(it->getName(), nhit->getConnectingFace(), std::ceil(nhit->getRouteCost()));
+        registerPrefixInNfd(it->getName(), nhit->getConnectingFace(),
+                            std::ceil(nhit->getRouteCost()));
       }
-      
       // increase sequence number and schedule refresh again
       it->setSeqNo(feSeqNum + 1);
-      it->setExpiringEventId(scheduleEntryRefreshing(nlsr,
-                                                     it->getName() ,
-                                                     it->getSeqNo(), 
+      it->setExpiringEventId(scheduleEntryRefreshing(it->getName() ,
+                                                     it->getSeqNo(),
                                                      m_refreshTime));
-      
     }
   }
 }
 
 void
-Fib::remove(Nlsr& pnlsr, const std::string& name)
+Fib::remove(const ndn::Name& name)
 {
   std::list<FibEntry>::iterator it = std::find_if(m_table.begin(),
                                                   m_table.end(),
@@ -84,14 +81,14 @@
          nhit != (*it).getNexthopList().getNextHops().end(); nhit++)
     {
       //remove entry from NDN-FIB
-      if (!pnlsr.getAdjacencyList().isNeighbor(it->getName()))
+      if (!m_nlsr.getAdjacencyList().isNeighbor(it->getName()))
       {
         unregisterPrefixFromNfd(it->getName(), nhit->getConnectingFace());
       }
       else
       {
-        if(pnlsr.getAdjacencyList().getAdjacent(it->getName()).getConnectingFace() != 
-           nhit->getConnectingFace())
+        if (m_nlsr.getAdjacencyList().getAdjacent(it->getName()).getConnectingFace() !=
+            nhit->getConnectingFace())
         {
           unregisterPrefixFromNfd(it->getName(), nhit->getConnectingFace());
         }
@@ -99,19 +96,19 @@
     }
     std::cout << "Cancellling Scheduled event" << std::endl;
     std::cout << "Name: " << name << "Seq num: " << it->getSeqNo() << std::endl;
-    cancelScheduledExpiringEvent(pnlsr, (*it).getExpiringEventId());
+    cancelScheduledExpiringEvent((*it).getExpiringEventId());
     m_table.erase(it);
   }
 }
 
 
 void
-Fib::update(Nlsr& pnlsr, const string& name, NexthopList& nextHopList)
+Fib::update(const ndn::Name& name, NexthopList& nextHopList)
 {
   std::cout << "Fib::updateFib Called" << std::endl;
   int startFace = 0;
   int endFace = getNumberOfFacesForName(nextHopList,
-                                        pnlsr.getConfParameter().getMaxFacesPerPrefix());
+                                        m_nlsr.getConfParameter().getMaxFacesPerPrefix());
   std::list<FibEntry>::iterator it = std::find_if(m_table.begin(),
                                                   m_table.end(),
                                                   bind(&fibEntryNameCompare, _1, name));
@@ -127,13 +124,13 @@
       {
         newEntry.getNexthopList().addNextHop((*nhit));
         //Add entry to NDN-FIB
-        registerPrefixInNfd(name, nhit->getConnectingFace(), std::ceil(nhit->getRouteCost()));
+        registerPrefixInNfd(name, nhit->getConnectingFace(),
+                            std::ceil(nhit->getRouteCost()));
       }
       newEntry.getNexthopList().sort();
       newEntry.setTimeToRefresh(m_refreshTime);
       newEntry.setSeqNo(1);
-      newEntry.setExpiringEventId(scheduleEntryRefreshing(pnlsr,
-                                                          name , 1, m_refreshTime));
+      newEntry.setExpiringEventId(scheduleEntryRefreshing(name , 1, m_refreshTime));
       m_table.push_back(newEntry);
     }
   }
@@ -148,8 +145,9 @@
         std::list<NextHop> nhl = nextHopList.getNextHops();
         std::list<NextHop>::iterator nhit = nhl.begin();
         // Add first Entry to NDN-FIB
-        registerPrefixInNfd(name, nhit->getConnectingFace(), std::ceil(nhit->getRouteCost()));
-        removeHop(pnlsr, it->getNexthopList(), nhit->getConnectingFace(), name);
+        registerPrefixInNfd(name, nhit->getConnectingFace(),
+                            std::ceil(nhit->getRouteCost()));
+        removeHop(it->getNexthopList(), nhit->getConnectingFace(), name);
         it->getNexthopList().reset();
         it->getNexthopList().addNextHop((*nhit));
         ++startFace;
@@ -158,21 +156,21 @@
         {
           it->getNexthopList().addNextHop((*nhit));
           //Add Entry to NDN_FIB
-          registerPrefixInNfd(name, nhit->getConnectingFace(), std::ceil(nhit->getRouteCost()));
+          registerPrefixInNfd(name, nhit->getConnectingFace(),
+                              std::ceil(nhit->getRouteCost()));
         }
       }
       it->setTimeToRefresh(m_refreshTime);
       std::cout << "Cancellling Scheduled event" << std::endl;
       std::cout << "Name: " << name << "Seq num: " << it->getSeqNo() << std::endl;
-      cancelScheduledExpiringEvent(pnlsr, it->getExpiringEventId());
+      cancelScheduledExpiringEvent(it->getExpiringEventId());
       it->setSeqNo(it->getSeqNo() + 1);
-      (*it).setExpiringEventId(scheduleEntryRefreshing(pnlsr,
-                                                       it->getName() ,
+      (*it).setExpiringEventId(scheduleEntryRefreshing(it->getName() ,
                                                        it->getSeqNo(), m_refreshTime));
     }
     else
     {
-      remove(pnlsr, name);
+      remove(name);
     }
   }
 }
@@ -180,27 +178,28 @@
 
 
 void
-Fib::clean(Nlsr& pnlsr)
+Fib::clean()
 {
   for (std::list<FibEntry>::iterator it = m_table.begin(); it != m_table.end();
        ++it)
   {
     std::cout << "Cancellling Scheduled event" << std::endl;
-    std::cout << "Name: " << it->getName() << "Seq num: " << it->getSeqNo() << std::endl;
-    cancelScheduledExpiringEvent(pnlsr, (*it).getExpiringEventId());
+    std::cout << "Name: " << it->getName() << "Seq num: " << it->getSeqNo() <<
+              std::endl;
+    cancelScheduledExpiringEvent((*it).getExpiringEventId());
     for (std::list<NextHop>::iterator nhit =
            (*it).getNexthopList().getNextHops().begin();
          nhit != (*it).getNexthopList().getNextHops().end(); nhit++)
     {
       //Remove entry from NDN-FIB
-      if (!pnlsr.getAdjacencyList().isNeighbor(it->getName()))
+      if (!m_nlsr.getAdjacencyList().isNeighbor(it->getName()))
       {
         unregisterPrefixFromNfd(it->getName(), nhit->getConnectingFace());
       }
       else
       {
-        if(pnlsr.getAdjacencyList().getAdjacent(it->getName()).getConnectingFace() != 
-           nhit->getConnectingFace())
+        if (m_nlsr.getAdjacencyList().getAdjacent(it->getName()).getConnectingFace() !=
+            nhit->getConnectingFace())
         {
           unregisterPrefixFromNfd(it->getName(), nhit->getConnectingFace());
         }
@@ -214,7 +213,8 @@
 }
 
 int
-Fib::getNumberOfFacesForName(NexthopList& nextHopList, uint32_t maxFacesPerPrefix)
+Fib::getNumberOfFacesForName(NexthopList& nextHopList,
+                             uint32_t maxFacesPerPrefix)
 {
   int endFace = 0;
   if ((maxFacesPerPrefix == 0) || (nextHopList.getSize() <= maxFacesPerPrefix))
@@ -229,8 +229,8 @@
 }
 
 void
-Fib::removeHop(Nlsr& pnlsr, NexthopList& nl, uint32_t doNotRemoveHopFaceId,
-               const std::string& name)
+Fib::removeHop(NexthopList& nl, uint32_t doNotRemoveHopFaceId,
+               const ndn::Name& name)
 {
   for (std::list<NextHop>::iterator it = nl.getNextHops().begin();
        it != nl.getNextHops().end();   ++it)
@@ -238,14 +238,14 @@
     if (it->getConnectingFace() != doNotRemoveHopFaceId)
     {
       //Remove FIB Entry from NDN-FIB
-      if (!pnlsr.getAdjacencyList().isNeighbor(name))
+      if (!m_nlsr.getAdjacencyList().isNeighbor(name))
       {
         unregisterPrefixFromNfd(name, it->getConnectingFace());
       }
       else
       {
-        if(pnlsr.getAdjacencyList().getAdjacent(name).getConnectingFace() != 
-           it->getConnectingFace())
+        if (m_nlsr.getAdjacencyList().getAdjacent(name).getConnectingFace() !=
+            it->getConnectingFace())
         {
           unregisterPrefixFromNfd(name, it->getConnectingFace());
         }
@@ -255,32 +255,31 @@
 }
 
 void
-Fib::registerPrefixInNfd(const std::string& namePrefix, uint64_t faceId, uint64_t faceCost)
+Fib::registerPrefixInNfd(const ndn::Name& namePrefix, uint64_t faceId,
+                         uint64_t faceCost)
 {
   ndn::nfd::ControlParameters controlParameters;
   controlParameters
-    .setName(namePrefix)
-    .setCost(faceCost)
-    .setFaceId(faceId)
-    .setExpirationPeriod(ndn::time::milliseconds(m_refreshTime*1000))
-    .setOrigin(128);
-
+  .setName(namePrefix)
+  .setCost(faceCost)
+  .setFaceId(faceId)
+  .setExpirationPeriod(ndn::time::milliseconds(m_refreshTime * 1000))
+  .setOrigin(128);
   m_controller.start<ndn::nfd::RibRegisterCommand>(controlParameters,
                                                    ndn::bind(&Fib::onSuccess, this, _1,
                                                              "Successful in name registration"),
                                                    ndn::bind(&Fib::onFailure, this, _1, _2,
                                                              "Failed in name registration"));
 }
-  
+
 void
-Fib::unregisterPrefixFromNfd(const std::string& namePrefix, uint64_t faceId)
+Fib::unregisterPrefixFromNfd(const ndn::Name& namePrefix, uint64_t faceId)
 {
   ndn::nfd::ControlParameters controlParameters;
   controlParameters
-    .setName(namePrefix)
-    .setFaceId(faceId)
-    .setOrigin(128);
-
+  .setName(namePrefix)
+  .setFaceId(faceId)
+  .setOrigin(128);
   m_controller.start<ndn::nfd::RibUnregisterCommand>(controlParameters,
                                                      ndn::bind(&Fib::onSuccess, this, _1,
                                                                "Successful in unregistering name"),
@@ -289,13 +288,15 @@
 }
 
 void
-Fib::onSuccess(const ndn::nfd::ControlParameters& commandSuccessResult, const std::string& message)
+Fib::onSuccess(const ndn::nfd::ControlParameters& commandSuccessResult,
+               const std::string& message)
 {
   std::cout << message << ": " << commandSuccessResult << std::endl;
 }
 
 void
-Fib::onFailure(uint32_t code, const std::string& error, const std::string& message)
+Fib::onFailure(uint32_t code, const std::string& error,
+               const std::string& message)
 {
   std::cout << message << ": " << error << " (code: " << code << ")";
 }
diff --git a/src/route/fib.hpp b/src/route/fib.hpp
index 2a90fc1..0f58351 100644
--- a/src/route/fib.hpp
+++ b/src/route/fib.hpp
@@ -16,8 +16,9 @@
 class Fib
 {
 public:
-  Fib(ndn::Face& face)
-    : m_table()
+  Fib(Nlsr& nlsr, ndn::Face& face)
+    : m_nlsr(nlsr)
+    , m_table()
     , m_refreshTime(0)
     , m_controller(face)
   {
@@ -27,13 +28,13 @@
   }
 
   void
-  remove(Nlsr& pnlsr, const std::string& name);
+  remove(const ndn::Name& name);
 
   void
-  update(Nlsr& pnlsr, const std::string& name, NexthopList& nextHopList);
+  update(const ndn::Name& name, NexthopList& nextHopList);
 
   void
-  clean(Nlsr& pnlsr);
+  clean();
 
   void
   setEntryRefreshTime(int32_t fert)
@@ -46,35 +47,38 @@
 
 private:
   void
-  removeHop(Nlsr& pnlsr, NexthopList& nl, uint32_t doNotRemoveHopFaceId,
-            const std::string& name);
+  removeHop(NexthopList& nl, uint32_t doNotRemoveHopFaceId,
+            const ndn::Name& name);
 
   int
   getNumberOfFacesForName(NexthopList& nextHopList, uint32_t maxFacesPerPrefix);
 
   ndn::EventId
-  scheduleEntryRefreshing(Nlsr& pnlsr, const std::string& name, int32_t feSeqNum,
+  scheduleEntryRefreshing(const ndn::Name& name, int32_t feSeqNum,
                           int32_t refreshTime);
 
   void
-  cancelScheduledExpiringEvent(Nlsr& pnlsr, ndn::EventId eid);
+  cancelScheduledExpiringEvent(ndn::EventId eid);
 
   void
-  refreshEntry(Nlsr& nlsr, const std::string& name, int32_t feSeqNum);
+  refreshEntry(const ndn::Name& name, int32_t feSeqNum);
 
   void
-  registerPrefixInNfd(const std::string& namePrefix, uint64_t faceId, uint64_t faceCost);
+  registerPrefixInNfd(const ndn::Name& namePrefix, uint64_t faceId,
+                      uint64_t faceCost);
 
   void
-  unregisterPrefixFromNfd(const std::string& namePrefix, uint64_t faceId);
-  
+  unregisterPrefixFromNfd(const ndn::Name& namePrefix, uint64_t faceId);
+
   void
-  onSuccess(const ndn::nfd::ControlParameters& commandSuccessResult, const std::string& message);
+  onSuccess(const ndn::nfd::ControlParameters& commandSuccessResult,
+            const std::string& message);
 
   void
   onFailure(uint32_t code, const std::string& error, const std::string& message);
 
 private:
+  Nlsr& m_nlsr;
   std::list<FibEntry> m_table;
   int32_t m_refreshTime;
   ndn::nfd::Controller m_controller;
diff --git a/src/route/map-entry.hpp b/src/route/map-entry.hpp
index 9174345..0c54145 100644
--- a/src/route/map-entry.hpp
+++ b/src/route/map-entry.hpp
@@ -2,8 +2,9 @@
 #define NLSR_MAP_ENTRY_HPP
 
 #include <boost/cstdint.hpp>
+#include <ndn-cxx/name.hpp>
 
-namespace nlsr{
+namespace nlsr {
 
 class MapEntry
 {
@@ -18,13 +19,13 @@
   {
   }
 
-  MapEntry(const std::string& rtr, int32_t mn)
+  MapEntry(const ndn::Name& rtr, int32_t mn)
   {
     m_router = rtr;
     m_mappingNumber = mn;
   }
 
-  const std::string&
+  const ndn::Name&
   getRouter() const
   {
     return m_router;
@@ -37,7 +38,7 @@
   }
 
 private:
-  std::string m_router;
+  ndn::Name m_router;
   int32_t m_mappingNumber;
 };
 
diff --git a/src/route/map.cpp b/src/route/map.cpp
index 4701a05..07310e7 100644
--- a/src/route/map.cpp
+++ b/src/route/map.cpp
@@ -12,7 +12,7 @@
 using namespace std;
 
 static bool
-mapEntryCompareByRouter(MapEntry& mpe1, const string& rtrName)
+mapEntryCompareByRouter(MapEntry& mpe1, const ndn::Name& rtrName)
 {
   return mpe1.getRouter() == rtrName;
 }
@@ -24,7 +24,7 @@
 }
 
 void
-Map::addEntry(const string& rtrName)
+Map::addEntry(const ndn::Name& rtrName)
 {
   MapEntry me(rtrName, m_mappingIndex);
   if (addEntry(me))
@@ -48,7 +48,7 @@
   return false;
 }
 
-string
+const ndn::Name
 Map::getRouterNameByMappingNo(int32_t mn)
 {
   std::list<MapEntry>::iterator it = std::find_if(m_table.begin(),
@@ -59,11 +59,11 @@
   {
     return (*it).getRouter();
   }
-  return "";
+  return ndn::Name();
 }
 
 int32_t
-Map::getMappingNoByRouterName(string& rName)
+Map::getMappingNoByRouterName(const ndn::Name& rName)
 {
   std::list<MapEntry>::iterator it = std::find_if(m_table.begin(),
                                                   m_table.end(),
@@ -83,14 +83,14 @@
   for (std::list<AdjLsa>::iterator it = adjLsdb.begin();
        it != adjLsdb.end() ; it++)
   {
-    string linkStartRouter = (*it).getOrigRouter();
-    addEntry(linkStartRouter);
+    //ndn::Name& linkStartRouter = (*it).getOrigRouter();
+    addEntry((*it).getOrigRouter());
     std::list<Adjacent> adl = (*it).getAdl().getAdjList();
     for (std::list<Adjacent>::iterator itAdl = adl.begin();
          itAdl != adl.end() ; itAdl++)
     {
-      string linkEndRouter = (*itAdl).getName();
-      addEntry(linkEndRouter);
+      //ndn::Name& linkEndRouter = (*itAdl).getName();
+      addEntry((*itAdl).getName());
     }
   }
 }
diff --git a/src/route/map.hpp b/src/route/map.hpp
index cc08771..1c8da32 100644
--- a/src/route/map.hpp
+++ b/src/route/map.hpp
@@ -23,16 +23,16 @@
 
 
   void
-  addEntry(const std::string& rtrName);
+  addEntry(const ndn::Name& rtrName);
 
   void
   createFromAdjLsdb(Nlsr& pnlsr);
 
-  std::string
+  const ndn::Name
   getRouterNameByMappingNo(int32_t mn);
 
   int32_t
-  getMappingNoByRouterName(std::string& rName);
+  getMappingNoByRouterName(const ndn::Name& rName);
 
   void
   reset();
@@ -43,7 +43,7 @@
     return m_table;
   }
 
-  int
+  size_t
   getMapSize() const
   {
     return m_table.size();
diff --git a/src/route/name-prefix-table-entry.cpp b/src/route/name-prefix-table-entry.cpp
index 01eea0d..0ca9bcb 100644
--- a/src/route/name-prefix-table-entry.cpp
+++ b/src/route/name-prefix-table-entry.cpp
@@ -27,7 +27,7 @@
 
 
 static bool
-rteCompare(RoutingTableEntry& rte, string& destRouter)
+rteCompare(RoutingTableEntry& rte, ndn::Name& destRouter)
 {
   return rte.getDestination() == destRouter;
 }
@@ -57,7 +57,8 @@
   else
   {
     (*it).getNexthopList().reset(); // reseting existing routing table's next hop
-    for (std::list<NextHop>::iterator nhit = rte.getNexthopList().getNextHops().begin();
+    for (std::list<NextHop>::iterator nhit =
+           rte.getNexthopList().getNextHops().begin();
          nhit != rte.getNexthopList().getNextHops().end(); ++nhit)
     {
       (*it).getNexthopList().addNextHop((*nhit));
diff --git a/src/route/name-prefix-table-entry.hpp b/src/route/name-prefix-table-entry.hpp
index 0ee28fa..ab507d7 100644
--- a/src/route/name-prefix-table-entry.hpp
+++ b/src/route/name-prefix-table-entry.hpp
@@ -16,13 +16,13 @@
   {
   }
 
-  NamePrefixTableEntry(const std::string& namePrefix)
-    : m_nexthopList()
+  NamePrefixTableEntry(const ndn::Name& namePrefix)
+    : m_namePrefix(namePrefix)
+    , m_nexthopList()
   {
-    m_namePrefix = namePrefix;
   }
 
-  const std::string&
+  const ndn::Name&
   getNamePrefix() const
   {
     return m_namePrefix;
@@ -69,7 +69,7 @@
   addRoutingTableEntry(RoutingTableEntry& rte);
 
 private:
-  std::string m_namePrefix;
+  ndn::Name m_namePrefix;
   std::list<RoutingTableEntry> m_rteList;
   NexthopList m_nexthopList;
 };
diff --git a/src/route/name-prefix-table.cpp b/src/route/name-prefix-table.cpp
index e6a7ccf..f791d0a 100644
--- a/src/route/name-prefix-table.cpp
+++ b/src/route/name-prefix-table.cpp
@@ -5,6 +5,7 @@
 #include "nlsr.hpp"
 #include "name-prefix-table.hpp"
 #include "name-prefix-table-entry.hpp"
+#include "routing-table.hpp"
 
 
 
@@ -13,7 +14,7 @@
 using namespace std;
 
 static bool
-npteCompare(NamePrefixTableEntry& npte, const string& name)
+npteCompare(NamePrefixTableEntry& npte, const ndn::Name& name)
 {
   return npte.getNamePrefix() == name;
 }
@@ -21,7 +22,7 @@
 
 
 void
-NamePrefixTable::addEntry(const string& name, RoutingTableEntry& rte, Nlsr& pnlsr)
+NamePrefixTable::addEntry(const ndn::Name& name, RoutingTableEntry& rte)
 {
   std::list<NamePrefixTableEntry>::iterator it = std::find_if(m_table.begin(),
                                                               m_table.end(), bind(&npteCompare, _1, name));
@@ -34,7 +35,7 @@
     m_table.push_back(newEntry);
     if (rte.getNexthopList().getSize() > 0)
     {
-      pnlsr.getFib().update(pnlsr, name, newEntry.getNexthopList());
+      m_nlsr.getFib().update(name, newEntry.getNexthopList());
     }
   }
   else
@@ -44,77 +45,82 @@
       (*it).addRoutingTableEntry(rte);
       (*it).generateNhlfromRteList();
       (*it).getNexthopList().sort();
-      pnlsr.getFib().update(pnlsr, name, (*it).getNexthopList());
+      m_nlsr.getFib().update(name, (*it).getNexthopList());
     }
     else
     {
       (*it).resetRteListNextHop();
       (*it).getNexthopList().reset();
-      pnlsr.getFib().remove(pnlsr, name);
+      m_nlsr.getFib().remove(name);
     }
   }
 }
 
 void
-NamePrefixTable::removeEntry(const string& name, RoutingTableEntry& rte, Nlsr& pnlsr)
+NamePrefixTable::removeEntry(const ndn::Name& name, RoutingTableEntry& rte)
 {
   std::list<NamePrefixTableEntry>::iterator it = std::find_if(m_table.begin(),
                                                               m_table.end(), bind(&npteCompare, _1, name));
   if (it != m_table.end())
   {
-    string destRouter = rte.getDestination();
+    ndn::Name destRouter = rte.getDestination();
     (*it).removeRoutingTableEntry(rte);
     if (((*it).getRteListSize() == 0) &&
-        (!pnlsr.getLsdb().doesLsaExist(destRouter + "/1", 1)) &&
-        (!pnlsr.getLsdb().doesLsaExist(destRouter + "/2", 2)) &&
-        (!pnlsr.getLsdb().doesLsaExist(destRouter + "/3", 3)))
+        (!m_nlsr.getLsdb().doesLsaExist(destRouter.append("/name"),
+                                        std::string("name"))) &&
+        (!m_nlsr.getLsdb().doesLsaExist(destRouter.append("/adjacency"),
+                                        std::string("adjacency"))) &&
+        (!m_nlsr.getLsdb().doesLsaExist(destRouter.append("/coordinate"),
+                                        std::string("coordinate"))))
     {
       m_table.erase(it);
-      pnlsr.getFib().remove(pnlsr, name);
+      m_nlsr.getFib().remove(name);
     }
     else
     {
       (*it).generateNhlfromRteList();
-      pnlsr.getFib().update(pnlsr, name, (*it).getNexthopList());
+      m_nlsr.getFib().update(name, (*it).getNexthopList());
     }
   }
 }
 
 
 void
-NamePrefixTable::addEntry(const string& name, const string& destRouter, Nlsr& pnlsr)
+NamePrefixTable::addEntry(const ndn::Name& name, const ndn::Name& destRouter)
 {
+  //
   RoutingTableEntry* rteCheck =
-    pnlsr.getRoutingTable().findRoutingTableEntry(destRouter);
+    m_nlsr.getRoutingTable().findRoutingTableEntry(destRouter);
   if (rteCheck != 0)
   {
-    addEntry(name, *(rteCheck) , pnlsr);
+    addEntry(name, *(rteCheck));
   }
   else
   {
     RoutingTableEntry rte(destRouter);
-    addEntry(name, rte, pnlsr);
+    addEntry(name, rte);
   }
 }
 
 void
-NamePrefixTable::removeEntry(const string& name, const string& destRouter, Nlsr& pnlsr)
+NamePrefixTable::removeEntry(const ndn::Name& name, const ndn::Name& destRouter)
 {
+  //
   RoutingTableEntry* rteCheck =
-    pnlsr.getRoutingTable().findRoutingTableEntry(destRouter);
+    m_nlsr.getRoutingTable().findRoutingTableEntry(destRouter);
   if (rteCheck != 0)
   {
-    removeEntry(name, *(rteCheck), pnlsr);
+    removeEntry(name, *(rteCheck));
   }
   else
   {
     RoutingTableEntry rte(destRouter);
-    removeEntry(name, rte, pnlsr);
+    removeEntry(name, rte);
   }
 }
 
 void
-NamePrefixTable::updateWithNewRoute(Nlsr& pnlsr)
+NamePrefixTable::updateWithNewRoute()
 {
   for (std::list<NamePrefixTableEntry>::iterator it = m_table.begin();
        it != m_table.end(); ++it)
@@ -124,15 +130,15 @@
          rteit != rteList.end(); ++rteit)
     {
       RoutingTableEntry* rteCheck =
-        pnlsr.getRoutingTable().findRoutingTableEntry((*rteit).getDestination());
+        m_nlsr.getRoutingTable().findRoutingTableEntry((*rteit).getDestination());
       if (rteCheck != 0)
       {
-        addEntry((*it).getNamePrefix(), *(rteCheck), pnlsr);
+        addEntry((*it).getNamePrefix(), *(rteCheck));
       }
       else
       {
         RoutingTableEntry rte((*rteit).getDestination());
-        addEntry((*it).getNamePrefix(), rte, pnlsr);
+        addEntry((*it).getNamePrefix(), rte);
       }
     }
   }
diff --git a/src/route/name-prefix-table.hpp b/src/route/name-prefix-table.hpp
index 4f7fbb4..b872161 100644
--- a/src/route/name-prefix-table.hpp
+++ b/src/route/name-prefix-table.hpp
@@ -13,30 +13,32 @@
 class NamePrefixTable
 {
 public:
-  NamePrefixTable()
+  NamePrefixTable(Nlsr& nlsr)
+    : m_nlsr(nlsr)
   {
   }
 
   void
-  addEntry(const std::string& name, const std::string& destRouter, Nlsr& pnlsr);
+  addEntry(const ndn::Name& name, const ndn::Name& destRouter);
 
   void
-  removeEntry(const std::string& name, const std::string& destRouter, Nlsr& pnlsr);
+  removeEntry(const ndn::Name& name, const ndn::Name& destRouter);
 
   void
-  updateWithNewRoute(Nlsr& pnlsr);
+  updateWithNewRoute();
 
   void
   print();
 
 private:
   void
-  addEntry(const std::string& name, RoutingTableEntry& rte, Nlsr& pnlsr);
+  addEntry(const ndn::Name& name, RoutingTableEntry& rte);
 
   void
-  removeEntry(const std::string& name, RoutingTableEntry& rte, Nlsr& pnlsr);
+  removeEntry(const ndn::Name& name, RoutingTableEntry& rte);
 
 private:
+  Nlsr& m_nlsr;
   std::list<NamePrefixTableEntry> m_table;
 };
 
diff --git a/src/route/routing-table-calculator.cpp b/src/route/routing-table-calculator.cpp
index 7ec8a23..33a703d 100644
--- a/src/route/routing-table-calculator.cpp
+++ b/src/route/routing-table-calculator.cpp
@@ -38,14 +38,12 @@
   for (std::list<AdjLsa>::iterator it = adjLsdb.begin();
        it != adjLsdb.end() ; it++)
   {
-    string linkStartRouter = (*it).getOrigRouter();
-    int row = pMap.getMappingNoByRouterName(linkStartRouter);
+    int row = pMap.getMappingNoByRouterName((*it).getOrigRouter());
     std::list<Adjacent> adl = (*it).getAdl().getAdjList();
     for (std::list<Adjacent>::iterator itAdl = adl.begin();
          itAdl != adl.end() ; itAdl++)
     {
-      string linkEndRouter = (*itAdl).getName();
-      int col = pMap.getMappingNoByRouterName(linkEndRouter);
+      int col = pMap.getMappingNoByRouterName((*itAdl).getName());
       double cost = (*itAdl).getLinkCost();
       if ((row >= 0 && row < numOfRouter) && (col >= 0 && col < numOfRouter))
       {
@@ -158,8 +156,7 @@
   makeAdjMatrix(pnlsr, pMap);
   std::cout << pMap;
   printAdjMatrix();
-  string routerName = pnlsr.getConfParameter().getRouterPrefix();
-  int sourceRouter = pMap.getMappingNoByRouterName(routerName);
+  int sourceRouter = pMap.getMappingNoByRouterName(pnlsr.getConfParameter().getRouterPrefix());
   //int noLink=getNumOfLinkfromAdjMatrix(sourceRouter);
   allocateParent();
   allocateDistance();
@@ -259,8 +256,7 @@
       if (nextHopRouter != NO_NEXT_HOP)
       {
         double routeCost = m_distance[i];
-        string nextHopRouterName =
-          pMap.getRouterNameByMappingNo(nextHopRouter);
+        ndn::Name nextHopRouterName = pMap.getRouterNameByMappingNo(nextHopRouter);
         int nxtHopFace =
           pnlsr.getAdjacencyList().getAdjacent(nextHopRouterName).getConnectingFace();
         std::cout << "Dest Router: " << pMap.getRouterNameByMappingNo(i) << std::endl;
@@ -382,7 +378,7 @@
                                          RoutingTable& rt, Nlsr& pnlsr)
 {
   makeAdjMatrix(pnlsr, pMap);
-  string routerName = pnlsr.getConfParameter().getRouterPrefix();
+  ndn::Name routerName = pnlsr.getConfParameter().getRouterPrefix();
   int sourceRouter = pMap.getMappingNoByRouterName(routerName);
   int noLink = getNumOfLinkfromAdjMatrix(sourceRouter);
   setNoLink(noLink);
@@ -399,7 +395,7 @@
       allocateDistFromNbrToDest();
       for (int j = 0; j < vNoLink; j++)
       {
-        string nextHopRouterName = pMap.getRouterNameByMappingNo(links[j]);
+        ndn::Name nextHopRouterName = pMap.getRouterNameByMappingNo(links[j]);
         int nextHopFace =
           pnlsr.getAdjacencyList().getAdjacent(nextHopRouterName).getConnectingFace();
         double distToNbr = getHyperbolicDistance(pnlsr, pMap,
@@ -431,7 +427,7 @@
 {
   for (int i = 0 ; i < noFaces ; ++i)
   {
-    string destRouter = pMap.getRouterNameByMappingNo(dest);
+    ndn::Name destRouter = pMap.getRouterNameByMappingNo(dest);
     NextHop nh(m_linkFaces[i], m_distFromNbrToDest[i]);
     rt.addNextHop(destRouter, nh);
     if (m_isDryRun)
@@ -446,8 +442,10 @@
                                                  Map& pMap, int src, int dest)
 {
   double distance = 0.0;
-  string srcRouterKey = pMap.getRouterNameByMappingNo(src) + "/3";
-  string destRouterKey = pMap.getRouterNameByMappingNo(dest) + "/3";
+  ndn::Name srcRouterKey = pMap.getRouterNameByMappingNo(src);
+  srcRouterKey.append("coordinate");
+  ndn::Name destRouterKey = pMap.getRouterNameByMappingNo(dest);
+  destRouterKey.append("coordinate");
   double srcRadius = (pnlsr.getLsdb().findCoordinateLsa(
                         srcRouterKey))->getCorRadius();
   double srcTheta = (pnlsr.getLsdb().findCoordinateLsa(
diff --git a/src/route/routing-table-entry.hpp b/src/route/routing-table-entry.hpp
index 0d0b662..fbba243 100644
--- a/src/route/routing-table-entry.hpp
+++ b/src/route/routing-table-entry.hpp
@@ -2,7 +2,7 @@
 #define NLSR_ROUTING_TABLE_ENTRY_HPP
 
 #include <iostream>
-
+#include <ndn-cxx/name.hpp>
 #include "nexthop-list.hpp"
 
 namespace nlsr {
@@ -18,13 +18,13 @@
   {
   }
 
-  RoutingTableEntry(const std::string& dest)
+  RoutingTableEntry(const ndn::Name& dest)
   {
     m_destination = dest;
   }
 
-  std::string
-  getDestination()
+  const ndn::Name&
+  getDestination() const
   {
     return m_destination;
   }
@@ -36,7 +36,7 @@
   }
 
 private:
-  std::string m_destination;
+  ndn::Name m_destination;
   NexthopList m_nexthopList;
 };
 
diff --git a/src/route/routing-table.cpp b/src/route/routing-table.cpp
index bb7d3fa..7664b89 100644
--- a/src/route/routing-table.cpp
+++ b/src/route/routing-table.cpp
@@ -17,7 +17,6 @@
 RoutingTable::calculate(Nlsr& pnlsr)
 {
   //debugging purpose
-  std::cout << pnlsr.getConfParameter() << std::endl;
   pnlsr.getNamePrefixTable().print();
   pnlsr.getLsdb().printAdjLsdb();
   pnlsr.getLsdb().printCorLsdb();
@@ -26,7 +25,8 @@
   {
     pnlsr.setIsRoutingTableCalculating(1); //setting routing table calculation
     if (pnlsr.getLsdb().doesLsaExist(
-          pnlsr.getConfParameter().getRouterPrefix() + "/" + "2", 2))
+          pnlsr.getConfParameter().getRouterPrefix().toUri() + "/" + "adjacency",
+          std::string("adjacency")))
     {
       if (pnlsr.getIsBuildAdjLsaSheduled() != 1)
       {
@@ -50,7 +50,7 @@
           calculateHypDryRoutingTable(pnlsr);
         }
         //need to update NPT here
-        pnlsr.getNamePrefixTable().updateWithNewRoute(pnlsr);
+        pnlsr.getNamePrefixTable().updateWithNewRoute();
         //debugging purpose
         printRoutingTable();
         pnlsr.getNamePrefixTable().print();
@@ -71,7 +71,7 @@
       clearDryRoutingTable(); // for dry run options
       // need to update NPT here
       std::cout << "Calling Update NPT With new Route" << std::endl;
-      pnlsr.getNamePrefixTable().updateWithNewRoute(pnlsr);
+      pnlsr.getNamePrefixTable().updateWithNewRoute();
       //debugging purpose
       printRoutingTable();
       pnlsr.getNamePrefixTable().print();
@@ -131,14 +131,14 @@
 }
 
 static bool
-routingTableEntryCompare(RoutingTableEntry& rte, string& destRouter)
+routingTableEntryCompare(RoutingTableEntry& rte, ndn::Name& destRouter)
 {
   return rte.getDestination() == destRouter;
 }
 
 // function related to manipulation of routing table
 void
-RoutingTable::addNextHop(string destRouter, NextHop& nh)
+RoutingTable::addNextHop(const ndn::Name& destRouter, NextHop& nh)
 {
   RoutingTableEntry* rteChk = findRoutingTableEntry(destRouter);
   if (rteChk == 0)
@@ -154,7 +154,7 @@
 }
 
 RoutingTableEntry*
-RoutingTable::findRoutingTableEntry(const string destRouter)
+RoutingTable::findRoutingTableEntry(const ndn::Name& destRouter)
 {
   std::list<RoutingTableEntry>::iterator it = std::find_if(m_rTable.begin(),
                                                            m_rTable.end(),
@@ -180,7 +180,7 @@
 
 //function related to manipulation of dry routing table
 void
-RoutingTable::addNextHopToDryTable(string destRouter, NextHop& nh)
+RoutingTable::addNextHopToDryTable(const ndn::Name& destRouter, NextHop& nh)
 {
   std::list<RoutingTableEntry>::iterator it = std::find_if(m_dryTable.begin(),
                                                            m_dryTable.end(),
diff --git a/src/route/routing-table.hpp b/src/route/routing-table.hpp
index 35f563e..983596b 100644
--- a/src/route/routing-table.hpp
+++ b/src/route/routing-table.hpp
@@ -24,19 +24,19 @@
   calculate(Nlsr& pnlsr);
 
   void
-  addNextHop(std::string destRouter, NextHop& nh);
+  addNextHop(const ndn::Name& destRouter, NextHop& nh);
 
   void
   printRoutingTable();
 
   void
-  addNextHopToDryTable(std::string destRouter, NextHop& nh);
+  addNextHopToDryTable(const ndn::Name& destRouter, NextHop& nh);
 
   void
   printDryRoutingTable();
 
   RoutingTableEntry*
-  findRoutingTableEntry(const std::string destRouter);
+  findRoutingTableEntry(const ndn::Name& destRouter);
 
   void
   scheduleRoutingTableCalculation(Nlsr& pnlsr);