Struct Tup2 

pub struct Tup2<T1, T2>(pub T1, pub T2);

A tuple type on which dbsp controls trait implementations.

Tuple Fields

0: T1

1: T2

Implementations

impl<T1, T2> Tup2<T1, T2>

pub fn new(T1: T1, T2: T2) -> Self

Trait Implementations

impl<T1, T2> AddAssignByRef for Tup2<T1, T2>

where T1: AddAssignByRef, T2: AddAssignByRef,

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

impl<T1, T2> AddByRef for Tup2<T1, T2>

where T1: AddByRef, T2: AddByRef,

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

impl<T1, T2> Archive for Tup2<T1, T2>

where T1: Archive + Archive, T2: Archive + Archive, <T1 as Archive>::Archived: Ord, <T2 as Archive>::Archived: Ord,

type Archived = ArchivedTup2<T1, T2>

The archived representation of this type.

type Resolver = Tup2Resolver<T1, T2>

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> Checkpoint for Tup2<T1, T2>

where Tup2<T1, T2>: Serialize<Serializer> + Deserializable,

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

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

impl<T1: Clone, T2: Clone> Clone for Tup2<T1, T2>

fn clone(&self) -> Tup2<T1, T2>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T1: Debug, T2: Debug> Debug for Tup2<T1, T2>

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

Formats the value using the given formatter.

impl<T1: Default, T2: Default> Default for Tup2<T1, T2>

fn default() -> Tup2<T1, T2>

Returns the “default value” for a type.

impl<'de, T1, T2> Deserialize<'de> for Tup2<T1, T2>

where T1: Deserialize<'de>, T2: 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> Deserialize<Tup2<T1, T2>, __D> for Archived<Tup2<T1, T2>>

where T1: Archive + Archive, T2: Archive + Archive, <T1 as Archive>::Archived: Ord, <T2 as Archive>::Archived: Ord, Archived<T1>: Deserialize<T1, __D>, Archived<T2>: Deserialize<T2, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Tup2<T1, T2>, __D::Error>

Deserializes using the given deserializer

impl<'de, C, AUX, T1, T2> DeserializeWithContext<'de, C, AUX> for Tup2<T1, T2>

where Tup2<T1, T2>: 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> From<(T1, T2)> for Tup2<T1, T2>

fn from((T1, T2): (T1, T2)) -> Self

Converts to this type from the input type.

impl<T1, T2> HasZero for Tup2<T1, T2>

where T1: HasZero, T2: HasZero,

fn zero() -> Self

fn is_zero(&self) -> bool

impl<T1: Hash, T2: Hash> Hash for Tup2<T1, T2>

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<T1, T2> Into<(T1, T2)> for Tup2<T1, T2>

fn into(self) -> (T1, T2)

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

impl<T1, T2, W> MulByRef<W> for Tup2<T1, T2>

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

type Output = Tup2<T1, T2>

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

impl<T1: Neg<Output = T1>, T2: Neg<Output = T2>> Neg for Tup2<T1, T2>

type Output = Tup2<T1, T2>

The resulting type after applying the - operator.

fn neg(self) -> Tup2<T1, T2>

Performs the unary - operation.

impl<T1, T2> NegByRef for Tup2<T1, T2>

where T1: NegByRef, T2: NegByRef,

fn neg_by_ref(&self) -> Self

impl<T1, T2> NumEntries for Tup2<T1, T2>

where T1: NumEntries, T2: 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> Ord for Tup2<T1, T2>

fn cmp(&self, other: &Tup2<T1, T2>) -> 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, T2, Trait1, Trait2> Pair<Trait1, Trait2> for Tup2<T1, T2>

where T1: DBData + Erase<Trait1>, T2: DBData + Erase<Trait2>, Trait1: DataTrait + ?Sized, Trait2: DataTrait + ?Sized,

fn fst(&self) -> &Trait1

Return a reference to the first component of the tuple.

fn fst_mut(&mut self) -> &mut Trait1

Return a mutable reference to the first component of the tuple.

fn snd(&self) -> &Trait2

Return a reference to the second component of the tuple.

fn snd_mut(&mut self) -> &mut Trait2

Return a mutable reference to the second component of the tuple.

fn split(&self) -> (&Trait1, &Trait2)

Return a pair of references to the values stored in the tuple.

fn split_mut(&mut self) -> (&mut Trait1, &mut Trait2)

Return a pair of mutable references to the values stored in the tuple.

fn from_refs(&mut self, fst: &Trait1, snd: &Trait2)

Clone the values of fst anf snd to the first and second components of the tuple.

fn from_vals(&mut self, fst: &mut Trait1, snd: &mut Trait2)

Move fst and snd into the first and second components of the tuple without cloning. Sets the contents of fst and snd to default values.

impl<T1: PartialEq, T2: PartialEq> PartialEq for Tup2<T1, T2>

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

fn partial_cmp(&self, other: &Tup2<T1, T2>) -> 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> Serialize<__S> for Tup2<T1, T2>

where T1: Archive + Serialize<__S>, T2: Archive + Serialize<__S>, <T1 as Archive>::Archived: Ord, <T2 as Archive>::Archived: Ord,

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> Serialize for Tup2<T1, T2>

where T1: Serialize, T2: 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> SizeOf for Tup2<T1, T2>

where T1: SizeOf, T2: 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> Copy for Tup2<T1, T2>

impl<T1: Eq, T2: Eq> Eq for Tup2<T1, T2>

impl<T1, T2> StructuralPartialEq for Tup2<T1, T2>