use super::structural_common::raw_ffi_any_same_as;
use super::structural_mutate::{
IntoMutateResult, MutationView, StructuralMutateEngine, StructuralMutatorView,
};
use super::structural_visit::DefRegionKind;
use super::structural_walk::WalkOrder;
use super::unchanged::{UnchangedOr, is_unchanged};
use super::visit_error_context::update_visit_error_context;
use crate::{Any, AnyView, Dispatcher, IntoDispatcher, Result};
use std::borrow::BorrowMut;
impl<O: IntoMutateResult> super::dispatch::CallbackResult<Result<Any>> for O {
#[inline(always)]
fn callback_result(self) -> Result<Any> {
self.into_mutate_result().map(Any::from)
}
}
impl<O: IntoMutateResult> super::dispatch::CallbackResult<Result<UnchangedOr<Any>>> for O {
#[inline(always)]
fn callback_result(self) -> Result<UnchangedOr<Any>> {
self.into_mutate_result()
}
}
struct MapMutator<'a, D, const PRE_ORDER: bool> {
dispatch: &'a mut D,
}
fn run_mapper<D>(root: Any, dispatch: &mut D, order: WalkOrder) -> Result<Any>
where
for<'s, 'v> &'s mut D:
Dispatcher<(AnyView<'v>, DefRegionKind), Option<Result<UnchangedOr<Any>>>>,
{
match order {
WalkOrder::PreOrder => {
StructuralMutateEngine::run_mutator::<MapMutator<'_, D, true>, false>(
root,
&mut MapMutator::<D, true> { dispatch },
)
}
WalkOrder::PostOrder => StructuralMutateEngine::run_mutator::<
MapMutator<'_, D, false>,
false,
>(root, &mut MapMutator::<D, false> { dispatch }),
}
}
impl<'v, 'c, 'r, 'a, D, const PRE_ORDER: bool>
Dispatcher<
(
MutationView<'v>,
&'c mut StructuralMutatorView<'r, MapMutator<'a, D, PRE_ORDER>>,
),
Option<Result<UnchangedOr<Any>>>,
> for &mut MapMutator<'a, D, PRE_ORDER>
where
for<'s, 'value> &'s mut D:
Dispatcher<(AnyView<'value>, DefRegionKind), Option<Result<UnchangedOr<Any>>>>,
{
#[inline(always)]
fn dispatch_tuple(
self,
(value, mutator): (
MutationView<'v>,
&'c mut StructuralMutatorView<'r, MapMutator<'a, D, PRE_ORDER>>,
),
) -> Option<Result<UnchangedOr<Any>>> {
Some(self.map_current(value, mutator).map(UnchangedOr::from_any))
}
}
impl<D, const PRE_ORDER: bool> MapMutator<'_, D, PRE_ORDER>
where
for<'s, 'v> &'s mut D:
Dispatcher<(AnyView<'v>, DefRegionKind), Option<Result<UnchangedOr<Any>>>>,
{
#[inline(always)]
fn map_current(
&mut self,
value: MutationView<'_>,
mutator: &mut StructuralMutatorView<'_, Self>,
) -> Result<Any> {
let mode = value.inplace_mode();
let raw = *value.as_any_view().as_raw_ffi_any();
let kind = mutator.def_region_kind();
if PRE_ORDER {
let Some(callback_result) = self
.dispatch
.dispatch_tuple((unsafe { AnyView::from_raw_ffi_any(raw) }, kind))
else {
return mutator.default_mutate(self, value).map(Into::into);
};
let mapped: Any = callback_result
.map_err(|error| update_visit_error_context(error, raw))?
.into();
if is_unchanged(&mapped) || raw_ffi_any_same_as(raw, *mapped.as_raw_ffi_any()) {
drop(mapped);
mutator.default_mutate(self, value).map(Into::into)
} else {
let replacement = MutationView::new(AnyView::from(&mapped), mode);
let descended: Any = mutator.default_mutate(self, replacement)?.into();
Ok(if is_unchanged(&descended) {
mapped
} else {
descended
})
}
} else {
let mapped: Any = mutator.default_mutate(self, value)?.into();
let current = if is_unchanged(&mapped) {
unsafe { AnyView::from_raw_ffi_any(raw) }
} else {
AnyView::from(&mapped)
};
match self.dispatch.dispatch_tuple((current, kind)) {
Some(Ok(result)) if result.is_unchanged() => Ok(mapped),
Some(result) => result
.map(Any::from)
.map_err(|error| update_visit_error_context(error, *current.as_raw_ffi_any())),
None => Ok(mapped),
}
}
}
}
pub fn structural_map<R, M, H, D, O>(root: R, mapper: H, order: WalkOrder) -> Result<Any>
where
R: Into<Any>,
O: BorrowMut<D>,
for<'v> H: IntoDispatcher<
(AnyView<'v>, DefRegionKind),
Option<Result<UnchangedOr<Any>>>,
M,
Target = D,
Output = O,
>,
for<'s, 'v> &'s mut D:
Dispatcher<(AnyView<'v>, DefRegionKind), Option<Result<UnchangedOr<Any>>>>,
{
run_mapper(root.into(), mapper.into_dispatcher().borrow_mut(), order)
}