use std::path::PathBuf;
use std::sync::Arc;
use crate::FactGuard;
use crate::cache::summary::{FileSummary, MacroKind};
use super::Definition;
#[derive(Debug, Clone)]
pub struct Step {
pub at: usize,
pub guard: FactGuard,
pub action: Action,
}
#[derive(Debug, Clone)]
pub enum Action {
Define(Arc<Definition>),
Undef(Arc<str>),
Include(IncludeAt),
}
#[derive(Debug, Clone)]
pub struct IncludeAt {
pub path: PathBuf,
}
#[derive(Debug, Clone, Default)]
pub struct Skeleton {
steps: Vec<Step>,
unresolved_includes: usize,
unreadable: usize,
}
impl Skeleton {
pub fn of(summary: &FileSummary, text: &str) -> Self {
Self::resolved_by(summary, text, &mut |fact| fact.resolved.clone())
}
pub fn resolved_by(
summary: &FileSummary,
text: &str,
resolve: &mut dyn FnMut(&crate::IncludeFact) -> Option<PathBuf>,
) -> Self {
let mut steps: Vec<Step> =
Vec::with_capacity(summary.macros.len() + summary.includes.len());
let mut unreadable = 0usize;
for fact in &summary.macros {
match Definition::of(fact, text) {
Some(definition) => steps.push(Step {
at: fact.range.start_offset,
guard: fact.guard,
action: Action::Define(Arc::new(definition)),
}),
None if fact.kind == MacroKind::Undefinition => steps.push(Step {
at: fact.range.start_offset,
guard: fact.guard,
action: Action::Undef(Arc::from(fact.name.as_str())),
}),
None => unreadable += 1,
}
}
let mut unresolved_includes = 0usize;
for fact in &summary.includes {
let Some(path) = resolve(fact) else {
unresolved_includes += 1;
continue;
};
steps.push(Step {
at: fact.range.start_offset,
guard: fact.guard,
action: Action::Include(IncludeAt { path }),
});
}
steps.sort_by_key(|step| step.at);
Skeleton {
steps,
unresolved_includes,
unreadable,
}
}
pub fn steps(&self) -> &[Step] {
&self.steps
}
pub fn unresolved_includes(&self) -> usize {
self.unresolved_includes
}
pub fn unreadable(&self) -> usize {
self.unreadable
}
pub fn is_empty(&self) -> bool {
self.steps.is_empty()
}
}