Enum TypedAction 

pub enum TypedAction<'a> {
    Typed(TypedActionInner<'a>),
    Drop,
    NonOverwrite,
}

Typed, unencoded forwarding action.

Variants

Typed(TypedActionInner<'a>)

Drop

NonOverwrite

Trait Implementations

impl Action<Single> for TypedAction<'_>

type S = TypedAction<'_>

What single form of action it contains. For structs that implements Action<Single>, S must be itself, while for Action<Multiple> structs, it should define one.

fn default_action() -> TypedAction<'_>

fn no_overwrite() -> TypedAction<'_>

fn overwritten(&self, rhs: &TypedAction<'_>) -> TypedAction<'_>

fn overwritten_(&mut self, rhs: &TypedAction<'_>)

fn from_single( single: <TypedAction<'_> as Action<Single>>::S, ) -> TypedAction<'_>

impl<'a> Clone for TypedAction<'a>

fn clone(&self) -> TypedAction<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TypedAction<'a>

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

Formats the value using the given formatter.

impl<'a> FibLoader<'a, TypedAction<'a>> for PortInfoBase

fn _load<'x, 'p, PE, Err>( &'a self, engine: &'p PE, content: &'x str, ) -> Result<((), (String, Vec<Rule<<PE as MatchEncoder<'p>>::P, TypedAction<'a>>>)), Err<Err>>

where 'a: 'p, 'p: 'a, PE: PredicateEngine<'p>, Err: ParseError<&'x str>,

fn load<'x, 'p, PE>( &'a self, engine: &'p PE, content: &'x str, ) -> Result<(String, Vec<Rule<<PE as MatchEncoder<'p>>::P, A>>), Error<&'x str>>

where 'a: 'p, 'p: 'a, PE: PredicateEngine<'p>,

load fib rules from string content. Since Rule is a combination of action as A and predicate as PredicatePE::P, the lifetime of A (’a) should equals to the lifetime of P (’p)

impl<'a> Hash for TypedAction<'a>

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for TypedAction<'a>

fn eq(&self, other: &TypedAction<'a>) -> 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<'a> UncodedAction<'a> for TypedAction<'a>

type N = &'a Rc<str>

Type of neighbor representation.

type P = &'a Rc<str>

type Err = Error

fn get_type(&self) -> impl Into<u8>

fn get_ports( &self, ) -> Result<Box<dyn Iterator<Item = <TypedAction<'a> as UncodedAction<'a>>::P> + 'a>, <TypedAction<'a> as UncodedAction<'a>>::Err>

fn get_next_hops( &self, ) -> Result<Box<dyn Iterator<Item = &'a Rc<str>> + 'a>, <TypedAction<'a> as UncodedAction<'a>>::Err>

impl<'a> Copy for TypedAction<'a>

impl<'a> Eq for TypedAction<'a>

impl<'a> StructuralPartialEq for TypedAction<'a>