Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

OSPF::RoutingTableEntry Class Reference

#include <OSPFRoutingTableEntry.h>

Inheritance diagram for OSPF::RoutingTableEntry:

RoutingEntry List of all members.

Public Types

typedef unsigned char RoutingDestinationType
enum  RoutingPathType { IntraArea = 0, InterArea = 1, Type1External = 2, Type2External = 3 }

Public Member Functions

 RoutingTableEntry (void)
 RoutingTableEntry (const RoutingTableEntry &entry)
virtual ~RoutingTableEntry (void)
bool operator== (const RoutingTableEntry &entry) const
bool operator!= (const RoutingTableEntry &entry) const
void SetDestinationType (RoutingDestinationType type)
RoutingDestinationType GetDestinationType (void) const
void SetDestinationID (IPAddress destID)
IPAddress GetDestinationID (void) const
void SetAddressMask (IPAddress destMask)
IPAddress GetAddressMask (void) const
void SetOptionalCapabilities (OSPFOptions options)
OSPFOptions GetOptionalCapabilities (void) const
void SetArea (AreaID source)
AreaID GetArea (void) const
void SetPathType (RoutingPathType type)
RoutingPathType GetPathType (void) const
void SetCost (Metric pathCost)
Metric GetCost (void) const
void SetType2Cost (Metric pathCost)
Metric GetType2Cost (void) const
void SetLinkStateOrigin (const OSPFLSA *lsa)
const OSPFLSA * GetLinkStateOrigin (void) const
void AddNextHop (NextHop hop)
void ClearNextHops (void)
unsigned int GetNextHopCount (void) const
NextHop GetNextHop (unsigned int index) const

Static Public Attributes

static const unsigned char NetworkDestination = 0
static const unsigned char AreaBorderRouterDestination = 1
static const unsigned char ASBoundaryRouterDestination = 2

Private Attributes

RoutingDestinationType destinationType
OSPFOptions optionalCapabilities
AreaID area
RoutingPathType pathType
Metric cost
Metric type2Cost
const OSPFLSA * linkStateOrigin
std::vector< NextHopnextHops

Member Typedef Documentation

typedef unsigned char OSPF::RoutingTableEntry::RoutingDestinationType
 


Member Enumeration Documentation

enum OSPF::RoutingTableEntry::RoutingPathType
 

Enumeration values:
IntraArea 
InterArea 
Type1External 
Type2External 
00014                          {
00015         IntraArea     = 0,
00016         InterArea     = 1,
00017         Type1External = 2,
00018         Type2External = 3
00019     };


Constructor & Destructor Documentation

OSPF::RoutingTableEntry::RoutingTableEntry void   )  [inline]
 

00076                                                      :
00077     RoutingEntry (),
00078     destinationType (OSPF::RoutingTableEntry::NetworkDestination),
00079     area (OSPF::BackboneAreaID),
00080     pathType (OSPF::RoutingTableEntry::IntraArea),
00081     type2Cost (0),
00082     linkStateOrigin (NULL)
00083 {
00084     netmask = 0xFFFFFFFF;
00085     source  = RoutingEntry::OSPF;
00086     memset (&optionalCapabilities, 0, sizeof (OSPFOptions));
00087 }

OSPF::RoutingTableEntry::RoutingTableEntry const RoutingTableEntry entry  )  [inline]
 

00089                                                                                :
00090     destinationType (entry.destinationType),
00091     optionalCapabilities (entry.optionalCapabilities),
00092     area (entry.area),
00093     pathType (entry.pathType),
00094     cost (entry.cost),
00095     type2Cost (entry.type2Cost),
00096     linkStateOrigin (entry.linkStateOrigin),
00097     nextHops (entry.nextHops)
00098 {
00099     host          = entry.host;
00100     netmask       = entry.netmask;
00101     gateway       = entry.gateway;
00102     interfaceName = entry.interfaceName;
00103     interfacePtr  = entry.interfacePtr;
00104     type          = entry.type;
00105     source        = entry.source;
00106     metric        = entry.metric;
00107 }

virtual OSPF::RoutingTableEntry::~RoutingTableEntry void   )  [inline, virtual]
 

00045 {}


Member Function Documentation

void OSPF::RoutingTableEntry::AddNextHop NextHop  hop  )  [inline]
 

00143 {
00144     if (nextHops.size () == 0) {
00145         InterfaceEntry*    routingInterface = InterfaceTableAccess().get ()->interfaceAt (hop.ifIndex);
00146 
00147         interfacePtr = routingInterface;
00148         interfaceName = routingInterface->name();
00149         //gateway = ULongFromIPv4Address (hop.hopAddress); // TODO: verify this isn't necessary
00150     }
00151     nextHops.push_back (hop);
00152 }

void OSPF::RoutingTableEntry::ClearNextHops void   )  [inline]
 

00069 { nextHops.clear (); }

IPAddress OSPF::RoutingTableEntry::GetAddressMask void   )  const [inline]
 

00055 { return netmask; }

AreaID OSPF::RoutingTableEntry::GetArea void   )  const [inline]
 

00059 { return area; }

Metric OSPF::RoutingTableEntry::GetCost void   )  const [inline]
 

00063 { return cost; }

IPAddress OSPF::RoutingTableEntry::GetDestinationID void   )  const [inline]
 

00053 { return host; }

RoutingDestinationType OSPF::RoutingTableEntry::GetDestinationType void   )  const [inline]
 

00051 { return destinationType; }

const OSPFLSA* OSPF::RoutingTableEntry::GetLinkStateOrigin void   )  const [inline]
 

00067 { return linkStateOrigin; }

NextHop OSPF::RoutingTableEntry::GetNextHop unsigned int  index  )  const [inline]
 

00071 { return nextHops[index]; }

unsigned int OSPF::RoutingTableEntry::GetNextHopCount void   )  const [inline]
 

00070 { return nextHops.size (); }

OSPFOptions OSPF::RoutingTableEntry::GetOptionalCapabilities void   )  const [inline]
 

00057 { return optionalCapabilities; }

RoutingPathType OSPF::RoutingTableEntry::GetPathType void   )  const [inline]
 

00061 { return pathType; }

Metric OSPF::RoutingTableEntry::GetType2Cost void   )  const [inline]
 

00065 { return type2Cost; }

bool OSPF::RoutingTableEntry::operator!= const RoutingTableEntry entry  )  const [inline]
 

00048 { return (!((*this) == entry)); }

bool OSPF::RoutingTableEntry::operator== const RoutingTableEntry entry  )  const [inline]
 

00155 {
00156     unsigned int hopCount = nextHops.size ();
00157     unsigned int i        = 0;
00158 
00159     if (hopCount != entry.nextHops.size ()) {
00160         return false;
00161     }
00162     for (i = 0; i < hopCount; i++) {
00163         if ((nextHops[i] != entry.nextHops[i]))
00164         {
00165             return false;
00166         }
00167     }
00168 
00169     return ((destinationType      == entry.destinationType)      &&
00170             (host                 == entry.host)                 &&
00171             (netmask              == entry.netmask)              &&
00172             (optionalCapabilities == entry.optionalCapabilities) &&
00173             (area                 == entry.area)                 &&
00174             (pathType             == entry.pathType)             &&
00175             (cost                 == entry.cost)                 &&
00176             (type2Cost            == entry.type2Cost)            &&
00177             (linkStateOrigin      == entry.linkStateOrigin));
00178 }

void OSPF::RoutingTableEntry::SetAddressMask IPAddress  destMask  )  [inline]
 

00054 { netmask = destMask; }

void OSPF::RoutingTableEntry::SetArea AreaID  source  )  [inline]
 

00058 { area = source; }

void OSPF::RoutingTableEntry::SetCost Metric  pathCost  )  [inline]
 

00121 {
00122     cost = pathCost;
00123     // FIXME: this is a hack. But the correct way to do it is to implement a separate RoutingTable module for OSPF...
00124     if (pathType == OSPF::RoutingTableEntry::Type2External) {
00125         metric = cost + type2Cost * 1000;
00126     } else {
00127         metric = cost;
00128     }
00129 }

void OSPF::RoutingTableEntry::SetDestinationID IPAddress  destID  )  [inline]
 

00052 { host = destID; }

void OSPF::RoutingTableEntry::SetDestinationType RoutingDestinationType  type  )  [inline]
 

00050 { destinationType = type; }

void OSPF::RoutingTableEntry::SetLinkStateOrigin const OSPFLSA *  lsa  )  [inline]
 

00066 { linkStateOrigin = lsa; }

void OSPF::RoutingTableEntry::SetOptionalCapabilities OSPFOptions  options  )  [inline]
 

00056 { optionalCapabilities = options; }

void OSPF::RoutingTableEntry::SetPathType RoutingPathType  type  )  [inline]
 

00110 {
00111     pathType = type;
00112     // FIXME: this is a hack. But the correct way to do it is to implement a separate RoutingTable module for OSPF...
00113     if (pathType == OSPF::RoutingTableEntry::Type2External) {
00114         metric = cost + type2Cost * 1000;
00115     } else {
00116         metric = cost;
00117     }
00118 }

void OSPF::RoutingTableEntry::SetType2Cost Metric  pathCost  )  [inline]
 

00132 {
00133     type2Cost = pathCost;
00134     // FIXME: this is a hack. But the correct way to do it is to implement a separate RoutingTable module for OSPF...
00135     if (pathType == OSPF::RoutingTableEntry::Type2External) {
00136         metric = cost + type2Cost * 1000;
00137     } else {
00138         metric = cost;
00139     }
00140 }


Member Data Documentation

AreaID OSPF::RoutingTableEntry::area [private]
 

const unsigned char OSPF::RoutingTableEntry::AreaBorderRouterDestination = 1 [static]
 

const unsigned char OSPF::RoutingTableEntry::ASBoundaryRouterDestination = 2 [static]
 

Metric OSPF::RoutingTableEntry::cost [private]
 

RoutingDestinationType OSPF::RoutingTableEntry::destinationType [private]
 

const OSPFLSA* OSPF::RoutingTableEntry::linkStateOrigin [private]
 

const unsigned char OSPF::RoutingTableEntry::NetworkDestination = 0 [static]
 

std::vector<NextHop> OSPF::RoutingTableEntry::nextHops [private]
 

OSPFOptions OSPF::RoutingTableEntry::optionalCapabilities [private]
 

RoutingPathType OSPF::RoutingTableEntry::pathType [private]
 

Metric OSPF::RoutingTableEntry::type2Cost [private]
 


The documentation for this class was generated from the following file:
Generated on Sat Apr 1 20:52:26 2006 for INET Framework for OMNeT++/OMNEST by  doxygen 1.4.1