Add IntoIterator<Item = &Pk> for Descriptor

Author: stevenroose

src/descriptor/bare.rs

@@ -63,6 +63,15 @@ impl<Pk: MiniscriptKey> Bare<Pk> {
     }
 }
 
+impl<'a, Pk: MiniscriptKey> IntoIterator for &'a Bare<Pk> {
+    type Item = &'a Pk;
+    type IntoIter = Box<dyn Iterator<Item = &'a Pk> + 'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.ms.into_iter()
+    }
+}
+
 impl<Pk: MiniscriptKey> fmt::Debug for Bare<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{:?}", self.ms)
@@ -227,6 +236,15 @@ impl<Pk: MiniscriptKey> Pkh<Pk> {
     }
 }
 
+impl<'a, Pk: MiniscriptKey> IntoIterator for &'a Pkh<Pk> {
+    type Item = &'a Pk;
+    type IntoIter = Box<dyn Iterator<Item = &'a Pk> + 'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Box::new(::std::iter::once(&self.pk))
+    }
+}
+
 impl<Pk: MiniscriptKey> fmt::Debug for Pkh<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "pkh({:?})", self.pk)

src/descriptor/mod.rs

@@ -300,6 +300,21 @@ impl<Pk: MiniscriptKey> Descriptor<Pk> {
     }
 }
 
+impl<'a, Pk: MiniscriptKey> IntoIterator for &'a Descriptor<Pk> {
+    type Item = &'a Pk;
+    type IntoIter = Box<dyn Iterator<Item = &'a Pk> + 'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        match *self {
+            Descriptor::Bare(ref bare) => bare.into_iter(),
+            Descriptor::Pkh(ref pk) => pk.into_iter(),
+            Descriptor::Wpkh(ref pk) => pk.into_iter(),
+            Descriptor::Sh(ref sh) => sh.into_iter(),
+            Descriptor::Wsh(ref wsh) => wsh.into_iter(),
+        }
+    }
+}
+
 impl<P: MiniscriptKey, Q: MiniscriptKey> TranslatePk<P, Q> for Descriptor<P> {
     type Output = Descriptor<Q>;
     /// Convert a descriptor using abstract keys to one using specific keys

src/descriptor/segwitv0.rs

@@ -78,6 +78,18 @@ impl<Pk: MiniscriptKey> Wsh<Pk> {
     }
 }
 
+impl<'a, Pk: MiniscriptKey> IntoIterator for &'a Wsh<Pk> {
+    type Item = &'a Pk;
+    type IntoIter = Box<dyn Iterator<Item = &'a Pk> + 'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        match self.inner {
+            WshInner::SortedMulti(ref sm) => sm.into_iter(),
+            WshInner::Ms(ref ms) => ms.into_iter(),
+        }
+    }
+}
+
 /// Wsh Inner
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub enum WshInner<Pk: MiniscriptKey> {
@@ -315,6 +327,15 @@ impl<Pk: MiniscriptKey> Wpkh<Pk> {
     }
 }
 
+impl<'a, Pk: MiniscriptKey> IntoIterator for &'a Wpkh<Pk> {
+    type Item = &'a Pk;
+    type IntoIter = Box<dyn Iterator<Item = &'a Pk> + 'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Box::new(::std::iter::once(&self.pk))
+    }
+}
+
 impl<Pk: MiniscriptKey> fmt::Debug for Wpkh<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "wpkh({:?})", self.pk)

src/descriptor/sh.rs

@@ -193,6 +193,20 @@ impl<Pk: MiniscriptKey> Sh<Pk> {
     }
 }
 
+impl<'a, Pk: MiniscriptKey> IntoIterator for &'a Sh<Pk> {
+    type Item = &'a Pk;
+    type IntoIter = Box<dyn Iterator<Item = &'a Pk> + 'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        match self.inner {
+            ShInner::Wsh(ref wsh) => wsh.into_iter(),
+            ShInner::Wpkh(ref wpkh) => wpkh.into_iter(),
+            ShInner::SortedMulti(ref smv) => smv.into_iter(),
+            ShInner::Ms(ref ms) => ms.into_iter(),
+        }
+    }
+}
+
 impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Sh<Pk> {
     fn sanity_check(&self) -> Result<(), Error> {
         match self.inner {

src/descriptor/sortedmulti.rs

@@ -106,6 +106,15 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
     }
 }
 
+impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> IntoIterator for &'a SortedMultiVec<Pk, Ctx> {
+    type Item = &'a Pk;
+    type IntoIter = Box<dyn Iterator<Item = &'a Pk> + 'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Box::new(self.pks.iter())
+    }
+}
+
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> ForEachKey<Pk> for SortedMultiVec<Pk, Ctx> {
     fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, mut pred: F) -> bool
     where