use bstr::{BStr, BString, ByteSlice};use std::borrow::Cow; mod error {    use bstr::BString;    use quick_error::quick_error;     quick_error! {        #[derive(Debug)]        pub enum Error {            PatternNegation { line_number: usize, line: BString } {                display("Line {} has a negative pattern, for literal characters use \\!: {}", line_number, line)            }        }    }}use crate::ignore;pub use error::Error; pub struct Lines<'a> {    lines: bstr::Lines<'a>,    line_no: usize,} pub struct Iter<'a> {    attrs: bstr::Split<'a>,} impl<'a> Iter<'a> {    pub fn new(attrs: &'a [u8]) -> Self {        Iter {            attrs: attrs.as_bstr().split_str(b" "),        }    }} impl<'a> Iterator for Iter<'a> {    type Item = Result<(&'a BStr, crate::State<'a>), Error>;     fn next(&mut self) -> Option<Self::Item> {        let _attr = self.attrs.next().filter(|a| !a.is_empty())?;        todo!("parse attribute")    }} impl<'a> Lines<'a> {    pub fn new(buf: &'a [u8]) -> Self {        let bom = unicode_bom::Bom::from(buf);        Lines {            lines: buf[bom.len()..].lines(),            line_no: 0,        }    }} impl<'a> Iterator for Lines<'a> {    type Item = Result<(BString, crate::ignore::pattern::Mode, Iter<'a>, usize), Error>;     fn next(&mut self) -> Option<Self::Item> {        for line in self.lines.by_ref() {            self.line_no += 1;            match parse_line(line) {                None => continue,                Some(Ok((pattern, flags, attrs))) => {                    return Some(if flags.contains(ignore::pattern::Mode::NEGATIVE) {                        Err(Error::PatternNegation {                            line: line.into(),                            line_number: self.line_no,                        })                    } else {                        Ok((pattern, flags, attrs, self.line_no))                    })                }                Some(Err(err)) => return Some(Err(err)),            }        }        None    }} fn parse_line(line: &[u8]) -> Option<Result<(BString, crate::ignore::pattern::Mode, Iter<'_>), Error>> {    if line.is_empty() {        return None;    }     let (line, attrs): (Cow<'_, _>, _) = if line.starts_with(b"\"") {        todo!("unquote, need length of consumed bytes to know where attrs start")    } else {        let mut tokens = line.splitn(2, |n| *n == b' ');        (            tokens.next().expect("at least a line").into(),            tokens.next().unwrap_or_default(),        )    };     let (pattern, flags) = super::ignore::parse_line(line.as_ref())?;    Ok((pattern, flags, Iter::new(attrs))).into()}