openpgp: Use predicate Key4::has_secret.

4 files changed, 20 insertions, 20 deletions

diff --git a/openpgp/src/cert/keyiter.rs b/openpgp/src/cert/keyiter.rs
index 6aa3ea3b..d3e94bac 100644
--- a/openpgp/src/cert/keyiter.rs
+++ b/openpgp/src/cert/keyiter.rs
@@ -131,7 +131,7 @@ impl<'a, P: 'a + key::KeyParts> KeyIter<'a, P> {
             }
 
             if let Some(want_secret) = self.secret {
-                if ka.key().secret().is_some() {
+                if ka.key().has_secret() {
                     // We have a secret.
                     if ! want_secret {
                         t!("Have a secret... skipping.");
@@ -636,7 +636,7 @@ impl<'a, P: 'a + key::KeyParts> ValidKeyIter<'a, P> {
             }
 
             if let Some(want_secret) = self.secret {
-                if key.secret().is_some() {
+                if key.has_secret() {
                     // We have a secret.
                     if ! want_secret {
                         t!("Have a secret... skipping.");
@@ -992,7 +992,7 @@ impl<'a, P: 'a + key::KeyParts, R: 'a + key::KeyRole> KeyBundleIter<'a, P, R>
 
 
             if let Some(want_secret) = self.secret {
-                if key.secret().is_some() {
+                if key.has_secret() {
                     // We have a secret.
                     if ! want_secret {
                         t!("Have a secret... skipping.");
diff --git a/openpgp/src/cert/mod.rs b/openpgp/src/cert/mod.rs
index 0feebdec..31fe1dfd 100644
--- a/openpgp/src/cert/mod.rs
+++ b/openpgp/src/cert/mod.rs
@@ -1239,7 +1239,7 @@ impl Cert {
         self.subkeys.sort_and_dedup(Key::public_cmp,
             |a, b| {
                 // Recall: if a and b are equal, a will be dropped.
-                if b.secret().is_none() && a.secret().is_some() {
+                if ! b.has_secret() && a.has_secret() {
                     std::mem::swap(a, b);
                 }
             });
@@ -1319,8 +1319,8 @@ impl Cert {
                 "Primary key mismatch".into()).into());
         }
 
-        if self.primary.key().secret().is_none()
-            && other.primary.key().secret().is_some()
+        if ! self.primary.key().has_secret()
+            && other.primary.key().has_secret()
         {
             std::mem::swap(self.primary.key_mut(), other.primary.key_mut());
         }
@@ -1395,11 +1395,11 @@ impl Cert {
     /// Returns whether at least one of the keys includes a secret
     /// part.
     pub fn is_tsk(&self) -> bool {
-        if self.primary_key().secret().is_some() {
+        if self.primary_key().has_secret() {
             return true;
         }
         self.subkeys().any(|sk| {
-            sk.key().secret().is_some()
+            sk.key().has_secret()
         })
     }
 }
@@ -2632,11 +2632,11 @@ mod test {
         let (tsk, _) = CertBuilder::general_purpose(None, Some("foo@example.com"))
             .generate().unwrap();
         // tsk is now a cert, but it still has its private bits.
-        assert!(tsk.primary.key().secret().is_some());
+        assert!(tsk.primary.key().has_secret());
         assert!(tsk.is_tsk());
         let subkey_count = tsk.subkeys().len();
         assert!(subkey_count > 0);
-        assert!(tsk.subkeys().all(|k| k.key().secret().is_some()));
+        assert!(tsk.subkeys().all(|k| k.key().has_secret()));
 
         // This will write out the tsk as a cert, i.e., without any
         // private bits.
@@ -2645,21 +2645,21 @@ mod test {
 
         // Reading it back in, the private bits have been stripped.
         let cert = Cert::from_bytes(&cert_bytes[..]).unwrap();
-        assert!(cert.primary.key().secret().is_none());
+        assert!(! cert.primary.key().has_secret());
         assert!(!cert.is_tsk());
-        assert!(cert.subkeys().all(|k| k.key().secret().is_none()));
+        assert!(cert.subkeys().all(|k| ! k.key().has_secret()));
 
         let merge1 = cert.clone().merge(tsk.clone()).unwrap();
         assert!(merge1.is_tsk());
-        assert!(merge1.primary.key().secret().is_some());
+        assert!(merge1.primary.key().has_secret());
         assert_eq!(merge1.subkeys().len(), subkey_count);
-        assert!(merge1.subkeys().all(|k| k.key().secret().is_some()));
+        assert!(merge1.subkeys().all(|k| k.key().has_secret()));
 
         let merge2 = tsk.clone().merge(cert.clone()).unwrap();
         assert!(merge2.is_tsk());
-        assert!(merge2.primary.key().secret().is_some());
+        assert!(merge2.primary.key().has_secret());
         assert_eq!(merge2.subkeys().len(), subkey_count);
-        assert!(merge2.subkeys().all(|k| k.key().secret().is_some()));
+        assert!(merge2.subkeys().all(|k| k.key().has_secret()));
     }
 
     #[test]
@@ -3231,14 +3231,14 @@ Pu1xwz57O4zo1VYf6TqHJzVC3OMvMUM2hhdecMUe5x6GorNaj6g=
         let cert_s =
             Cert::from_packet_pile(vec![primary_sec.clone().into()].into())?;
         let cert = cert_p.merge(cert_s)?;
-        assert!(cert.primary_key().secret().is_some());
+        assert!(cert.primary_key().has_secret());
 
         let cert_p =
             Cert::from_packet_pile(vec![primary_pub.clone().into()].into())?;
         let cert_s =
             Cert::from_packet_pile(vec![primary_sec.clone().into()].into())?;
         let cert = cert_s.merge(cert_p)?;
-        assert!(cert.primary_key().secret().is_some());
+        assert!(cert.primary_key().has_secret());
         Ok(())
     }
 
diff --git a/openpgp/src/packet/key/mod.rs b/openpgp/src/packet/key/mod.rs
index 31e46062..ac088594 100644
--- a/openpgp/src/packet/key/mod.rs
+++ b/openpgp/src/packet/key/mod.rs
@@ -1678,7 +1678,7 @@ mod tests {
             if let Some(Packet::PublicKey(Key::V4(ref parsed_key))) =
                 pp.path_ref(&[0])
             {
-                assert!(parsed_key.secret().is_none());
+                assert!(! parsed_key.has_secret());
 
                 key.set_secret(None);
                 assert_eq!(&key.mark_parts_public(), parsed_key);
diff --git a/openpgp/src/serialize/cert.rs b/openpgp/src/serialize/cert.rs
index 11b2341d..d7c94ab7 100644
--- a/openpgp/src/serialize/cert.rs
+++ b/openpgp/src/serialize/cert.rs
@@ -347,7 +347,7 @@ impl<'a> TSK<'a> {
     ///
     /// let cert_ = Cert::from_bytes(&buf)?;
     /// assert_eq!(cert_.keys().with_policy(p, None).alive().revoked(false).secret().count(), 1);
-    /// assert!(cert_.primary_key().secret().is_some());
+    /// assert!(cert_.primary_key().has_secret());
     /// # Ok(()) }
     pub fn set_filter<P>(mut self, predicate: P) -> Self
         where P: 'a + Fn(&'a key::UnspecifiedSecret) -> bool