use std::ops::{Deref, DerefMut};
use super::{FilePreview, Plan};
use crate::change::Change;
use crate::{EngineError, FileChange, Workspace};
#[derive(Debug, Clone)]
pub struct Planned<T> {
result: T,
plans: Vec<Plan>,
preview: Vec<FilePreview>,
}
impl<T> Planned<T> {
pub(crate) fn of(
workspace: &Workspace,
change: Change,
result: impl FnOnce(crate::change::Bound, Vec<FileChange>) -> T,
) -> Result<Self, EngineError> {
let mut bound = change.bind()?;
let change_set = std::mem::take(&mut bound.change_set);
let plan = Plan::new(change_set, workspace)?;
let preview = plan.preview(workspace)?.files;
let files = FileChange::all(Some(&plan), &preview);
Ok(Self::new(result(bound, files), vec![plan], preview))
}
pub(crate) fn new(result: T, plans: Vec<Plan>, preview: Vec<FilePreview>) -> Self {
Self {
result,
plans,
preview,
}
}
pub fn into_inner(self) -> T {
self.result
}
pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Planned<U> {
Planned {
result: f(self.result),
plans: self.plans,
preview: self.preview,
}
}
pub fn preview(&self) -> &[FilePreview] {
&self.preview
}
pub fn is_empty(&self) -> bool {
self.plans.iter().all(Plan::is_empty)
}
pub(crate) fn into_parts(self) -> (T, Vec<Plan>) {
(self.result, self.plans)
}
pub(crate) fn into_plans(self) -> Vec<Plan> {
self.plans
}
}
impl<T> Deref for Planned<T> {
type Target = T;
fn deref(&self) -> &T {
&self.result
}
}
impl<T> DerefMut for Planned<T> {
fn deref_mut(&mut self) -> &mut T {
&mut self.result
}
}