Struct Router 

pub struct Router<P: Prefix, Ospf = GlobalOspfProcess> {
    pub ospf: Ospf,
    pub sr: SrProcess<P>,
    pub bgp: BgpProcess<P>,
    /* private fields */
}

Bgp Router

Fields

ospf: Ospf

The IGP routing process

sr: SrProcess<P>

The Static Routing Process

bgp: BgpProcess<P>

The BGP routing process

Implementations

impl<P: Prefix, Ospf> Router<P, Ospf>

pub fn router_id(&self) -> RouterId

Return the idx of the Router

pub fn name(&self) -> &str

Return the name of the Router

pub fn asn(&self) -> ASN

Return the AS ID of the Router

pub fn get_load_balancing(&self) -> bool

Check if load balancing is enabled

impl<P: Prefix, Ospf: OspfProcess> Router<P, Ospf>

pub unsafe fn trigger_event<T: Default>( &mut self, event: Event<P, T>, ) -> Result<(StepUpdate<P>, Vec<Event<P, T>>), DeviceError>

Manually trigger the given event, returning the result of that event. No new events will be enqueued automatically.

Safety

The network (that this router is in) will be in an inconsistent state. Make sure to deal with that properly.

pub fn get_fib(&self) -> P::Map<Vec<RouterId>>

Get the forwarding table of the router. The forwarding table is a mapping from each prefix to a next-hop.

TODO: Make this function work with longest prefix map!

pub fn get_next_hop(&self, prefix: P) -> Vec<RouterId>

Get the IGP next hop for a prefix. Prefixes are matched using longest prefix match.

TODO make this function return a slice

Trait Implementations

impl<P: Prefix, Ospf: Clone> Clone for Router<P, Ospf>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P: Debug + Prefix, Ospf: Debug> Debug for Router<P, Ospf>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, P, Ospf> Deserialize<'de> for Router<P, Ospf>

where P: for<'a> Deserialize<'a> + Prefix, Ospf: for<'a> Deserialize<'a>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P: PartialEq + Prefix, Ospf: PartialEq> PartialEq for Router<P, Ospf>

fn eq(&self, other: &Router<P, Ospf>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P, Ospf> Serialize for Router<P, Ospf>

where P: Serialize + Prefix, Ospf: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<P: Prefix, Ospf> StructuralPartialEq for Router<P, Ospf>