[][src]Struct sequoia_openpgp::packet::Iter

pub struct Iter<'a> { /* fields omitted */ }

An iterator over the contents of a packet in depth-first order.

Given a Packet, an Iter iterates over the Packet and any Packets that it contains. For non-container Packets, this just returns a reference to the Packet itself. For container Packets like CompressedData, SEIP, and AED, this walks the Packet hierarchy in depth-first order, and returns the Packets the first time they are visited. (Thus, the packet itself is always returned first.)

This is returned by PacketPile::descendants and Container::descendants.


impl<'a> Iter<'a>[src]

pub fn paths(
) -> impl Iterator<Item = (Vec<usize>, &'a Packet)> + Send + Sync

Extends an Iter to also return each packet's pathspec.

This is similar to enumerate, but instead of counting, this returns each packet's pathspec in addition to a reference to the packet.

See PacketPile::path_ref for an explanation of pathspecs.


use sequoia_openpgp as openpgp;
use openpgp::packet::prelude::*;
use openpgp::PacketPile;

let pp = PacketPile::from(message);
let tags: Vec<(Vec<usize>, Tag)> = pp.descendants().paths()
    .map(|(path, packet)| (path, packet.into()))
              // Root.
              ([0].to_vec(), Tag::CompressedData),
              // Root's first child.
              ([0, 0].to_vec(), Tag::Literal),

Trait Implementations

impl<'a> Default for Iter<'a>[src]

impl<'a> Iterator for Iter<'a>[src]

type Item = &'a Packet

The type of the elements being iterated over.

Auto Trait Implementations

impl<'a> RefUnwindSafe for Iter<'a>

impl<'a> Send for Iter<'a>

impl<'a> Sync for Iter<'a>

impl<'a> Unpin for Iter<'a>

impl<'a> UnwindSafe for Iter<'a>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<I> IntoIterator for I where
    I: Iterator

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.