src/nlsr_adl.cpp

#include<iostream>
#include<algorithm>

#include "nlsr_adl.hpp"
#include "nlsr_adjacent.hpp"
#include "nlsr.hpp"

namespace nlsr
{

  Adl::Adl()
  {
  }

  Adl::~Adl()
  {
  }

  static bool
  adjacent_compare(Adjacent& adj1, Adjacent& adj2)
  {
    return adj1.getAdjacentName()==adj2.getAdjacentName();
  }

  int
  Adl::insert(Adjacent& adj)
  {
    std::list<Adjacent >::iterator it = std::find_if( adjList.begin(),
                                        adjList.end(),
                                        bind(&adjacent_compare, _1, adj));
    if ( it != adjList.end() )
    {
      return -1;
    }
    adjList.push_back(adj);
    return 0;
  }

  void
  Adl::addAdjacentsFromAdl(Adl& adl)
  {
    for(std::list<Adjacent >::iterator it=adl.getAdjList().begin();
        it!=adl.getAdjList().end(); ++it)
    {
      insert((*it));
    }
  }

  int
  Adl::updateAdjacentStatus(string adjName, int s)
  {
    Adjacent adj(adjName);
    std::list<Adjacent >::iterator it = std::find_if( adjList.begin(),
                                        adjList.end(),
                                        bind(&adjacent_compare, _1, adj));
    if( it == adjList.end())
    {
      return -1;
    }
    (*it).setStatus(s);
    return 0;
  }

  Adjacent
  Adl::getAdjacent(string adjName)
  {
    Adjacent adj(adjName);
    std::list<Adjacent >::iterator it = std::find_if( adjList.begin(),
                                        adjList.end(),
                                        bind(&adjacent_compare, _1, adj));
    if( it != adjList.end())
    {
      return (*it);
    }
    return adj;
  }


  bool
  Adl::isAdlEqual(Adl &adl)
  {
    if ( getAdlSize() != adl.getAdlSize() )
    {
      return false;
    }
    adjList.sort(adjacent_compare);
    adl.getAdjList().sort(adjacent_compare);
    int equalAdjCount=0;
    std::list< Adjacent > adjList2=adl.getAdjList();
    std::list<Adjacent>::iterator it1;
    std::list<Adjacent>::iterator it2;
    for(it1=adjList.begin() , it2=adjList2.begin() ;
        it1!=adjList.end(); it1++,it2++)
    {
      if ( !(*it1).isAdjacentEqual((*it2)) )
      {
        break;
      }
      equalAdjCount++;
    }
    return equalAdjCount==getAdlSize();
  }


  int
  Adl::updateAdjacentLinkCost(string adjName, double lc)
  {
    Adjacent adj(adjName);
    std::list<Adjacent >::iterator it = std::find_if( adjList.begin(),
                                        adjList.end(),
                                        bind(&adjacent_compare, _1, adj));
    if( it == adjList.end())
    {
      return -1;
    }
    (*it).setLinkCost(lc);
    return 0;
  }

  bool
  Adl::isNeighbor(string adjName)
  {
    Adjacent adj(adjName);
    std::list<Adjacent >::iterator it = std::find_if( adjList.begin(),
                                        adjList.end(),
                                        bind(&adjacent_compare, _1, adj));
    if( it == adjList.end())
    {
      return false;
    }
    return true;
  }

  void
  Adl::incrementTimedOutInterestCount(string& neighbor)
  {
    Adjacent adj(neighbor);
    std::list<Adjacent >::iterator it = std::find_if( adjList.begin(),
                                        adjList.end(),
                                        bind(&adjacent_compare, _1, adj));
    if( it == adjList.end())
    {
      return ;
    }
    (*it).setInterestTimedOutNo((*it).getInterestTimedOutNo()+1);
  }

  void
  Adl::setTimedOutInterestCount(string& neighbor, int count)
  {
    Adjacent adj(neighbor);
    std::list<Adjacent >::iterator it = std::find_if( adjList.begin(),
                                        adjList.end(),
                                        bind(&adjacent_compare, _1, adj));
    if( it != adjList.end())
    {
      (*it).setInterestTimedOutNo(count);
    }
  }

  int
  Adl::getTimedOutInterestCount(string& neighbor)
  {
    Adjacent adj(neighbor);
    std::list<Adjacent >::iterator it = std::find_if( adjList.begin(),
                                        adjList.end(),
                                        bind(&adjacent_compare, _1, adj));
    if( it == adjList.end())
    {
      return -1;
    }
    return (*it).getInterestTimedOutNo();
  }

  int
  Adl::getStatusOfNeighbor(string& neighbor)
  {
    Adjacent adj(neighbor);
    std::list<Adjacent >::iterator it = std::find_if( adjList.begin(),
                                        adjList.end(),
                                        bind(&adjacent_compare, _1, adj));
    if( it == adjList.end())
    {
      return -1;
    }
    return (*it).getStatus();
  }

  void
  Adl::setStatusOfNeighbor(string& neighbor, int status)
  {
    Adjacent adj(neighbor);
    std::list<Adjacent >::iterator it = std::find_if( adjList.begin(),
                                        adjList.end(),
                                        bind(&adjacent_compare, _1, adj));
    if( it != adjList.end())
    {
      (*it).setStatus(status);
    }
  }

  std::list<Adjacent>&
  Adl::getAdjList()
  {
    return adjList;
  }

  bool
  Adl::isAdjLsaBuildable(Nlsr& pnlsr)
  {
    int nbrCount=0;
    for( std::list<Adjacent>::iterator it=adjList.begin();
         it!= adjList.end() ; it++)
    {
      if ( ((*it).getStatus() == 1 ) )
      {
        nbrCount++;
      }
      else
      {
        if ( (*it).getInterestTimedOutNo() >=
             pnlsr.getConfParameter().getInterestRetryNumber())
        {
          nbrCount++;
        }
      }
    }
    if( nbrCount == adjList.size())
    {
      return true;
    }
    return false;
  }

  int
  Adl::getNumOfActiveNeighbor()
  {
    int actNbrCount=0;
    for( std::list<Adjacent>::iterator it=adjList.begin();
         it!= adjList.end() ; it++)
    {
      if ( ((*it).getStatus() == 1 ) )
      {
        actNbrCount++;
      }
    }
    return actNbrCount;
  }

// used for debugging purpose
  void
  Adl::printAdl()
  {
    for( std::list<Adjacent>::iterator it=adjList.begin(); it!= adjList.end() ;
         it++)
    {
      cout<< (*it) <<endl;
    }
  }

} //namespace nlsr