shadowfacts/v6
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Self doesn't need to be mutable when visting rule inputs

Browse Source
This commit is contained in:
Shadowfacts 2024-10-31 11:35:43 -04:00
parent ca0b77349a
commit e034f30455
1 changed files with 24 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
crates/graph/src/lib.rs
View File

@ -408,7 +408,7 @@ pub struct ErasedNode<Synch: Synchronicity> {
any: Box<dyn Any>, any: Box<dyn Any>,
is_valid: Box<dyn Fn(&Box<dyn Any>) -> bool>, is_valid: Box<dyn Fn(&Box<dyn Any>) -> bool>,
invalidate: Box<dyn Fn(&mut Box<dyn Any>) -> ()>, invalidate: Box<dyn Fn(&mut Box<dyn Any>) -> ()>,
visit_inputs: Box<dyn Fn(&mut Box<dyn Any>, &mut dyn FnMut(NodeIndex<u32>) -> ()) -> ()>, visit_inputs: Box<dyn Fn(&Box<dyn Any>, &mut dyn FnMut(NodeIndex<u32>) -> ()) -> ()>,
update: Synch::UpdateFn, update: Synch::UpdateFn,
} }
@ -428,7 +428,7 @@ impl<S: Synchronicity> ErasedNode<S> {
x.invalidate(); x.invalidate();
}), }),
visit_inputs: Box::new(|any, visitor| { visit_inputs: Box::new(|any, visitor| {
let x = any.downcast_mut::<Box<dyn Node<V, S>>>().unwrap(); let x = any.downcast_ref::<Box<dyn Node<V, S>>>().unwrap();
x.visit_inputs(visitor); x.visit_inputs(visitor);
}), }),
update: S::make_update_fn::<V>(), update: S::make_update_fn::<V>(),
@ -447,15 +447,15 @@ impl<S: Synchronicity> ErasedNode<S> {
fn invalidate(&mut self) { fn invalidate(&mut self) {
(self.invalidate)(&mut self.any); (self.invalidate)(&mut self.any);
} }
fn visit_inputs(&mut self, f: &mut dyn FnMut(NodeIndex<u32>) -> ()) { fn visit_inputs(&self, f: &mut dyn FnMut(NodeIndex<u32>) -> ()) {
(self.visit_inputs)(&mut self.any, f); (self.visit_inputs)(&self.any, f);
} }
} }
trait Node<Value: 'static, Synch: Synchronicity> { trait Node<Value: 'static, Synch: Synchronicity> {
fn is_valid(&self) -> bool; fn is_valid(&self) -> bool;
fn invalidate(&mut self); fn invalidate(&mut self);
fn visit_inputs(&mut self, visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()); fn visit_inputs(&self, visitor: &mut dyn FnMut(NodeIndex<u32>) -> ());
fn update(&mut self) -> Synch::UpdateResult<'_>; fn update(&mut self) -> Synch::UpdateResult<'_>;
fn value_rc(&self) -> Rc<RefCell<Option<Value>>>; fn value_rc(&self) -> Rc<RefCell<Option<Value>>>;
} }
@ -481,7 +481,7 @@ impl<V: Clone + 'static, S: Synchronicity> Node<V, S> for ConstNode<V, S> {
fn invalidate(&mut self) {} fn invalidate(&mut self) {}
fn visit_inputs(&mut self, _visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()) {} fn visit_inputs(&self, _visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()) {}
fn update(&mut self) -> <S as Synchronicity>::UpdateResult<'_> { fn update(&mut self) -> <S as Synchronicity>::UpdateResult<'_> {
unreachable!() unreachable!()
@ -519,10 +519,10 @@ impl<R: Rule, S: Synchronicity> Node<R::Output, S> for RuleNode<R, R::Output, S>
self.valid = false; self.valid = false;
} }
fn visit_inputs(&mut self, visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()) { fn visit_inputs(&self, visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()) {
struct InputIndexVisitor<'a>(&'a mut dyn FnMut(NodeIndex<u32>) -> ()); struct InputIndexVisitor<'a>(&'a mut dyn FnMut(NodeIndex<u32>) -> ());
impl<'a> InputVisitor for InputIndexVisitor<'a> { impl<'a> InputVisitor for InputIndexVisitor<'a> {
fn visit<T>(&mut self, input: &mut Input<T>) { fn visit<T>(&mut self, input: &Input<T>) {
self.0(input.node_idx); self.0(input.node_idx);
} }
} }
@ -569,10 +569,10 @@ where
self.valid = false; self.valid = false;
} }
fn visit_inputs(&mut self, visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()) { fn visit_inputs(&self, visitor: &mut dyn FnMut(NodeIndex<u32>) -> ()) {
struct InputIndexVisitor<'a>(&'a mut dyn FnMut(NodeIndex<u32>) -> ()); struct InputIndexVisitor<'a>(&'a mut dyn FnMut(NodeIndex<u32>) -> ());
impl<'a> InputVisitor for InputIndexVisitor<'a> { impl<'a> InputVisitor for InputIndexVisitor<'a> {
fn visit<T>(&mut self, input: &mut Input<T>) { fn visit<T>(&mut self, input: &Input<T>) {
self.0(input.node_idx); self.0(input.node_idx);
} }
} }
@ -599,7 +599,7 @@ impl<R: AsyncRule> AsyncRuleNode<R, R::Output> {
pub trait Rule: 'static { pub trait Rule: 'static {
type Output; type Output;
fn visit_inputs(&mut self, visitor: &mut impl InputVisitor); fn visit_inputs(&self, visitor: &mut impl InputVisitor);
fn evaluate(&mut self) -> Self::Output; fn evaluate(&mut self) -> Self::Output;
} }
@ -607,13 +607,13 @@ pub trait Rule: 'static {
pub trait AsyncRule: 'static { pub trait AsyncRule: 'static {
type Output: 'static; type Output: 'static;
fn visit_inputs(&mut self, visitor: &mut impl InputVisitor); fn visit_inputs(&self, visitor: &mut impl InputVisitor);
async fn evaluate(&mut self) -> Self::Output; async fn evaluate(&mut self) -> Self::Output;
} }
pub trait InputVisitor { pub trait InputVisitor {
fn visit<T>(&mut self, input: &mut Input<T>); fn visit<T>(&mut self, input: &Input<T>);
} }
#[cfg(test)] #[cfg(test)]
@ -630,7 +630,7 @@ mod tests {
struct ConstantRule(i32); struct ConstantRule(i32);
impl Rule for ConstantRule { impl Rule for ConstantRule {
type Output = i32; type Output = i32;
fn visit_inputs(&mut self, _visitor: &mut impl InputVisitor) {} fn visit_inputs(&self, _visitor: &mut impl InputVisitor) {}
fn evaluate(&mut self) -> i32 { fn evaluate(&mut self) -> i32 {
self.0 self.0
} }
@ -656,8 +656,8 @@ mod tests {
struct Double(Input<i32>); struct Double(Input<i32>);
impl Rule for Double { impl Rule for Double {
type Output = i32; type Output = i32;
fn visit_inputs(&mut self, visitor: &mut impl InputVisitor) { fn visit_inputs(&self, visitor: &mut impl InputVisitor) {
visitor.visit(&mut self.0); visitor.visit(&self.0);
} }
fn evaluate(&mut self) -> i32 { fn evaluate(&mut self) -> i32 {
self.0.value() * 2 self.0.value() * 2
@ -683,7 +683,7 @@ mod tests {
struct Inc(i32); struct Inc(i32);
impl Rule for Inc { impl Rule for Inc {
type Output = i32; type Output = i32;
fn visit_inputs(&mut self, _visitor: &mut impl InputVisitor) {} fn visit_inputs(&self, _visitor: &mut impl InputVisitor) {}
fn evaluate(&mut self) -> i32 { fn evaluate(&mut self) -> i32 {
self.0 += 1; self.0 += 1;
return self.0; return self.0;
@ -711,9 +711,9 @@ mod tests {
struct Add(Input<i32>, Input<i32>); struct Add(Input<i32>, Input<i32>);
impl Rule for Add { impl Rule for Add {
type Output = i32; type Output = i32;
fn visit_inputs(&mut self, visitor: &mut impl InputVisitor) { fn visit_inputs(&self, visitor: &mut impl InputVisitor) {
visitor.visit(&mut self.0); visitor.visit(&self.0);
visitor.visit(&mut self.1); visitor.visit(&self.1);
} }
fn evaluate(&mut self) -> i32 { fn evaluate(&mut self) -> i32 {
self.0.value() + self.1.value() self.0.value() + self.1.value()
@ -759,9 +759,9 @@ mod tests {
struct DeferredInput(Rc<RefCell<Option<Input<i32>>>>); struct DeferredInput(Rc<RefCell<Option<Input<i32>>>>);
impl Rule for DeferredInput { impl Rule for DeferredInput {
type Output = i32; type Output = i32;
fn visit_inputs(&mut self, visitor: &mut impl InputVisitor) { fn visit_inputs(&self, visitor: &mut impl InputVisitor) {
let mut borrowed = self.0.borrow_mut(); let borrowed = self.0.borrow();
let input = borrowed.as_mut().unwrap(); let input = borrowed.as_ref().unwrap();
visitor.visit(input); visitor.visit(input);
} }
fn evaluate(&mut self) -> i32 { fn evaluate(&mut self) -> i32 {
@ -830,7 +830,7 @@ mod tests {
struct AsyncConst(i32); struct AsyncConst(i32);
impl AsyncRule for AsyncConst { impl AsyncRule for AsyncConst {
type Output = i32; type Output = i32;
fn visit_inputs(&mut self, _visitor: &mut impl InputVisitor) {} fn visit_inputs(&self, _visitor: &mut impl InputVisitor) {}
async fn evaluate(&mut self) -> i32 { async fn evaluate(&mut self) -> i32 {
self.0 self.0
} }