use std::sync::Arc;
use bytes::Bytes;
use super::load::Asked;
use super::registry::{Slot, Through, entry_of};
use super::{Cab, Candidate, Environment, LoadMode, RawCab, resource_candidates};
use crate::error::{Error, NotFound};
use crate::files::{BundleFile, File, Parent, ParentKind, SerializedFile};
use crate::raw::RawStr;
fn read_cab(cab: &Cab, offset: u64, size: u64) -> Result<Bytes, Error> {
match cab {
Cab::Raw(RawCab::InBundle { bundle, dir_index }) => {
bundle.entry_range(*dir_index, offset..offset.saturating_add(size))
}
Cab::Raw(RawCab::File(raw)) => {
let kind = raw.reader_kind();
let at = kind.seek(i128::from(offset))?;
let (range, _) = kind.read_u64(raw.data.len(), at, size)?;
Ok(raw.data.slice(range))
}
Cab::Serialized(sf) => Err(not_a_reader(sf.name())),
}
}
fn not_a_reader(name: &RawStr) -> Error {
Error::Malformed {
what: "resource",
detail: format!("{name} is a SerializedFile, not a reader").into(),
}
}
impl Environment {
pub fn resource(
&self,
from: &Arc<SerializedFile>,
path: &RawStr,
offset: u64,
size: u64,
) -> Result<Bytes, Error> {
let _top = top_container(from);
let candidates = resource_candidates(path);
let first = self.room(|| {
self.reach_chain(from)?;
self.resource_try(from, &candidates, offset, size)
})?;
if let Some(bytes) = first {
return Ok(bytes);
}
let meter = from.meter();
for external in from.externals() {
self.fallback_load(&external.path)?;
}
for c in &candidates {
self.room(|| self.fallback_candidate(c, meter))?;
}
if let Some(bytes) = self.room(|| self.resource_try(from, &candidates, offset, size))? {
return Ok(bytes);
}
let [basename, ..] = candidates;
Err(Error::NotFound(NotFound::Resource(basename.stem)))
}
fn fallback_load(&self, name: &RawStr) -> Result<(), Error> {
let Some(resolver) = self.inner.options.resolver.as_ref() else {
return Ok(());
};
let Some(source) = resolver.resolve(name.as_bytes()) else {
return Ok(());
};
self.load_resolved(&source, Asked::Fallback(name)).map(drop)
}
fn fallback_candidate(
&self,
candidate: &Candidate,
meter: &Arc<crate::limits::Meter>,
) -> Result<(), Error> {
let name = candidate.joined_vec(meter)?;
let Some(resolver) = self.inner.options.resolver.as_ref() else {
return Ok(());
};
let Some(source) = resolver.resolve(name.as_slice()) else {
return Ok(());
};
let persistent = RawStr::from_metered(name, meter)?;
self.load_resolved(&source, Asked::Fallback(&persistent))
.map(drop)
}
fn resource_try(
&self,
from: &Arc<SerializedFile>,
candidates: &[Candidate; 4],
offset: u64,
size: u64,
) -> Result<Option<Bytes>, Error> {
let meter = from.meter();
for c in candidates {
let name = c.joined_vec(meter)?;
let Some(slot) = self.inner.registry.slot_bytes(name.as_slice(), meter)? else {
continue;
};
drop(name);
if let Some((bundle, i)) = own_entry(from, &slot) {
match bundle.entry(i)? {
File::Raw(_) => {
return Ok(Some(
bundle.entry_range(i, offset..offset.saturating_add(size))?,
));
}
File::Serialized(sf) => return Err(not_a_reader(sf.name())),
File::Bundle(nested) => {
self.inner.registry.reach(&slot, Some(&nested))?;
continue;
}
File::Web(w) => {
self.inner.registry.reach_web(&slot, &w)?;
continue;
}
}
}
if let Some(cab) = self.inner.registry.resolve(&slot)? {
return Ok(Some(read_cab(&cab, offset, size)?));
}
}
Ok(None)
}
}
impl Environment {
pub(super) fn reach_chain(&self, from: &SerializedFile) -> Result<(), Error> {
if self.inner.options.load != LoadMode::Lazy {
return Ok(());
}
let Some(mut top) = parent_container(from.parent()) else {
return Ok(());
};
let mut below = None;
while let Some(up) = parent_container(container_parent(&top)) {
below = Some(std::mem::replace(&mut top, up));
}
let Some(nested) = below else {
return Ok(());
};
let name = match &nested {
File::Bundle(b) => b.name(),
File::Web(w) => w.name(),
_ => return Ok(()),
};
let Some(slot) = self.inner.registry.slot(name, nested.meter())? else {
return Ok(());
};
match top {
File::Bundle(b) => self.reach_entry(&b, &slot, &nested),
_ => Ok(()),
}
}
pub(super) fn reach_sibling(
&self,
from: &SerializedFile,
bundle: &Arc<BundleFile>,
dir_index: usize,
nested: &File,
) -> Result<(), Error> {
if self.inner.options.load != LoadMode::Lazy {
return Ok(());
}
let Some(d) = bundle.directory().get(dir_index) else {
return Ok(());
};
let Some(slot) = self.inner.registry.slot(&d.path, from.meter())? else {
return Ok(());
};
self.reach_entry(bundle, &slot, nested)
}
fn reach_entry(
&self,
bundle: &Arc<BundleFile>,
slot: &Arc<Slot>,
nested: &File,
) -> Result<(), Error> {
let Some((i, through)) = entry_of(bundle, slot) else {
return Ok(());
};
let same = match (bundle.entry(i)?, nested) {
(File::Bundle(a), File::Bundle(b)) => Arc::ptr_eq(&a, b),
(File::Web(a), File::Web(b)) => Arc::ptr_eq(&a, b),
_ => false,
};
if !same {
return Ok(());
}
let reg = &self.inner.registry;
match (through, nested) {
(Through::Own, File::Bundle(b)) => reg.reach(slot, Some(b)),
(Through::Own, File::Web(w)) => reg.reach_web(slot, w),
_ => reg.reach(slot, None),
}
}
}
pub(super) fn top_container(from: &SerializedFile) -> Option<File> {
let mut top = parent_container(from.parent())?;
while let Some(up) = parent_container(container_parent(&top)) {
top = up;
}
Some(top)
}
fn container_parent(file: &File) -> Option<&Parent> {
match file {
File::Bundle(b) => b.parent(),
File::Web(w) => w.parent(),
_ => None,
}
}
fn parent_container(parent: Option<&Parent>) -> Option<File> {
match &parent?.kind {
ParentKind::Bundle { bundle, .. } => bundle.upgrade().map(File::Bundle),
ParentKind::Web { web } => web.upgrade().map(File::Web),
}
}
fn parent_bundle(parent: Option<&Parent>) -> Option<Arc<BundleFile>> {
match &parent?.kind {
ParentKind::Bundle { bundle, .. } => bundle.upgrade(),
ParentKind::Web { .. } => None,
}
}
fn own_entry(from: &SerializedFile, slot: &Slot) -> Option<(Arc<BundleFile>, usize)> {
let fb = parent_bundle(from.parent())?;
match entry_of(&fb, slot)? {
(i, Through::Own) => Some((fb, i)),
(_, Through::Slot) => None,
}
}