Struct mail_headers::header_components::MessageIdList

pub struct MessageIdList(pub Vec1<MessageId>);

Methods from Deref<Target = Vec1<MessageId>>

pub fn mapped_ref<F, N>(&self, map_fn: F) -> Vec1<N> where
    F: FnMut(&T) -> N, 

Create a new Vec1 by mapping references to the elements of self.

The benefit to this compared to Iterator::map is that it's known that the length will still be at least 1 when creating the new Vec1.

pub fn mapped_mut<F, N>(&mut self, map_fn: F) -> Vec1<N> where
    F: FnMut(&mut T) -> N, 

Create a new Vec1 by mapping mutable references to the elements of self.

The benefit to this compared to Iterator::map is that it's known that the length will still be at least 1 when creating the new Vec1.

pub fn try_mapped_ref<F, N, E>(&self, map_fn: F) -> Result<Vec1<N>, E> where
    F: FnMut(&T) -> Result<N, E>, 

Create a new Vec1 by mapping references to the elements of self to Results.

The benefit to this compared to Iterator::map is that it's known that the length will still be at least 1 when creating the new Vec1.

pub fn try_mapped_mut<F, N, E>(&mut self, map_fn: F) -> Result<Vec1<N>, E> where
    F: FnMut(&mut T) -> Result<N, E>, 

Create a new Vec1 by mapping mutable references to the elements of self to Results.

The benefit to this compared to Iterator::map is that it's known that the length will still be at least 1 when creating the new Vec1.

pub fn last(&self) -> &T

Returns a reference to the last element.

As Vec1 always contains at least one element there is always a last element.

pub fn last_mut(&mut self) -> &mut T

Returns a mutable reference to the last element.

As Vec1 always contains at least one element there is always a last element.

pub fn first(&self) -> &T

Returns a reference to the first element.

As Vec1 always contains at least one element there is always a first element.

pub fn first_mut(&mut self) -> &mut T

Returns a mutable reference to the first element.

As Vec1 always contains at least one element there is always a first element.

pub fn try_truncate(&mut self, len: usize) -> Result<(), Size0Error>

pub fn try_swap_remove(&mut self, index: usize) -> Result<T, Size0Error>

pub fn try_remove(&mut self, index: usize) -> Result<T, Size0Error>

pub fn try_split_off(&mut self, at: usize) -> Result<Vec1<T>, Size0Error>

pub fn dedup_by_key<F, K>(&mut self, key: F) where
    F: FnMut(&mut T) -> K,
    K: PartialEq<K>, 

pub fn dedup_by<F>(&mut self, same_bucket: F) where
    F: FnMut(&mut T, &mut T) -> bool, 

pub fn try_pop(&mut self) -> Result<T, Size0Error>

Tries to remove the last element from the Vec1.

Returns an error if the length is currently 1 (so the try_pop would reduce the length to 0).

pub fn as_vec(&self) -> &Vec<T>

pub fn splice<R, I>(
    &mut self,
    range: R,
    replace_with: I
) -> Result<Splice<<I as IntoIterator>::IntoIter>, Size0Error> where
    I: IntoIterator<Item = T>,
    R: RangeBounds<usize>, 

pub fn to_ascii_uppercase(&self) -> Vec1<u8>

Works like &[u8].to_ascii_uppercase() but returns a Vec1<T> instead of a Vec<T>

pub fn to_ascii_lowercase(&self) -> Vec1<u8>

Works like &[u8].to_ascii_lowercase() but returns a Vec1<T> instead of a Vec<T>

pub fn try_resize(&mut self, new_len: usize, value: T) -> Result<(), Size0Error>

pub fn extend_from_slice(&mut self, other: &[T])

pub fn dedub(&mut self)

pub fn dedup(&mut self)

pub fn reserve(&mut self, additional: usize)

pub fn reserve_exact(&mut self, additional: usize)

pub fn shrink_to_fit(&mut self)

pub fn as_mut_slice(&mut self) -> &mut [T]

pub fn push(&mut self, value: T)

pub fn append(&mut self, other: &mut Vec<T>)

pub fn insert(&mut self, idx: usize, val: T)

pub fn len(&self) -> usize

pub fn capacity(&self) -> usize

pub fn as_slice(&self) -> &[T]

Trait Implementations

impl Clone for MessageIdList

fn clone(&self) -> MessageIdList

Returns a copy of the value.

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

Performs copy-assignment from source.

impl DerefMut for MessageIdList

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Debug for MessageIdList

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Deref for MessageIdList

type Target = Vec1<MessageId>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Serialize for MessageIdList

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

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for MessageIdList

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl EncodableInHeader for MessageIdList

fn encode(&self, handle: &mut EncodingWriter) -> Result<(), EncodingError>

fn boxed_clone(&self) -> Box<dyn EncodableInHeader>