如何使用nom解析器组合器实现文件的部分读取与解析？

• 需求：仅解析文件开头至设定停止点的内容，无需读取整个大文件（比如100KB），停止点前的内容长度未知（可能4KB或更大）。
• 遇到的问题：主流解析器组合库nom通常处理内存中的完整字节/字符块，尝试自定义MyInput数据结构动态读取文件时，因Compare trait方法接收的是不可变引用&self，无法修改内部缓存current_content。

用户尝试的代码：

struct MyInput {
  pb: PathBuf,
  read: Box<dyn Read>,
  filelength: u64,
  current_content: String,
}

impl MyInput {
  fn new(pb: PathBuf) -> Self {
    let file = OpenOptions::new().read(true).open(pb.clone()).unwrap();
    let filelength = std::fs::metadata(pb.clone()).unwrap().len();
    let current_content = "".to_string();
    Self { pb, read: Box::new(file), filelength, current_content }
  }
}

impl InputLength for MyInput {
  fn input_len(&self) -> usize {
    self.filelength as usize // 后续需要处理char和u8的长度差异
  }
}

// 问题所在
impl Compare<&str> for MyInput {
  fn compare(&self, t: &str) -> nom::CompareResult { 
    // 无法修改self.current_content填充缓存，因为&self是不可变的
    todo!()
  }

  fn compare_no_case(&self, t: &str) -> nom::CompareResult {
    todo!()
  }
}

方案1：使用内部可变性绕过不可变引用限制 #

Rust的内部可变性（比如RefCell）允许在持有不可变引用的同时修改内部数据，适合单线程场景。修改MyInput结构，用RefCell包装需要动态修改的字段：

use std::cell::RefCell;
use std::fs::OpenOptions;
use std::path::PathBuf;
use std::io::Read;
use nom::{InputLength, Compare, CompareResult};

struct MyInput {
  pb: PathBuf,
  read: RefCell<Box<dyn Read>>, // 用RefCell包装Read trait对象
  filelength: u64,
  current_content: RefCell<String>, // 用RefCell包装缓存字符串
}

impl MyInput {
  fn new(pb: PathBuf) -> Self {
    let file = OpenOptions::new().read(true).open(pb.clone()).unwrap();
    let filelength = std::fs::metadata(pb.clone()).unwrap().len();
    let current_content = RefCell::new("".to_string());
    Self { 
      pb, 
      read: RefCell::new(Box::new(file)), 
      filelength, 
      current_content 
    }
  }

  // 辅助方法：从文件读取更多数据到缓存
  fn read_more(&self, needed: usize) -> std::io::Result<()> {
    let mut content = self.current_content.borrow_mut();
    let mut read = self.read.borrow_mut();
    let mut buffer = vec![0; needed];
    let bytes_read = read.read(&mut buffer)?;
    content.push_str(&String::from_utf8_lossy(&buffer[..bytes_read]));
    Ok(())
  }
}

impl InputLength for MyInput {
  fn input_len(&self) -> usize {
    self.filelength as usize
  }
}

impl Compare<&str> for MyInput {
  fn compare(&self, t: &str) -> nom::CompareResult {
    let content = self.current_content.borrow();
    // 如果缓存长度不足，先读取更多数据
    if content.len() < t.len() {
      if let Err(_) = self.read_more(t.len() - content.len()) {
        return CompareResult::Error;
      }
      // 重新获取更新后的缓存
      let content = self.current_content.borrow();
      content.starts_with(t).then_some(CompareResult::Ok).unwrap_or(CompareResult::Error)
    } else {
      content.starts_with(t).then_some(CompareResult::Ok).unwrap_or(CompareResult::Error)
    }
  }

  fn compare_no_case(&self, t: &str) -> nom::CompareResult {
    let content = self.current_content.borrow();
    if content.len() < t.len() {
      if let Err(_) = self.read_more(t.len() - content.len()) {
        return CompareResult::Error;
      }
      let content = self.current_content.borrow();
      content.to_lowercase().starts_with(&t.to_lowercase())
        .then_some(CompareResult::Ok)
        .unwrap_or(CompareResult::Error)
    } else {
      content.to_lowercase().starts_with(&t.to_lowercase())
        .then_some(CompareResult::Ok)
        .unwrap_or(CompareResult::Error)
    }
  }
}

注意：RefCell仅适用于单线程场景，如果是多线程环境，可替换为Mutex或RwLock。

方案2：基于BufReader的流式解析（更简单） #

不需要自定义输入类型，直接用BufReader结合nom的流式解析能力，逐步读取缓存直到匹配到停止点：

use std::fs::File;
use std::io::{BufRead, BufReader};
use nom::{IResult, bytes::complete::take_until, sequence::terminated};

fn parse_until_stop_point(input: &str) -> IResult<&str, &str> {
  // 假设停止点是"STOP_HERE"，根据实际需求修改
  terminated(take_until("STOP_HERE"), nom::bytes::complete::tag("STOP_HERE"))(input)
}

fn main() -> std::io::Result<()> {
  let file = File::open("target_file.txt")?;
  let mut reader = BufReader::new(file);
  let mut buffer = String::new();
  let mut parsed = false;

  while !parsed {
    let bytes_read = reader.read_line(&mut buffer)?;
    if bytes_read == 0 {
      // 文件读完仍未找到停止点
      break;
    }

    match parse_until_stop_point(&buffer) {
      Ok((remaining, result)) => {
        println!("解析到的内容: {}", result);
        parsed = true;
        // 剩余内容可忽略或按需处理
      }
      Err(nom::Err::Incomplete(_)) => {
        // 缓存不足，继续读取更多内容
        continue;
      }
      Err(_) => {
        // 解析失败，按需处理（比如重置缓存或报错）
        buffer.clear();
      }
    }
  }

  Ok(())
}

这种方式利用BufReader的缓冲能力，结合nom的Incomplete错误提示，动态补充缓存直到完成解析或遍历到停止点，无需自定义输入类型，实现更简洁。

内容的提问来源于stack exchange，提问作者Frank Schwidom