Enum Variant7 

pub enum Variant7<T0, T1, T2, T3, T4, T5, T6> {
    V0(T0),
    V1(T1),
    V2(T2),
    V3(T3),
    V4(T4),
    V5(T5),
    V6(T6),
}

Variants

V0(T0)

V1(T1)

V2(T2)

V3(T3)

V4(T4)

V5(T5)

V6(T6)

Implementations

impl<T0, T1, T2, T3, T4, T5, T6> Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: 'static, T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static,

Returns Some(&T) if the active alternative has type T, else None.

pub fn get_if<T>(&self) -> Option<&T>

where T: 'static,

impl<T0, T1, T2, T3, T4, T5, T6> Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: 'static, T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static,

pub fn get_if_mut<T>(&mut self) -> Option<&mut T>

where T: 'static,

impl<T0, T1, T2, T3, T4, T5, T6> Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: 'static, T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static,

pub fn get_type_id<T>() -> i32

where T: 'static,

impl<T0, T1, T2, T3, T4, T5, T6> Variant7<T0, T1, T2, T3, T4, T5, T6>

pub fn operator_assign_mut( &mut self, other: Variant7<T0, T1, T2, T3, T4, T5, T6>, )

impl<T0, T1, T2, T3, T4, T5, T6> Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: PartialEq, T1: PartialEq, T2: PartialEq, T3: PartialEq, T4: PartialEq, T5: PartialEq, T6: PartialEq,

pub fn variant_operator_eq( &self, other: &Variant7<T0, T1, T2, T3, T4, T5, T6>, ) -> bool

impl<T0, T1, T2, T3, T4, T5, T6> Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: PartialEq, T1: PartialEq, T2: PartialEq, T3: PartialEq, T4: PartialEq, T5: PartialEq, T6: PartialEq,

pub fn variant_operator_ne( &self, other: &Variant7<T0, T1, T2, T3, T4, T5, T6>, ) -> bool

impl<T0, T1, T2, T3, T4, T5, T6> Variant7<T0, T1, T2, T3, T4, T5, T6>

pub fn variant(&mut self)

impl<T0, T1, T2, T3, T4, T5, T6> Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: 'static, T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static,

pub fn variant_t_enable_if_t_get_type_id_t<T>( value: T, ) -> Variant7<T0, T1, T2, T3, T4, T5, T6>

where T: 'static,

impl<T0, T1, T2, T3, T4, T5, T6> Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: Clone, T1: Clone, T2: Clone, T3: Clone, T4: Clone, T5: Clone, T6: Clone,

pub fn variant_variant(&self) -> Variant7<T0, T1, T2, T3, T4, T5, T6>

impl<T0, T1, T2, T3, T4, T5, T6> Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: Clone, T1: Clone, T2: Clone, T3: Clone, T4: Clone, T5: Clone, T6: Clone,

pub fn variant_variant_mut(&mut self) -> Variant7<T0, T1, T2, T3, T4, T5, T6>

impl<T0, T1, T2, T3, T4, T5, T6> Variant7<T0, T1, T2, T3, T4, T5, T6>

pub fn variant_destructor(&mut self)

impl<T0, T1, T2, T3, T4, T5, T6> Variant7<T0, T1, T2, T3, T4, T5, T6>

pub fn index(&self) -> usize

index() / typeId — the active alternative’s position.

pub fn valueless_by_exception(&self) -> bool

Always false (this port has no valueless state). Matches the C++ valueless_by_exception.

pub fn get_if_0(&self) -> Option<&T0>

pub fn get_if_0_mut(&mut self) -> Option<&mut T0>

pub fn get_if_1(&self) -> Option<&T1>

pub fn get_if_1_mut(&mut self) -> Option<&mut T1>

pub fn get_if_2(&self) -> Option<&T2>

pub fn get_if_2_mut(&mut self) -> Option<&mut T2>

pub fn get_if_3(&self) -> Option<&T3>

pub fn get_if_3_mut(&mut self) -> Option<&mut T3>

pub fn get_if_4(&self) -> Option<&T4>

pub fn get_if_4_mut(&mut self) -> Option<&mut T4>

pub fn get_if_5(&self) -> Option<&T5>

pub fn get_if_5_mut(&mut self) -> Option<&mut T5>

pub fn get_if_6(&self) -> Option<&T6>

pub fn get_if_6_mut(&mut self) -> Option<&mut T6>

Trait Implementations

impl<T0, T1, T2, T3, T4, T5, T6> Clone for Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: Clone, T1: Clone, T2: Clone, T3: Clone, T4: Clone, T5: Clone, T6: Clone,

fn clone(&self) -> Variant7<T0, T1, T2, T3, T4, T5, T6>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T0, T1, T2, T3, T4, T5, T6> Debug for Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: Debug, T1: Debug, T2: Debug, T3: Debug, T4: Debug, T5: Debug, T6: Debug,

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

Formats the value using the given formatter.

impl<T0, T1, T2, T3, T4, T5, T6> Default for Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: Default,

fn default() -> Variant7<T0, T1, T2, T3, T4, T5, T6>

Returns the “default value” for a type.

impl<T0, T1, T2, T3, T4, T5, T6> Eq for Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: Eq, T1: Eq, T2: Eq, T3: Eq, T4: Eq, T5: Eq, T6: Eq,

impl<T0, T1, T2, T3, T4, T5, T6> Hash for Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: Hash, T1: Hash, T2: Hash, T3: Hash, T4: Hash, T5: Hash, T6: Hash,

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<T0, T1, T2, T3, T4, T5, T6> PartialEq for Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: PartialEq, T1: PartialEq, T2: PartialEq, T3: PartialEq, T4: PartialEq, T5: PartialEq, T6: PartialEq,

fn eq(&self, other: &Variant7<T0, T1, T2, T3, T4, T5, T6>) -> 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<T0, T1, T2, T3, T4, T5, T6> StructuralPartialEq for Variant7<T0, T1, T2, T3, T4, T5, T6>

where T0: PartialEq, T1: PartialEq, T2: PartialEq, T3: PartialEq, T4: PartialEq, T5: PartialEq, T6: PartialEq,