Struct sequoia_openpgp::cert::CertParser [−][src]
pub struct CertParser<'a> { /* fields omitted */ }
An iterator over a sequence of certificates, i.e., an OpenPGP keyring.
The source of packets is a fallible iterator over Packet
s. In
this way, it is possible to propagate parse errors.
A CertParser
returns each TPK
or TSK
that it encounters.
Its behavior can be modeled using a simple state machine.
In the first and initial state, it looks for the start of a
certificate, a Public Key
packet or a Secret Key
packet.
When it encounters such a packet it buffers it, and transitions to
the second state. Any other packet or an error causes it to emit
an error and stay in the same state. When the source of packets
is exhausted, it enters the End
state.
In the second state, it looks for packets that belong to a
certificate’s body. If it encounters a valid body packet, then it
buffers it and stays in the same state. If it encounters the
start of a certificate, then it emits the buffered certificate,
buffers the packet, and stays in the same state. If it encounters
an invalid packet (e.g., a Literal Data
packet), it emits two
items, the buffered certificate, and an error, and then it
transitions back to the initial state. When the source of packets
is exhausted, it emits the buffered certificate and enters the end
state.
In the end state, it emits None
.
Invalid Packet / Error
,------------------------.
v |
Not a +---------+ +---------+
Start .-> | Looking | -------------> | Looking | <-. Cert
of Cert | | for | Start | for | | Body
Packet | | Start | of Cert | Cert | | Packet
/ Error `-- | of Cert | Packet | Body | --'
+---------+ .-> +---------+
| | | |
| `------' |
| Start of Cert Packet |
| |
EOF | +-----+ | EOF
`------> | End | <---------'
+-----+
| ^
`--'
The parser does not recurse into containers, thus when it
encounters a container like a Compressed Data
Packet, it will
return an error even if the container contains a valid
certificate.
The parser considers unknown packets to be valid body packets.
(In a Cert
, these show up as Unknown
components.) The
goal is to provide some future compatibility.
Examples
Print information about all certificates in a keyring:
use sequoia_openpgp as openpgp; use openpgp::parse::Parse; use openpgp::parse::PacketParser; use openpgp::cert::prelude::*; let ppr = PacketParser::from_bytes(&keyring)?; for certo in CertParser::from(ppr) { match certo { Ok(cert) => { println!("Key: {}", cert.fingerprint()); for ua in cert.userids() { println!(" User ID: {}", ua.userid()); } } Err(err) => { eprintln!("Error reading keyring: {}", err); } } }
When an invalid packet is encountered, an error is returned and parsing continues:
use sequoia_openpgp as openpgp; use openpgp::cert::prelude::*; use openpgp::packet::prelude::*; use openpgp::types::DataFormat; let mut lit = Literal::new(DataFormat::Text); lit.set_body(b"test".to_vec()); let (alice, _) = CertBuilder::general_purpose(None, Some("alice@example.org")) .generate()?; let (bob, _) = CertBuilder::general_purpose(None, Some("bob@example.org")) .generate()?; let mut packets : Vec<Packet> = Vec::new(); packets.extend(alice.clone()); packets.push(lit.clone().into()); packets.push(lit.clone().into()); packets.extend(bob.clone()); let r : Vec<Result<Cert>> = CertParser::from(packets).collect(); assert_eq!(r.len(), 4); assert_eq!(r[0].as_ref().unwrap().fingerprint(), alice.fingerprint()); assert!(r[1].is_err()); assert!(r[2].is_err()); assert_eq!(r[3].as_ref().unwrap().fingerprint(), bob.fingerprint());
Implementations
impl<'a> CertParser<'a>
[src]
impl<'a> CertParser<'a>
[src]pub fn from_iter<I, J>(iter: I) -> Self where
I: 'a + IntoIterator<Item = J>,
J: 'a + Into<Result<Packet>>,
<I as IntoIterator>::IntoIter: Send + Sync,
[src]
pub fn from_iter<I, J>(iter: I) -> Self where
I: 'a + IntoIterator<Item = J>,
J: 'a + Into<Result<Packet>>,
<I as IntoIterator>::IntoIter: Send + Sync,
[src]Creates a CertParser
from a Result<Packet>
iterator.
Note: because we implement From<Packet>
for
Result<Packet>
, it is possible to pass in an iterator over
Packet
s.
Examples
From a Vec<Packet>
:
use sequoia_openpgp as openpgp; use openpgp::cert::prelude::*; use openpgp::packet::prelude::*; for certo in CertParser::from_iter(packets) { match certo { Ok(cert) => { println!("Key: {}", cert.fingerprint()); for ua in cert.userids() { println!(" User ID: {}", ua.userid()); } } Err(err) => { eprintln!("Error reading keyring: {}", err); } } }
pub fn unvalidated_cert_filter<F: 'a>(self, filter: F) -> Self where
F: Send + Sync + Fn(&Cert, bool) -> bool,
[src]
pub fn unvalidated_cert_filter<F: 'a>(self, filter: F) -> Self where
F: Send + Sync + Fn(&Cert, bool) -> bool,
[src]Filters the Certs prior to validation.
By default, the CertParser
only returns valdiated Cert
s.
Checking that a certificate’s self-signatures are valid,
however, is computationally expensive, and not always
necessary. For example, when looking for a small number of
certificates in a large keyring, most certificates can be
immediately discarded. That is, it is more efficient to
filter, validate, and double check, than to validate and
filter. (It is necessary to double check, because the check
might have been on an invalid part. For example, if searching
for a key with a particular Key ID, a matching key might not
have any self signatures.)
If the CertParser
gave out unvalidated Cert
s, and provided
an interface to validate them, then the caller could implement
this check-validate-double-check pattern. Giving out
unvalidated Cert
s, however, is dangerous: inevitably, a
Cert
will be used without having been validated in a context
where it should have been.
This function avoids this class of bugs while still providing
a mechanism to filter Cert
s prior to validation: the caller
provides a callback that is invoked on the unvalidated
Cert
. If the callback returns true
, then the parser
validates the Cert
, and invokes the callback a second time
to make sure the Cert
is really wanted. If the callback
returns false, then the Cert
is skipped.
Note: calling this function multiple times on a single
CertParser
will not replace the existing filter, but install
multiple filters.
Examples
use sequoia_openpgp as openpgp; use openpgp::cert::prelude::*; for certr in CertParser::from(ppr) .unvalidated_cert_filter(|cert, _| { for component in cert.keys() { if component.key().keyid() == some_keyid { return true; } } false }) { match certr { Ok(cert) => { // The Cert contains the subkey. } Err(err) => { eprintln!("Error reading keyring: {}", err); } } }
Trait Implementations
impl<'a> Default for CertParser<'a>
[src]
impl<'a> Default for CertParser<'a>
[src]impl<'a> From<PacketParserResult<'a>> for CertParser<'a>
[src]
impl<'a> From<PacketParserResult<'a>> for CertParser<'a>
[src]fn from(ppr: PacketParserResult<'a>) -> Self
[src]
fn from(ppr: PacketParserResult<'a>) -> Self
[src]Initializes a CertParser
from a PacketParser
.
impl<'a> From<Vec<Packet, Global>> for CertParser<'a>
[src]
impl<'a> From<Vec<Packet, Global>> for CertParser<'a>
[src]fn from(p: Vec<Packet>) -> CertParser<'a>ⓘNotable traits for CertParser<'a>
impl<'a> Iterator for CertParser<'a> type Item = Result<Cert>;
[src]
fn from(p: Vec<Packet>) -> CertParser<'a>ⓘNotable traits for CertParser<'a>
impl<'a> Iterator for CertParser<'a> type Item = Result<Cert>;
[src]Performs the conversion.
impl<'a> From<Vec<Result<Packet, Error>, Global>> for CertParser<'a>
[src]
impl<'a> From<Vec<Result<Packet, Error>, Global>> for CertParser<'a>
[src]fn from(p: Vec<Result<Packet>>) -> CertParser<'a>ⓘNotable traits for CertParser<'a>
impl<'a> Iterator for CertParser<'a> type Item = Result<Cert>;
[src]
fn from(p: Vec<Result<Packet>>) -> CertParser<'a>ⓘNotable traits for CertParser<'a>
impl<'a> Iterator for CertParser<'a> type Item = Result<Cert>;
[src]Performs the conversion.
impl<'a> Iterator for CertParser<'a>
[src]
impl<'a> Iterator for CertParser<'a>
[src]fn next(&mut self) -> Option<Self::Item>
[src]
fn next(&mut self) -> Option<Self::Item>
[src]Advances the iterator and returns the next value. Read more
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0[src]
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0[src]Returns the bounds on the remaining length of the iterator. Read more
fn count(self) -> usize
1.0.0[src]
fn count(self) -> usize
1.0.0[src]Consumes the iterator, counting the number of iterations and returning it. Read more
fn last(self) -> Option<Self::Item>
1.0.0[src]
fn last(self) -> Option<Self::Item>
1.0.0[src]Consumes the iterator, returning the last element. Read more
fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]
fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]🔬 This is a nightly-only experimental API. (iter_advance_by
)
recently added
Advances the iterator by n
elements. Read more
fn nth(&mut self, n: usize) -> Option<Self::Item>
1.0.0[src]
fn nth(&mut self, n: usize) -> Option<Self::Item>
1.0.0[src]Returns the n
th element of the iterator. Read more
fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]
fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]Creates an iterator starting at the same point, but stepping by the given amount at each iteration. Read more
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
1.0.0[src]
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
1.0.0[src]Takes two iterators and creates a new iterator over both in sequence. Read more
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]‘Zips up’ two iterators into a single iterator of pairs. Read more
fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
fn intersperse(self, separator: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]🔬 This is a nightly-only experimental API. (iter_intersperse
)
recently added
Creates a new iterator which places a copy of separator
between adjacent
items of the original iterator. Read more
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
[src]
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> where
G: FnMut() -> Self::Item,
[src]🔬 This is a nightly-only experimental API. (iter_intersperse
)
recently added
Creates a new iterator which places an item generated by separator
between adjacent items of the original iterator. Read more
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[src]
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[src]Takes a closure and creates an iterator which calls that closure on each element. Read more
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]Calls a closure on each element of an iterator. Read more
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]Creates an iterator which uses a closure to determine if an element should be yielded. Read more
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
1.0.0[src]
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
1.0.0[src]Creates an iterator that both filters and maps. Read more
fn enumerate(self) -> Enumerate<Self>
1.0.0[src]
fn enumerate(self) -> Enumerate<Self>
1.0.0[src]Creates an iterator which gives the current iteration count as well as the next value. Read more
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]Creates an iterator that yields elements based on a predicate. Read more
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]🔬 This is a nightly-only experimental API. (iter_map_while
)
recently added
Creates an iterator that both yields elements based on a predicate and maps. Read more
fn skip(self, n: usize) -> Skip<Self>
1.0.0[src]
fn skip(self, n: usize) -> Skip<Self>
1.0.0[src]Creates an iterator that skips the first n
elements. Read more
fn take(self, n: usize) -> Take<Self>
1.0.0[src]
fn take(self, n: usize) -> Take<Self>
1.0.0[src]Creates an iterator that yields the first n
elements, or fewer
if the underlying iterator ends sooner. Read more
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0[src]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0[src]fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
1.0.0[src]
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
1.0.0[src]Creates an iterator that works like map, but flattens nested structure. Read more
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]Creates an iterator that flattens nested structure. Read more
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]Does something with each element of an iterator, passing the value on. Read more
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
1.0.0[src]
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
1.0.0[src]Transforms an iterator into a collection. Read more
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
1.0.0[src]Consumes an iterator, creating two collections from it. Read more
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
P: FnMut(&T) -> bool,
[src]
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
P: FnMut(&T) -> bool,
[src]🔬 This is a nightly-only experimental API. (iter_partition_in_place
)
new API
Reorders the elements of this iterator in-place according to the given predicate,
such that all those that return true
precede all those that return false
.
Returns the number of true
elements found. Read more
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]🔬 This is a nightly-only experimental API. (iter_is_partitioned
)
new API
Checks if the elements of this iterator are partitioned according to the given predicate,
such that all those that return true
precede all those that return false
. Read more
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
R: Try<Ok = B>,
F: FnMut(B, Self::Item) -> R,
1.27.0[src]
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
R: Try<Ok = B>,
F: FnMut(B, Self::Item) -> R,
1.27.0[src]An iterator method that applies a function as long as it returns successfully, producing a single, final value. Read more
fn try_for_each<F, R>(&mut self, f: F) -> R where
R: Try<Ok = ()>,
F: FnMut(Self::Item) -> R,
1.27.0[src]
fn try_for_each<F, R>(&mut self, f: F) -> R where
R: Try<Ok = ()>,
F: FnMut(Self::Item) -> R,
1.27.0[src]An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error. Read more
fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
1.0.0[src]
fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
1.0.0[src]Folds every element into an accumulator by applying an operation, returning the final result. Read more
fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]
fn reduce<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]Reduces the elements to a single one, by repeatedly applying a reducing operation. Read more
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]Tests if every element of the iterator matches a predicate. Read more
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]Tests if any element of the iterator matches a predicate. Read more
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]Searches for an element of an iterator that satisfies a predicate. Read more
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]Applies function to the elements of iterator and returns the first non-none result. Read more
fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
R: Try<Ok = bool>,
F: FnMut(&Self::Item) -> R,
[src]
fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
R: Try<Ok = bool>,
F: FnMut(&Self::Item) -> R,
[src]🔬 This is a nightly-only experimental API. (try_find
)
new API
Applies function to the elements of iterator and returns the first true result or the first error. Read more
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
1.0.0[src]
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
1.0.0[src]Searches for an element in an iterator, returning its index. Read more
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
1.0.0[src]
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
1.0.0[src]Searches for an element in an iterator from the right, returning its index. Read more
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]Returns the maximum element of an iterator. Read more
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]Returns the minimum element of an iterator. Read more
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]Returns the element that gives the maximum value from the specified function. Read more
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]Returns the element that gives the maximum value with respect to the specified comparison function. Read more
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.6.0[src]Returns the element that gives the minimum value from the specified function. Read more
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]Returns the element that gives the minimum value with respect to the specified comparison function. Read more
fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
1.0.0[src]
fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
1.0.0[src]Reverses an iterator’s direction. Read more
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
1.0.0[src]
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
1.0.0[src]Converts an iterator of pairs into a pair of containers. Read more
fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]
fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]Creates an iterator which copies all of its elements. Read more
fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
1.0.0[src]
fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
1.0.0[src]fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]Sums the elements of an iterator. Read more
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]Iterates over the entire iterator, multiplying all the elements Read more
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]Lexicographically compares the elements of this Iterator
with those
of another. Read more
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
[src]
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
[src]iter_order_by
)Lexicographically compares the elements of this Iterator
with those
of another with respect to the specified comparison function. Read more
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Lexicographically compares the elements of this Iterator
with those
of another. Read more
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
[src]
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
[src]iter_order_by
)Lexicographically compares the elements of this Iterator
with those
of another with respect to the specified comparison function. Read more
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]fn eq_by<I, F>(self, other: I, eq: F) -> bool where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
[src]
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
[src]iter_order_by
)fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
less than those of another. Read more
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
less or equal to those of another. Read more
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
greater than those of another. Read more
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]Determines if the elements of this Iterator
are lexicographically
greater than or equal to those of another. Read more
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted. Read more
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted using the given comparator function. Read more
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
K: PartialOrd<K>,
F: FnMut(Self::Item) -> K,
[src]
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
K: PartialOrd<K>,
F: FnMut(Self::Item) -> K,
[src]🔬 This is a nightly-only experimental API. (is_sorted
)
new API
Checks if the elements of this iterator are sorted using the given key extraction function. Read more
impl<'a> Parse<'a, CertParser<'a>> for CertParser<'a>
[src]
impl<'a> Parse<'a, CertParser<'a>> for CertParser<'a>
[src]Auto Trait Implementations
impl<'a> !RefUnwindSafe for CertParser<'a>
impl<'a> Send for CertParser<'a>
impl<'a> Sync for CertParser<'a>
impl<'a> Unpin for CertParser<'a>
impl<'a> !UnwindSafe for CertParser<'a>
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<I> IntoIterator for I where
I: Iterator,
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]impl<T> Same<T> for T
impl<T> Same<T> for T
type Output = T
type Output = T
Should always be Self