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

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< NextHop > nextHops

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