src/nlsr_lsa.hpp

#ifndef NLSR_LSA_HPP
#define NLSR_LSA_HPP

#include <ndn-cpp-dev/util/scheduler.hpp>
#include "nlsr_adjacent.hpp"
#include "nlsr_npl.hpp"
#include "nlsr_adl.hpp"

namespace nlsr {

using namespace std;
using namespace ndn;

class Lsa{
public:
	Lsa()
		: origRouter()
		, lsSeqNo()
		, lifeTime()
		, lsaExpiringEventId()
	{
	}	


	void setLsType(uint8_t lst)
	{
		lsType=lst;
	}

	uint8_t getLsType()
	{
		return lsType;
	}

	void setLsSeqNo(uint32_t lsn)
	{
		lsSeqNo=lsn;
	}

	uint32_t getLsSeqNo()
	{
		return lsSeqNo;
	}

	string& getOrigRouter()
	{
		return origRouter;
	}

	void setOrigRouter(string& org)
	{
		origRouter=org;
	}

	uint32_t getLifeTime()
	{
		return lifeTime;
	}

	void setLifeTime(uint32_t lt)
	{
		lifeTime=lt;
	}

	void setLsaExpiringEventId(ndn::EventId leei)
	{
		lsaExpiringEventId=leei;
	}

	ndn::EventId getLsaExpiringEventId()
	{
		return lsaExpiringEventId;
	}
	
	
protected:
	string origRouter;
	uint8_t lsType;
	uint32_t lsSeqNo;
	uint32_t lifeTime;
	ndn::EventId lsaExpiringEventId;
};

class NameLsa:public Lsa{
public:
	NameLsa()
		: Lsa()
		, npl()
	{
		setLsType(1);
	}

	NameLsa(string origR, uint8_t lst, uint32_t lsn, uint32_t lt, Npl npl);

	Npl& getNpl(){
		return npl;
	}

	void addNameToLsa(string& name)
	{
		npl.insertIntoNpl(name);
	}

	void removeNameFromLsa(string& name)
	{
		npl.removeFromNpl(name);
	}

	string getNameLsaKey();

	string getNameLsaData();
	
private:
	Npl npl;
	
};

std::ostream& 
operator<<(std::ostream& os, NameLsa& nLsa);

class AdjLsa: public Lsa{
public:
	AdjLsa()
		: Lsa()
		, adl()
	{
		setLsType(2);
	}

	AdjLsa(string origR, uint8_t lst, uint32_t lsn, uint32_t lt, 
	                                                        uint32_t nl ,Adl padl);
	Adl& getAdl(){
		return adl;
	}

	void addAdjacentToLsa(Adjacent adj)
	{
		adl.insert(adj);
	}
	string getAdjLsaKey();
	string getAdjLsaData();
	uint32_t getNoLink()
	{
		return noLink;
	}

	bool isLsaContentEqual(AdjLsa& alsa);
	void addNptEntriesForAdjLsa(Nlsr& pnlsr);
	void removeNptEntriesForAdjLsa(Nlsr& pnlsr);

private:
	uint32_t noLink;
	Adl adl;
};

std::ostream& 
operator<<(std::ostream& os, AdjLsa& aLsa);

class CorLsa:public Lsa{
public:
	CorLsa()
		:Lsa()
	{
		setLsType(3);
	}

	CorLsa(string origR, uint8_t lst, uint32_t lsn, uint32_t lt
	      																							, double r, double theta);
	string getCorLsaKey();
	string getCorLsaData();
	
	double getCorRadius()
	{
		if ( corRad >= 0 )
		{	
			return corRad;
		}
		else 
		{
			return -1;
		}
	}
	
	void setCorRadius(double cr)
	{
		corRad=cr;
	}

	double getCorTheta()
	{
		return corTheta;
	}

	void setCorTheta(double ct){
		corTheta=ct;
	}

	bool isLsaContentEqual(CorLsa& clsa);
private:
	double corRad;
	double corTheta;

};

std::ostream& 
operator<<(std::ostream& os, CorLsa& cLsa);


}//namespace nlsr

#endif