Struct Tup7 

pub struct Tup7<T1, T2, T3, T4, T5, T6, T7>(pub T1, pub T2, pub T3, pub T4, pub T5, pub T6, pub T7);

Tuple Fields

0: T1

1: T2

2: T3

3: T4

4: T5

5: T6

6: T7

Implementations

impl<T1, T2, T3, T4, T5, T6, T7> Tup7<T1, T2, T3, T4, T5, T6, T7>

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

pub fn from_results<E>( t0: Result<T1, E>, t1: Result<T2, E>, t2: Result<T3, E>, t3: Result<T4, E>, t4: Result<T5, E>, t5: Result<T6, E>, t6: Result<T7, E>, ) -> Result<Option<Self>, E>

where T1: IsNone, T2: IsNone, T3: IsNone, T4: IsNone, T5: IsNone, T6: IsNone, T7: IsNone,

impl<T1, T2, T3, T4, T5, T6, T7> Tup7<T1, T2, T3, T4, T5, T6, T7>

pub fn get_0(&self) -> &T1

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

impl<T1, T2, T3, T4, T5, T6, T7> Tup7<T1, T2, T3, T4, T5, T6, T7>

pub fn get_1(&self) -> &T2

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

impl<T1, T2, T3, T4, T5, T6, T7> Tup7<T1, T2, T3, T4, T5, T6, T7>

pub fn get_2(&self) -> &T3

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

impl<T1, T2, T3, T4, T5, T6, T7> Tup7<T1, T2, T3, T4, T5, T6, T7>

pub fn get_3(&self) -> &T4

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

impl<T1, T2, T3, T4, T5, T6, T7> Tup7<T1, T2, T3, T4, T5, T6, T7>

pub fn get_4(&self) -> &T5

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

impl<T1, T2, T3, T4, T5, T6, T7> Tup7<T1, T2, T3, T4, T5, T6, T7>

pub fn get_5(&self) -> &T6

pub fn get_5_mut(&mut self) -> &mut T6

impl<T1, T2, T3, T4, T5, T6, T7> Tup7<T1, T2, T3, T4, T5, T6, T7>

pub fn get_6(&self) -> &T7

pub fn get_6_mut(&mut self) -> &mut T7

impl<T1, T2, T3, T4, T5, T6, T7> Tup7<T1, T2, T3, T4, T5, T6, T7>

pub const NUM_ELEMENTS: usize = 7usize

Trait Implementations

impl<T1, T2, T3, T4, T5, T6, T7> AddAssignByRef for Tup7<T1, T2, T3, T4, T5, T6, T7>

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

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

impl<T1, T2, T3, T4, T5, T6, T7> AddByRef for Tup7<T1, T2, T3, T4, T5, T6, T7>

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

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

impl<T1, T2, T3, T4, T5, T6, T7> Archive for Tup7<T1, T2, T3, T4, T5, T6, T7>

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

type Archived = ArchivedTup7<T1, T2, T3, T4, T5, T6, T7>

The archived representation of this type.

type Resolver = Tup7Resolver<T1, T2, T3, T4, T5, T6, T7>

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, T6, T7> Checkpoint for Tup7<T1, T2, T3, T4, T5, T6, T7>

where Tup7<T1, T2, T3, T4, T5, T6, T7>: for<'lifetime> Serialize<DbspSerializer<'lifetime>> + 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, T6: Clone, T7: Clone> Clone for Tup7<T1, T2, T3, T4, T5, T6, T7>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T1: Copy, T2: Copy, T3: Copy, T4: Copy, T5: Copy, T6: Copy, T7: Copy> Copy for Tup7<T1, T2, T3, T4, T5, T6, T7>

impl<T1: Debug, T2: Debug, T3: Debug, T4: Debug, T5: Debug, T6: Debug, T7: Debug> Debug for Tup7<T1, T2, T3, T4, T5, T6, T7>

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, T6: Default, T7: Default> Default for Tup7<T1, T2, T3, T4, T5, T6, T7>

fn default() -> Tup7<T1, T2, T3, T4, T5, T6, T7>

Returns the “default value” for a type.

impl<'de, T1, T2, T3, T4, T5, T6, T7> Deserialize<'de> for Tup7<T1, T2, T3, T4, T5, T6, T7>

where T1: Deserialize<'de>, T2: Deserialize<'de>, T3: Deserialize<'de>, T4: Deserialize<'de>, T5: Deserialize<'de>, T6: Deserialize<'de>, T7: 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, T6, T7> Deserialize<Tup7<T1, T2, T3, T4, T5, T6, T7>, __D> for Archived<Tup7<T1, T2, T3, T4, T5, T6, T7>>

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>, T6: Archive, Archived<T6>: Deserialize<T6, __D>, T7: Archive, Archived<T7>: Deserialize<T7, __D>,

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

Deserializes using the given deserializer

impl<'de, C, AUX, T1, T2, T3, T4, T5, T6, T7> DeserializeWithContext<'de, C, AUX> for Tup7<T1, T2, T3, T4, T5, T6, T7>

where Tup7<T1, T2, T3, T4, T5, T6, T7>: 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: Eq, T2: Eq, T3: Eq, T4: Eq, T5: Eq, T6: Eq, T7: Eq> Eq for Tup7<T1, T2, T3, T4, T5, T6, T7>

impl<T1, T2, T3, T4, T5, T6, T7> From<(T1, T2, T3, T4, T5, T6, T7)> for Tup7<T1, T2, T3, T4, T5, T6, T7>

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

Converts to this type from the input type.

impl<T1, T2, T3, T4, T5, T6, T7> HasZero for Tup7<T1, T2, T3, T4, T5, T6, T7>

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

fn zero() -> Self

fn is_zero(&self) -> bool

impl<T1: Hash, T2: Hash, T3: Hash, T4: Hash, T5: Hash, T6: Hash, T7: Hash> Hash for Tup7<T1, T2, T3, T4, T5, T6, T7>

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

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

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

impl<T1, T2, T3, T4, T5, T6, T7> Into<(T1, T2, T3, T4, T5, T6, T7)> for Tup7<T1, T2, T3, T4, T5, T6, T7>

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

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

impl<T1, T2, T3, T4, T5, T6, T7> IsNone for Tup7<T1, T2, T3, T4, T5, T6, T7>

type Inner = Tup7<T1, T2, T3, T4, T5, T6, T7>

fn is_none(&self) -> bool

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

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

fn result_to_field<E>(r: Result<Self, E>) -> Result<Self, E>

where Self: Sized,

If Self is Option<T> an Err is converted as Ok(None). For all other types the error is propagated unchanged.

impl<T1, T2, T3, T4, T5, T6, T7, W> MulByRef<W> for Tup7<T1, T2, T3, T4, T5, T6, T7>

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>, T6: MulByRef<W, Output = T6>, T7: MulByRef<W, Output = T7>, W: ZRingValue,

type Output = Tup7<T1, T2, T3, T4, T5, T6, T7>

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>, T6: Neg<Output = T6>, T7: Neg<Output = T7>> Neg for Tup7<T1, T2, T3, T4, T5, T6, T7>

type Output = Tup7<T1, T2, T3, T4, T5, T6, T7>

The resulting type after applying the - operator.

fn neg(self) -> Tup7<T1, T2, T3, T4, T5, T6, T7>

Performs the unary - operation.

impl<T1, T2, T3, T4, T5, T6, T7> NegByRef for Tup7<T1, T2, T3, T4, T5, T6, T7>

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

fn neg_by_ref(&self) -> Self

impl<T1, T2, T3, T4, T5, T6, T7> NumEntries for Tup7<T1, T2, T3, T4, T5, T6, T7>

where T1: NumEntries, T2: NumEntries, T3: NumEntries, T4: NumEntries, T5: NumEntries, T6: NumEntries, T7: 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, T6: Ord, T7: Ord> Ord for Tup7<T1, T2, T3, T4, T5, T6, T7>

fn cmp(&self, other: &Tup7<T1, T2, T3, T4, T5, T6, T7>) -> 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, T6: PartialEq, T7: PartialEq> PartialEq for Tup7<T1, T2, T3, T4, T5, T6, T7>

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

fn partial_cmp( &self, other: &Tup7<T1, T2, T3, T4, T5, T6, T7>, ) -> 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<T1, T2, T3, T4, T5, T6, T7> Serialize for Tup7<T1, T2, T3, T4, T5, T6, T7>

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

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

where T1: Serialize<__S>, T2: Serialize<__S>, T3: Serialize<__S>, T4: Serialize<__S>, T5: Serialize<__S>, T6: Serialize<__S>, T7: 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, T6, T7> SizeOf for Tup7<T1, T2, T3, T4, T5, T6, T7>

where T1: SizeOf, T2: SizeOf, T3: SizeOf, T4: SizeOf, T5: SizeOf, T6: SizeOf, T7: 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, T2, T3, T4, T5, T6, T7> StructuralPartialEq for Tup7<T1, T2, T3, T4, T5, T6, T7>

impl<T1, T2, T3, T4, T5, T6, T7> SupportsRoaring for Tup7<T1, T2, T3, T4, T5, T6, T7>

fn supports_roaring32(&self) -> bool

Returns true if this key type can be represented in a 32-bit roaring bitmap.

fn roaring_u32_offset(&self, _min: &Self) -> Option<u32>

where Self: Sized,

Computes the u32 offset of self relative to min.

fn roaring_u32_offset_dyn(&self, _min: &DynData) -> Option<u32>

Like roaring_u32_offset, but accepts min as a type-erased DynData reference.

fn roaring_u32_offset_dyn_checked(&self, min: &DynData) -> u32

Like roaring_u32_offset_dyn, but panics when the offset cannot be computed.