Struct Tuple2VarULE 

pub struct Tuple2VarULE<A: ?Sized, B: ?Sized, Format: VarZeroVecFormat = Index16> { /* private fields */ }

VarULE type for tuples with 2 elements. See module docs for more information

Implementations

impl<A: VarULE + ?Sized, B: VarULE + ?Sized, Format: VarZeroVecFormat> Tuple2VarULE<A, B, Format>

pub fn a(&self) -> &A

Get field 0of this tuple

pub fn b(&self) -> &B

Get field 1of this tuple

Trait Implementations

impl<A: Debug + VarULE + ?Sized, B: Debug + VarULE + ?Sized, Format: VarZeroVecFormat> Debug for Tuple2VarULE<A, B, Format>

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

Formats the value using the given formatter.

impl<A, B, AE, BE, Format> EncodeAsVarULE<Tuple2VarULE<A, B, Format>> for (AE, BE)

where A: VarULE + ?Sized, B: VarULE + ?Sized, AE: EncodeAsVarULE<A>, BE: EncodeAsVarULE<B>, Format: VarZeroVecFormat,

fn encode_var_ule_as_slices<R>(&self, _: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated produce the memory pattern of the corresponding instance of T.

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding VarULE type

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding VarULE type to the dst buffer. dst should be the size of Self::encode_var_ule_len()

impl<A: Ord + VarULE + ?Sized, B: Ord + VarULE + ?Sized, Format: VarZeroVecFormat> Ord for Tuple2VarULE<A, B, Format>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

impl<A: PartialEq + VarULE + ?Sized, B: PartialEq + VarULE + ?Sized, Format: VarZeroVecFormat> PartialEq for Tuple2VarULE<A, B, Format>

fn eq(&self, other: &Self) -> 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<A: PartialOrd + VarULE + ?Sized, B: PartialOrd + VarULE + ?Sized, Format: VarZeroVecFormat> PartialOrd for Tuple2VarULE<A, B, Format>

fn partial_cmp(&self, other: &Self) -> 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<A: VarULE + ?Sized, B: VarULE + ?Sized, Format: VarZeroVecFormat> ToOwned for Tuple2VarULE<A, B, Format>

type Owned = Box<Tuple2VarULE<A, B, Format>>

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

Uses borrowed data to replace owned data, usually by cloning.

impl<A: VarULE + ?Sized, B: VarULE + ?Sized, Format: VarZeroVecFormat> VarULE for Tuple2VarULE<A, B, Format>

fn validate_bytes(bytes: &[u8]) -> Result<(), UleError>

Validates a byte slice, &[u8].

unsafe fn from_bytes_unchecked(bytes: &[u8]) -> &Self

Takes a byte slice, &[u8], and return it as &Self with the same lifetime, assuming that this byte slice has previously been run through Self::parse_bytes() with success.

fn parse_bytes(bytes: &[u8]) -> Result<&Self, UleError>

Parses a byte slice, &[u8], and return it as &Self with the same lifetime.

fn as_bytes(&self) -> &[u8]

Given &Self, returns a &[u8] with the same lifetime.

fn to_boxed(&self) -> Box<Self>

Allocate on the heap as a Box<T>

impl<'a, A, B, AE, BE, Format> ZeroFrom<'a, Tuple2VarULE<A, B, Format>> for (AE, BE)

where A: VarULE + ?Sized, B: VarULE + ?Sized, AE: ZeroFrom<'a, A>, BE: ZeroFrom<'a, B>, Format: VarZeroVecFormat,

fn zero_from(other: &'a Tuple2VarULE<A, B, Format>) -> Self

Clone the other C into a struct that may retain references into C.

impl<A: Eq + VarULE + ?Sized, B: Eq + VarULE + ?Sized, Format: VarZeroVecFormat> Eq for Tuple2VarULE<A, B, Format>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: (unsized)