Struct Tup5 

pub struct Tup5<T1, T2, T3, T4, T5>(pub T1, pub T2, pub T3, pub T4, pub T5);

Tuple Fields

0: T1

1: T2

2: T3

3: T4

4: T5

Implementations

impl<T1, T2, T3, T4, T5> Tup5<T1, T2, T3, T4, T5>

pub fn new(t0: T1, t1: T2, t2: T3, t3: T4, t4: T5) -> Self

impl<T1, T2, T3, T4, T5> Tup5<T1, T2, T3, T4, T5>

pub fn get_0(&self) -> &T1

pub fn get_0_mut(&mut self) -> &mut T1

impl<T1, T2, T3, T4, T5> Tup5<T1, T2, T3, T4, T5>

pub fn get_1(&self) -> &T2

pub fn get_1_mut(&mut self) -> &mut T2

impl<T1, T2, T3, T4, T5> Tup5<T1, T2, T3, T4, T5>

pub fn get_2(&self) -> &T3

pub fn get_2_mut(&mut self) -> &mut T3

impl<T1, T2, T3, T4, T5> Tup5<T1, T2, T3, T4, T5>

pub fn get_3(&self) -> &T4

pub fn get_3_mut(&mut self) -> &mut T4

impl<T1, T2, T3, T4, T5> Tup5<T1, T2, T3, T4, T5>

pub fn get_4(&self) -> &T5

pub fn get_4_mut(&mut self) -> &mut T5

impl<T1, T2, T3, T4, T5> Tup5<T1, T2, T3, T4, T5>

pub const NUM_ELEMENTS: usize = 5usize

Trait Implementations

impl<T1, T2, T3, T4, T5> AddAssignByRef for Tup5<T1, T2, T3, T4, T5>

where T1: AddAssignByRef, T2: AddAssignByRef, T3: AddAssignByRef, T4: AddAssignByRef, T5: AddAssignByRef,

fn add_assign_by_ref(&mut self, other: &Self)

impl<T1, T2, T3, T4, T5> AddByRef for Tup5<T1, T2, T3, T4, T5>

where T1: AddByRef, T2: AddByRef, T3: AddByRef, T4: AddByRef, T5: AddByRef,

fn add_by_ref(&self, other: &Self) -> Self

impl<T1, T2, T3, T4, T5> Archive for Tup5<T1, T2, T3, T4, T5>

where T1: Archive, T2: Archive, T3: Archive, T4: Archive, T5: Archive,

type Archived = ArchivedTup5<T1, T2, T3, T4, T5>

The archived representation of this type.

type Resolver = Tup5Resolver<T1, T2, T3, T4, T5>

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl<T1, T2, T3, T4, T5> Checkpoint for Tup5<T1, T2, T3, T4, T5>

where Tup5<T1, T2, T3, T4, T5>: Serialize<Serializer> + Deserializable,

fn checkpoint(&self) -> Result<Vec<u8>, Error>

fn restore(&mut self, data: &[u8]) -> Result<(), Error>

impl<T1: Clone, T2: Clone, T3: Clone, T4: Clone, T5: Clone> Clone for Tup5<T1, T2, T3, T4, T5>

fn clone(&self) -> Tup5<T1, T2, T3, T4, T5>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T1: Debug, T2: Debug, T3: Debug, T4: Debug, T5: Debug> Debug for Tup5<T1, T2, T3, T4, T5>

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

Formats the value using the given formatter.

impl<T1: Default, T2: Default, T3: Default, T4: Default, T5: Default> Default for Tup5<T1, T2, T3, T4, T5>

fn default() -> Tup5<T1, T2, T3, T4, T5>

Returns the “default value” for a type.

impl<'de, T1, T2, T3, T4, T5> Deserialize<'de> for Tup5<T1, T2, T3, T4, T5>

where T1: Deserialize<'de>, T2: Deserialize<'de>, T3: Deserialize<'de>, T4: Deserialize<'de>, T5: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized, T1, T2, T3, T4, T5> Deserialize<Tup5<T1, T2, T3, T4, T5>, __D> for Archived<Tup5<T1, T2, T3, T4, T5>>

where T1: Archive, Archived<T1>: Deserialize<T1, __D>, T2: Archive, Archived<T2>: Deserialize<T2, __D>, T3: Archive, Archived<T3>: Deserialize<T3, __D>, T4: Archive, Archived<T4>: Deserialize<T4, __D>, T5: Archive, Archived<T5>: Deserialize<T5, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Tup5<T1, T2, T3, T4, T5>, __D::Error>

Deserializes using the given deserializer

impl<'de, C, AUX, T1, T2, T3, T4, T5> DeserializeWithContext<'de, C, AUX> for Tup5<T1, T2, T3, T4, T5>

where Tup5<T1, T2, T3, T4, T5>: Deserialize<'de>,

fn deserialize_with_context<D>( deserializer: D, _context: &'de C, ) -> Result<Self, D::Error>

where D: Deserializer<'de>,

fn deserialize_with_context_aux<D>( deserializer: D, context: &'de C, _aux: &'de Option<AUX>, ) -> Result<Self, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

impl<T1, T2, T3, T4, T5> From<(T1, T2, T3, T4, T5)> for Tup5<T1, T2, T3, T4, T5>

fn from((t0, t1, t2, t3, t4): (T1, T2, T3, T4, T5)) -> Self

Converts to this type from the input type.

impl<T1, T2, T3, T4, T5> HasZero for Tup5<T1, T2, T3, T4, T5>

where T1: HasZero, T2: HasZero, T3: HasZero, T4: HasZero, T5: HasZero,

fn zero() -> Self

fn is_zero(&self) -> bool

impl<T1: Hash, T2: Hash, T3: Hash, T4: Hash, T5: Hash> Hash for Tup5<T1, T2, T3, T4, T5>

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

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, T1, T2, T3, T4, T5> Into<(&'a T1, &'a T2, &'a T3, &'a T4, &'a T5)> for &'a Tup5<T1, T2, T3, T4, T5>

fn into(self) -> (&'a T1, &'a T2, &'a T3, &'a T4, &'a T5)

Converts this type into the (usually inferred) input type.

impl<T1, T2, T3, T4, T5> Into<(T1, T2, T3, T4, T5)> for Tup5<T1, T2, T3, T4, T5>

fn into(self) -> (T1, T2, T3, T4, T5)

Converts this type into the (usually inferred) input type.

impl<T1, T2, T3, T4, T5> IsNone for Tup5<T1, T2, T3, T4, T5>

type Inner = Tup5<T1, T2, T3, T4, T5>

fn is_none(&self) -> bool

fn unwrap_or_self(&self) -> &Self::Inner

fn from_inner(inner: Self::Inner) -> Self

impl<T1, T2, T3, T4, T5, W> MulByRef<W> for Tup5<T1, T2, T3, T4, T5>

where T1: MulByRef<W, Output = T1>, T2: MulByRef<W, Output = T2>, T3: MulByRef<W, Output = T3>, T4: MulByRef<W, Output = T4>, T5: MulByRef<W, Output = T5>, W: ZRingValue,

type Output = Tup5<T1, T2, T3, T4, T5>

fn mul_by_ref(&self, other: &W) -> Self::Output

impl<T1: Neg<Output = T1>, T2: Neg<Output = T2>, T3: Neg<Output = T3>, T4: Neg<Output = T4>, T5: Neg<Output = T5>> Neg for Tup5<T1, T2, T3, T4, T5>

type Output = Tup5<T1, T2, T3, T4, T5>

The resulting type after applying the - operator.

fn neg(self) -> Tup5<T1, T2, T3, T4, T5>

Performs the unary - operation.

impl<T1, T2, T3, T4, T5> NegByRef for Tup5<T1, T2, T3, T4, T5>

where T1: NegByRef, T2: NegByRef, T3: NegByRef, T4: NegByRef, T5: NegByRef,

fn neg_by_ref(&self) -> Self

impl<T1, T2, T3, T4, T5> NumEntries for Tup5<T1, T2, T3, T4, T5>

where T1: NumEntries, T2: NumEntries, T3: NumEntries, T4: NumEntries, T5: NumEntries,

const CONST_NUM_ENTRIES: Option<usize> = None

Returns Some(n) if Self has constant size or None otherwise.

fn num_entries_shallow(&self) -> usize

Returns the number of entries in self.

fn num_entries_deep(&self) -> usize

Recursively computes the number of entries in a container by calling this method on each entry in self.

impl<T1: Ord, T2: Ord, T3: Ord, T4: Ord, T5: Ord> Ord for Tup5<T1, T2, T3, T4, T5>

fn cmp(&self, other: &Tup5<T1, T2, T3, T4, T5>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T1: PartialEq, T2: PartialEq, T3: PartialEq, T4: PartialEq, T5: PartialEq> PartialEq for Tup5<T1, T2, T3, T4, T5>

fn eq(&self, other: &Tup5<T1, T2, T3, T4, T5>) -> 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<T1: PartialOrd, T2: PartialOrd, T3: PartialOrd, T4: PartialOrd, T5: PartialOrd> PartialOrd for Tup5<T1, T2, T3, T4, T5>

fn partial_cmp(&self, other: &Tup5<T1, T2, T3, T4, T5>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<__S: Fallible + ?Sized, T1, T2, T3, T4, T5> Serialize<__S> for Tup5<T1, T2, T3, T4, T5>

where T1: Serialize<__S>, T2: Serialize<__S>, T3: Serialize<__S>, T4: Serialize<__S>, T5: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<T1, T2, T3, T4, T5> Serialize for Tup5<T1, T2, T3, T4, T5>

where T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T1, T2, T3, T4, T5> SizeOf for Tup5<T1, T2, T3, T4, T5>

where T1: SizeOf, T2: SizeOf, T3: SizeOf, T4: SizeOf, T5: SizeOf,

fn size_of_children(&self, context: &mut Context)

Gets the size of all “children” owned by this value, not including the size of the value itself.

fn size_of(&self) -> TotalSize

Gets the total size of the current value

fn size_of_with_context(&self, context: &mut Context)

Adds the size of the current value to the given Context, including both the size of the value itself and all of its children

impl<T1: Copy, T2: Copy, T3: Copy, T4: Copy, T5: Copy> Copy for Tup5<T1, T2, T3, T4, T5>

impl<T1: Eq, T2: Eq, T3: Eq, T4: Eq, T5: Eq> Eq for Tup5<T1, T2, T3, T4, T5>

impl<T1, T2, T3, T4, T5> StructuralPartialEq for Tup5<T1, T2, T3, T4, T5>