Struct mit_commit::Trailers

pub struct Trailers<'a> { /* private fields */ }

A Collection of Trailer

Implementations

impl<'a> Trailers<'a>

pub fn iter(&self) -> Iter<'_, Trailer<'_>>

Iterate over the Trailers

Examples

use mit_commit::{Trailer, Trailers};
let trailers = Trailers::from(vec![
    Trailer::new(
        "Co-authored-by".into(),
        "Billie Thompson <billie@example.com>".into(),
    ),
    Trailer::new(
        "Co-authored-by".into(),
        "Someone Else <someone@example.com>".into(),
    ),
    Trailer::new("Relates-to".into(), "#124".into()),
]);
let mut iterator = trailers.iter();

assert_eq!(
    iterator.next(),
    Some(&Trailer::new(
        "Co-authored-by".into(),
        "Billie Thompson <billie@example.com>".into()
    ))
);
assert_eq!(
    iterator.next(),
    Some(&Trailer::new(
        "Co-authored-by".into(),
        "Someone Else <someone@example.com>".into()
    ))
);
assert_eq!(
    iterator.next(),
    Some(&Trailer::new("Relates-to".into(), "#124".into()))
);
assert_eq!(iterator.next(), None);

pub fn len(&self) -> usize

How many Trailers are there

Examples

use mit_commit::{Trailer, Trailers};
let trailers = Trailers::from(vec![
    Trailer::new(
        "Co-authored-by".into(),
        "Billie Thompson <billie@example.com>".into(),
    ),
    Trailer::new(
        "Co-authored-by".into(),
        "Someone Else <someone@example.com>".into(),
    ),
]);

assert_eq!(trailers.len(), 2)

pub fn is_empty(&self) -> bool

Are there no Trailers

Examples

use mit_commit::{Trailer, Trailers};
assert_eq!(
    Trailers::from(vec![
        Trailer::new(
            "Co-authored-by".into(),
            "Billie Thompson <billie@example.com>".into()
        ),
        Trailer::new(
            "Co-authored-by".into(),
            "Someone Else <someone@example.com>".into()
        ),
    ])
    .is_empty(),
    false
);

let trailers: Vec<Trailer> = Vec::new();
assert_eq!(Trailers::from(trailers).is_empty(), true)

Trait Implementations

impl<'a> Clone for Trailers<'a>

fn clone(&self) -> Trailers<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Trailers<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Trailers<'a>

fn default() -> Trailers<'a>

Returns the “default value” for a type.

impl<'a> From<Trailers<'a>> for String

fn from(trailers: Trailers<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<Vec<Fragment<'a>, Global>> for Trailers<'a>

fn from(ast: Vec<Fragment<'a>>) -> Self

Converts to this type from the input type.

impl<'a> From<Vec<Trailer<'a>, Global>> for Trailers<'a>

fn from(trailers: Vec<Trailer<'a>>) -> Self

Converts to this type from the input type.

impl<'a> IntoIterator for Trailers<'a>

fn into_iter(self) -> Self::IntoIter

Iterate over the Trailers

Examples

use mit_commit::{Trailer, Trailers};
let trailers = Trailers::from(vec![
    Trailer::new(
        "Co-authored-by".into(),
        "Billie Thompson <billie@example.com>".into(),
    ),
    Trailer::new(
        "Co-authored-by".into(),
        "Someone Else <someone@example.com>".into(),
    ),
    Trailer::new("Relates-to".into(), "#124".into()),
]);
let mut iterator = trailers.into_iter();

assert_eq!(
    iterator.next(),
    Some(Trailer::new(
        "Co-authored-by".into(),
        "Billie Thompson <billie@example.com>".into()
    ))
);
assert_eq!(
    iterator.next(),
    Some(Trailer::new(
        "Co-authored-by".into(),
        "Someone Else <someone@example.com>".into()
    ))
);
assert_eq!(
    iterator.next(),
    Some(Trailer::new("Relates-to".into(), "#124".into()))
);
assert_eq!(iterator.next(), None);

type IntoIter = IntoIter<Trailer<'a>, Global>

Which kind of iterator are we turning this into?

type Item = Trailer<'a>

The type of the elements being iterated over.

impl<'a> PartialEq<Trailers<'a>> for Trailers<'a>

fn eq(&self, other: &Trailers<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for Trailers<'a>

impl<'a> StructuralEq for Trailers<'a>

impl<'a> StructuralPartialEq for Trailers<'a>