use crate::error::PanResult;
use crate::formats::common::text::lossy;
use log::debug;
use memchr::{memchr, memrchr};
use std::io::{ErrorKind, Read};
pub(super) struct BlockReader<'r, R> {
reader: &'r mut R,
buf: Vec<u8>,
consumed: usize,
block_size: usize,
eof: bool,
}
impl<'r, R: Read> BlockReader<'r, R> {
pub(super) fn new(reader: &'r mut R, block_size: usize) -> Self {
Self {
reader,
buf: Vec::new(),
consumed: 0,
block_size: block_size.max(1),
eof: false,
}
}
pub(super) fn next_block(&mut self) -> PanResult<Option<&[u8]>> {
self.buf.drain(..self.consumed);
self.consumed = 0;
let mut target = self.block_size;
loop {
self.fill_to(target)?;
if let Some(last_newline) = memrchr(b'\n', &self.buf) {
self.consumed = last_newline + 1;
return Ok(Some(&self.buf[..self.consumed]));
}
if self.eof {
if self.buf.is_empty() {
return Ok(None);
}
self.consumed = self.buf.len();
return Ok(Some(&self.buf));
}
target = self.buf.len().saturating_mul(2);
}
}
fn fill_to(&mut self, target: usize) -> PanResult<()> {
while !self.eof && self.buf.len() < target {
let len = self.buf.len();
self.buf.resize(target, 0);
let read = self.reader.read(&mut self.buf[len..]);
match read {
Ok(0) => {
self.buf.truncate(len);
self.eof = true;
}
Ok(n) => self.buf.truncate(len + n),
Err(e) if e.kind() == ErrorKind::Interrupted => self.buf.truncate(len),
Err(e) => {
self.buf.truncate(len);
return Err(e.into());
}
}
}
Ok(())
}
}
pub(super) struct Split<'a> {
rest: Option<&'a [u8]>,
sep: u8,
}
impl<'a> Split<'a> {
pub(super) const fn new(bytes: &'a [u8], sep: u8) -> Self {
Self {
rest: Some(bytes),
sep,
}
}
}
impl<'a> Iterator for Split<'a> {
type Item = &'a [u8];
fn next(&mut self) -> Option<&'a [u8]> {
let rest = self.rest?;
if let Some(i) = memchr(self.sep, rest) {
self.rest = Some(&rest[i + 1..]);
Some(&rest[..i])
} else {
self.rest = None;
Some(rest)
}
}
}
pub(super) struct Lines<'a> {
rest: &'a [u8],
}
impl<'a> Iterator for Lines<'a> {
type Item = &'a [u8];
fn next(&mut self) -> Option<&'a [u8]> {
if self.rest.is_empty() {
return None;
}
let (line, rest) = memchr(b'\n', self.rest).map_or((self.rest, &[][..]), |i| {
(&self.rest[..i], &self.rest[i + 1..])
});
self.rest = rest;
Some(line.strip_suffix(b"\r").unwrap_or(line))
}
}
pub(super) const fn lines(block: &[u8]) -> Lines<'_> {
Lines { rest: block }
}
pub(super) fn record_type(line: &[u8]) -> &[u8] {
if line.first() == Some(&b'#') {
return b"#";
}
&line[..memchr(b'\t', line).unwrap_or(line.len())]
}
pub(super) fn note_skipped(seen: &mut Vec<Vec<u8>>, record_type: &[u8]) {
if record_type != b"H" && !seen.iter().any(|t| t == record_type) {
debug!("Skipping GFA records of type {:?}", lossy(record_type));
seen.push(record_type.to_vec());
}
}