str range

src/expr.rs

@@ -178,7 +178,7 @@ impl<T> Sections<T> {
         self.payload.is_empty()
     }
 
-    pub fn get(&self, index: u32) -> Option<(Option<&T>, &str)> {
+    fn buf_range(&self, index: u32) -> Option<SmallRange> {
         if self.is_empty() {
             return None;
         }
@@ -188,24 +188,40 @@ impl<T> Sections<T> {
                 .first()
                 .copied()
                 .unwrap_or(self.buf.len() as u32);
-            Some((
-                self.payload[index as usize].as_ref(),
-                &self.buf[..end as usize],
-            ))
+            Some(SmallRange::new(0, end))
         } else {
             let start = *self.additional_offsets.get(index as usize - 1)?;
             let end = self
                 .additional_offsets
                 .get(index as usize)
                 .copied()
                 .unwrap_or(self.buf.len() as u32);
-            Some((
-                self.payload[index as usize].as_ref(),
-                &self.buf[start as usize..end as usize],
-            ))
+            Some(SmallRange::new(start, end))
         }
     }
 
+    pub fn get(&self, index: u32) -> Option<(Option<&T>, &str)> {
+        self.buf_range(index).map(|buf_range| {
+            (
+                self.payload[index as usize].as_ref(),
+                &self.buf[buf_range.into_slice_index()],
+            )
+        })
+    }
+
+    pub fn str_range(&self, range: SmallRange) -> Option<&str> {
+        let end = (range.end == self.len())
+            .then_some(self.buf.len())
+            .or_else(|| {
+                self.buf_range(range.end)
+                    .map(|buf_range| buf_range.end as usize)
+            })?;
+        let start = self
+            .buf_range(range.start)
+            .map(|buf_range| buf_range.start as usize)?;
+        Some(&self.buf[start..end])
+    }
+
     pub fn iter(&self) -> impl Iterator<Item = (Option<&T>, &str)> {
         (0..self.len()).map(|i| self.get(i).unwrap())
     }
@@ -296,6 +312,11 @@ impl<'a, T> Arg<'a, T> {
         self.sections.get(self.range.start + index)
     }
 
+    #[inline]
+    pub fn as_str(&self) -> Option<&'a str> {
+        self.sections.str_range(self.range)
+    }
+
     pub fn iter(&self) -> impl Iterator<Item = (Option<&'a T>, &'a str)> {
         let self_ = *self;
         (0..self.len()).map(move |i| self_.get(i).unwrap())