Struct Single 

pub struct Single {}

Single means the action is one-dimensional, e.g., one forwarding action from a port.

Trait Implementations

impl<'a> Action<Single> for IbAction<'a>

type S = IbAction<'a>

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() -> IbAction<'a>

fn no_overwrite() -> IbAction<'a>

fn overwritten(&self, rhs: &IbAction<'a>) -> IbAction<'a>

fn overwritten_(&mut self, rhs: &IbAction<'a>)

fn from_single(single: <IbAction<'a> as Action<Single>>::S) -> IbAction<'a>

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 Action<Single> for i128

type S = i128

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() -> i128

fn no_overwrite() -> i128

fn overwritten(&self, rhs: &i128) -> i128

fn overwritten_(&mut self, rhs: &i128)

fn from_single(single: <i128 as Action<Single>>::S) -> i128

impl Action<Single> for i16

type S = i16

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() -> i16

fn no_overwrite() -> i16

fn overwritten(&self, rhs: &i16) -> i16

fn overwritten_(&mut self, rhs: &i16)

fn from_single(single: <i16 as Action<Single>>::S) -> i16

impl Action<Single> for i32

type S = i32

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() -> i32

fn no_overwrite() -> i32

fn overwritten(&self, rhs: &i32) -> i32

fn overwritten_(&mut self, rhs: &i32)

fn from_single(single: <i32 as Action<Single>>::S) -> i32

impl Action<Single> for i64

type S = i64

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() -> i64

fn no_overwrite() -> i64

fn overwritten(&self, rhs: &i64) -> i64

fn overwritten_(&mut self, rhs: &i64)

fn from_single(single: <i64 as Action<Single>>::S) -> i64

impl Action<Single> for i8

type S = i8

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() -> i8

fn no_overwrite() -> i8

fn overwritten(&self, rhs: &i8) -> i8

fn overwritten_(&mut self, rhs: &i8)

fn from_single(single: <i8 as Action<Single>>::S) -> i8

impl Action<Single> for isize

type S = isize

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() -> isize

fn no_overwrite() -> isize

fn overwritten(&self, rhs: &isize) -> isize

fn overwritten_(&mut self, rhs: &isize)

fn from_single(single: <isize as Action<Single>>::S) -> isize

impl Action<Single> for u128

type S = u128

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() -> u128

fn no_overwrite() -> u128

fn overwritten(&self, rhs: &u128) -> u128

fn overwritten_(&mut self, rhs: &u128)

fn from_single(single: <u128 as Action<Single>>::S) -> u128

impl Action<Single> for u16

type S = u16

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() -> u16

fn no_overwrite() -> u16

fn overwritten(&self, rhs: &u16) -> u16

fn overwritten_(&mut self, rhs: &u16)

fn from_single(single: <u16 as Action<Single>>::S) -> u16

impl Action<Single> for u32

type S = u32

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() -> u32

fn no_overwrite() -> u32

fn overwritten(&self, rhs: &u32) -> u32

fn overwritten_(&mut self, rhs: &u32)

fn from_single(single: <u32 as Action<Single>>::S) -> u32

impl Action<Single> for u64

type S = u64

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() -> u64

fn no_overwrite() -> u64

fn overwritten(&self, rhs: &u64) -> u64

fn overwritten_(&mut self, rhs: &u64)

fn from_single(single: <u64 as Action<Single>>::S) -> u64

impl Action<Single> for u8

type S = u8

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() -> u8

fn no_overwrite() -> u8

fn overwritten(&self, rhs: &u8) -> u8

fn overwritten_(&mut self, rhs: &u8)

fn from_single(single: <u8 as Action<Single>>::S) -> u8

impl Action<Single> for usize

type S = usize

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() -> usize

fn no_overwrite() -> usize

fn overwritten(&self, rhs: &usize) -> usize

fn overwritten_(&mut self, rhs: &usize)

fn from_single(single: <usize as Action<Single>>::S) -> usize

impl Dimension for Single