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