Change to using a reference to a Haystack

Author: sminez

examples/ad_regex/Cargo.lock

@@ -181,31 +181,31 @@ mod impl_structex {
         }
     }
 
-    impl Haystack<Regex> for &str {
+    impl Haystack<Regex> for str {
         fn is_match_between(&self, re: &Regex, from: usize, to: usize) -> bool {
-            re.matches_between(self, from, to)
+            re.matches_between(&self, from, to)
         }
 
         fn captures_between(&self, re: &Regex, from: usize, to: usize) -> Option<RawCaptures> {
-            let m = re.find_between(self, from, to)?;
+            let m = re.find_between(&self, from, to)?;
 
             Some(RawCaptures::new(m.iter_locs()))
         }
     }
 
-    impl Haystack<Regex> for &GapBuffer {
+    impl Haystack<Regex> for GapBuffer {
         fn is_match_between(&self, re: &Regex, from: usize, to: usize) -> bool {
-            re.matches_between(*self, from, to)
+            re.matches_between(self, from, to)
         }
 
         fn captures_between(&self, re: &Regex, from: usize, to: usize) -> Option<RawCaptures> {
-            let m = re.find_between(*self, from, to)?;
+            let m = re.find_between(self, from, to)?;
 
             Some(RawCaptures::new(m.iter_locs()))
         }
     }
 
-    impl Sliceable for &GapBuffer {
+    impl Sliceable for GapBuffer {
         type Slice<'h>
             = gap_buffer::Slice<'h>
         where
@@ -224,7 +224,7 @@ mod impl_structex {
         }
     }
 
-    impl Writable for &GapBuffer {
+    impl Writable for GapBuffer {
         fn write_to<W>(&self, w: &mut W) -> std::io::Result<usize>
         where
             W: std::io::Write,

examples/ad_regex/src/lib.rs

@@ -226,22 +226,22 @@ mod impl_structex {
     use std::{io::Read, ops::Range};
     use structex::re::{Haystack, RawCaptures, Sliceable, Writable};
 
-    impl<R> Haystack<Regex> for &CachingStream<R>
+    impl<R> Haystack<Regex> for CachingStream<R>
     where
         R: Read,
     {
         fn is_match_between(&self, re: &Regex, from: usize, to: usize) -> bool {
-            re.matches_between(*self, from, to)
+            re.matches_between(self, from, to)
         }
 
         fn captures_between(&self, re: &Regex, from: usize, to: usize) -> Option<RawCaptures> {
-            let m = re.find_between(*self, from, to)?;
+            let m = re.find_between(self, from, to)?;
 
             Some(RawCaptures::new(m.iter_locs()))
         }
     }
 
-    impl<R> Sliceable for &CachingStream<R>
+    impl<R> Sliceable for CachingStream<R>
     where
         R: Read,
     {
@@ -272,7 +272,7 @@ mod impl_structex {
         }
     }
 
-    impl<R> Writable for &CachingStream<R>
+    impl<R> Writable for CachingStream<R>
     where
         R: Read,
     {

examples/ad_regex/src/stream.rs

@@ -58,14 +58,14 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn run_for<H>(
+fn run_for<'h, H>(
     se: &Structex<Regex>,
-    h: H,
+    h: &'h H,
     templates: &HashMap<usize, Template>,
-    after_match: impl Fn(H, &TaggedCaptures<H>),
+    after_match: impl Fn(&'h H, &TaggedCaptures<'h, H>),
 ) -> Result<()>
 where
-    H: Haystack<Regex>,
+    H: Haystack<Regex> + ?Sized,
 {
     for caps in se.iter_tagged_captures(h) {
         let id = caps.id().unwrap();

examples/sgrep/src/main.rs

@@ -64,14 +64,14 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn run_for<H>(
+fn run_for<'h, H>(
     se: &Structex<Regex>,
-    h: H,
+    h: &'h H,
     templates: &HashMap<usize, Template>,
-    after_match: impl Fn(H, &TaggedCaptures<H>),
+    after_match: impl Fn(&'h H, &TaggedCaptures<'h, H>),
 ) -> Result<()>
 where
-    H: Haystack<Regex>,
+    H: Haystack<Regex> + ?Sized,
 {
     let mut pos = 0;
 

examples/ssed/src/main.rs

@@ -55,7 +55,7 @@ where
 }
 
 /// Something that supports extracting a contiguous sub-section between two bytes offsets.
-pub trait Sliceable: Writable + Copy {
+pub trait Sliceable: Writable {
     /// The output of the [slice][Sliceable::slice] method.
     type Slice<'h>: Writable
     where
@@ -75,43 +75,50 @@ pub trait Sliceable: Writable + Copy {
     fn max_len(&self) -> usize;
 }
 
-/// Something that can be written to to a given [io::Write].
-pub trait Writable {
-    /// Writes `self` to the given [io::Write], returning the number of bytes written.
-    fn write_to<W>(&self, w: &mut W) -> io::Result<usize>
-    where
-        W: io::Write;
-}
-
-impl Sliceable for &str {
+impl<T> Sliceable for T
+where
+    T: AsRef<str> + ?Sized,
+{
     type Slice<'h>
         = &'h str
     where
         Self: 'h;
 
     fn char_at(&self, byte_offset: usize) -> Option<char> {
-        if byte_offset >= self.len() {
+        if byte_offset >= self.as_ref().len() {
             return None;
         }
 
-        self[byte_offset..].chars().next()
+        self.as_ref()[byte_offset..].chars().next()
     }
 
     fn slice(&self, range: Range<usize>) -> &str {
-        &self[range]
+        &self.as_ref()[range]
     }
 
     fn max_len(&self) -> usize {
-        self.len()
+        self.as_ref().len()
     }
 }
 
-impl Writable for &str {
+/// Something that can be written to to a given [io::Write].
+pub trait Writable {
+    /// Writes `self` to the given [io::Write], returning the number of bytes written.
+    fn write_to<W>(&self, w: &mut W) -> io::Result<usize>
+    where
+        W: io::Write;
+}
+
+impl<T> Writable for T
+where
+    T: AsRef<str> + ?Sized,
+{
     fn write_to<W>(&self, w: &mut W) -> io::Result<usize>
     where
         W: io::Write,
     {
-        w.write_all(self.as_bytes()).map(|_| self.len())
+        w.write_all(self.as_ref().as_bytes())
+            .map(|_| self.as_ref().len())
     }
 }
 
@@ -154,19 +161,19 @@ impl RawCaptures {
 /// Represents the capture group positions for a single [RegexEngine] match in terms of byte
 /// offsets into the original haystack that the match was run against.
 #[derive(Debug, PartialEq, Eq)]
-pub struct Captures<H>
+pub struct Captures<'h, H>
 where
-    H: Sliceable,
+    H: Sliceable + ?Sized,
 {
-    haystack: H,
+    haystack: &'h H,
     caps: Vec<Option<(usize, usize)>>,
 }
 
-impl<H> Captures<H>
+impl<'h, H> Captures<'h, H>
 where
-    H: Sliceable,
+    H: Sliceable + ?Sized,
 {
-    pub(crate) fn new(haystack: H, caps: Vec<Option<(usize, usize)>>) -> Self {
+    pub(crate) fn new(haystack: &'h H, caps: Vec<Option<(usize, usize)>>) -> Self {
         Self { haystack, caps }
     }
 
@@ -241,7 +248,7 @@ mod impl_for_regex {
         }
     }
 
-    impl Haystack<Regex> for &str {
+    impl Haystack<Regex> for str {
         fn is_match_between(&self, re: &Regex, from: usize, to: usize) -> bool {
             re.is_match(&self[from..to])
         }

src/re.rs

@@ -43,30 +43,30 @@ impl Extract {
     }
 }
 
-pub(super) struct Iter<'s, R, H>
+pub(super) struct Iter<'s, 'h, R, H>
 where
     R: RegexEngine,
-    H: Haystack<R>,
+    H: Haystack<R> + ?Sized,
 {
-    haystack: H,
+    haystack: &'h H,
     ext: &'s Extract,
     inner: Arc<Inner<R>>,
     /// The original parent dot we are extracting from
     parent: Dot,
     /// The child branch we are currently iterating over
-    child: Option<Box<MatchesInner<'s, R, H>>>,
+    child: Option<Box<MatchesInner<'s, 'h, R, H>>>,
     /// The current match
     held: Option<RawCaptures>,
     /// The current byte offset we are up to
     pos: usize,
 }
 
-impl<'s, R, H> Iter<'s, R, H>
+impl<'s, 'h, R, H> Iter<'s, 'h, R, H>
 where
     R: RegexEngine,
-    H: Haystack<R>,
+    H: Haystack<R> + ?Sized,
 {
-    pub fn new(haystack: H, parent: Dot, ext: &'s Extract, inner: Arc<Inner<R>>) -> Self {
+    pub fn new(haystack: &'h H, parent: Dot, ext: &'s Extract, inner: Arc<Inner<R>>) -> Self {
         let pos = parent.from();
 
         Self {
@@ -98,12 +98,12 @@ where
     }
 }
 
-impl<'s, R, H> Iterator for Iter<'s, R, H>
+impl<'s, 'h, R, H> Iterator for Iter<'s, 'h, R, H>
 where
     R: RegexEngine,
-    H: Haystack<R>,
+    H: Haystack<R> + ?Sized,
 {
-    type Item = TaggedCaptures<H>;
+    type Item = TaggedCaptures<'h, H>;
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {

src/se/extract.rs

@@ -42,15 +42,15 @@ impl Guard {
         Some(self)
     }
 
-    pub(super) fn apply<'s, R, H>(
+    pub(super) fn apply<'s, 'h, R, H>(
         &'s self,
-        haystack: H,
+        haystack: &'h H,
         dot: Dot,
         inner: Arc<Inner<R>>,
-    ) -> Option<MatchesInner<'s, R, H>>
+    ) -> Option<MatchesInner<'s, 'h, R, H>>
     where
         R: RegexEngine,
-        H: Haystack<R>,
+        H: Haystack<R> + ?Sized,
     {
         let (from, to) = dot.loc();
         let is_match = haystack.is_match_between(&inner.re[self.re], from, to);