use tracing::debug;
use super::WrDiskCache;
use crate::error::Result;
impl WrDiskCache {
pub async fn read(&self, offset: u64, length: u64) -> Result<Option<bytes::Bytes>> {
let entries = self.entries.lock().await;
let end = offset.checked_add(length).ok_or_else(|| {
crate::error::Aria2Error::InvalidArgument(
"read range exceeds u64 address space".to_string(),
)
})?;
let Some((&entry_offset, entry)) = entries.range(..=offset).next_back() else {
return Ok(None);
};
let entry_end = entry_offset + entry.data.len() as u64;
if entry_end >= end {
let start = (offset - entry_offset) as usize;
let slice_end = start + length as usize;
return Ok(Some(entry.data.slice(start..slice_end)));
}
let mut result = Vec::with_capacity(length as usize);
let mut cursor = offset;
for (&fragment_offset, fragment) in entries.range(entry_offset..) {
let fragment_end = fragment_offset + fragment.data.len() as u64;
if fragment_end <= cursor {
continue;
}
if fragment_offset > cursor {
return Ok(None);
}
let copy_start = (cursor - fragment_offset) as usize;
let copy_end = ((end.min(fragment_end)) - fragment_offset) as usize;
result.extend_from_slice(&fragment.data[copy_start..copy_end]);
cursor = end.min(fragment_end);
if cursor == end {
return Ok(Some(bytes::Bytes::from(result)));
}
}
Ok(None)
}
pub async fn flush(&self) -> Result<Vec<super::CacheEntry>> {
let _flush_guard = self.flush_gate.lock().await;
let mut entries = self.entries.lock().await;
let mut flushed = Vec::new();
for entry in entries.values_mut() {
if entry.dirty {
flushed.push(entry.clone());
entry.dirty = false;
}
}
debug!("Flushed {} dirty cache entries", flushed.len());
Ok(flushed)
}
}