Struct `VarTupleULE`

struct VarTupleULE<A: AsULE, V: VarULE + ?Sized> { ... }

A dynamically-sized type combining a sized and an unsized type.

See the module for examples.

Fields

sized: <A as >::ULE
variable: V

Implementations

`impl<A, V> Freeze for VarTupleULE<A, V>`

`impl<A, V> RefUnwindSafe for VarTupleULE<A, V>`

`impl<A, V> Send for VarTupleULE<A, V>`

`impl<A, V> Sync for VarTupleULE<A, V>`

`impl<A, V> ToOwned for VarTupleULE<A, V>`

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

`impl<A, V> Unpin for VarTupleULE<A, V>`

`impl<A, V> UnsafeUnpin for VarTupleULE<A, V>`

`impl<A, V> UnwindSafe for VarTupleULE<A, V>`

`impl<A, V> VarULE for VarTupleULE<A, V>`

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

`impl<A: $crate::cmp::Eq + AsULE, V: $crate::cmp::Eq + VarULE + ?Sized> Eq for VarTupleULE<A, V>`

`impl<A: $crate::cmp::Ord + AsULE, V: $crate::cmp::Ord + VarULE + ?Sized> Ord for VarTupleULE<A, V>`

fn cmp(self: &Self, other: &VarTupleULE<A, V>) -> Ordering

`impl<A: $crate::cmp::PartialEq + AsULE, V: $crate::cmp::PartialEq + VarULE + ?Sized> PartialEq for VarTupleULE<A, V>`

fn eq(self: &Self, other: &VarTupleULE<A, V>) -> bool

`impl<A: $crate::cmp::PartialOrd + AsULE, V: $crate::cmp::PartialOrd + VarULE + ?Sized> PartialOrd for VarTupleULE<A, V>`

fn partial_cmp(self: &Self, other: &VarTupleULE<A, V>) -> Option<Ordering>

`impl<A: $crate::fmt::Debug + AsULE, V: $crate::fmt::Debug + VarULE + ?Sized> Debug for VarTupleULE<A, V>`

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

`impl<A: AsULE, V: VarULE + ?Sized> StructuralPartialEq for VarTupleULE<A, V>`

`impl<T> Any for VarTupleULE<A, V>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for VarTupleULE<A, V>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for VarTupleULE<A, V>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> EncodeAsVarULE for VarTupleULE<A, V>`

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

`impl<T> ErasedDestructor for VarTupleULE<A, V>`

`impl<T> From for VarTupleULE<A, V>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for VarTupleULE<A, V>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for VarTupleULE<A, V>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for VarTupleULE<A, V>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>