///
/// Dirties this Node, which will cause it to examine its dependencies the next time it is
/// requested, and re-run if any of them have changed generations.
///
/// See comment on complete for information about _graph argument.
///
Dirties this Node, which will cause it to examine its dependencies the next time it is
requested, and re-run if any of them have changed generations.

See comment on complete for information about _graph argument.
Dirties this Node which will cause it to examine its dependencies the next time it is requested and re - run if any of them have changed generations . See comment on complete for information about _graph argument .
pub(crate) fn dirty(&mut self, _graph: &mut super::InnerGraph<N>) {
    let state = &mut *self.state.lock();
    trace!("Dirtying node {:?}", self.node);
    match state {
      &mut EntryState::Completed {
        ref mut result,
        ref mut pollers,
        ..
      } => {
        // Notify all pollers (ignoring any that have gone away.)
        for poller in pollers.drain(..) {
          let _ = poller.send(());
        }
        result.dirty();
        return;
      }
      &mut EntryState::NotStarted { .. } => return,
      &mut EntryState::Running { .. } if !self.node.cacheable() => {
        // An uncacheable node cannot be interrupted.
        return;
      }
      &mut EntryState::Running { .. } => {
        // Handled below: we need to move back to NotStarted.
      }
    };
    *state = match mem::replace(&mut *state, EntryState::initial()) {
      EntryState::Running {
        run_token,
        abort_handle,
        generation,
        previous_result,
        ..
      } => {
        // Dirtying a Running node immediately cancels it.
        trace!("Node {:?} was dirtied while running.", self.node);
        abort_handle.abort();
        EntryState::NotStarted {
          run_token,
          generation,
          previous_result,
        }
      }
      _ => unreachable!(),
    }
  }
pub ( crate ) fn dirty ( & mut self , _graph : & mut super :: InnerGraph < N > ) { let state = & mut * self . state . lock ( ) ; trace ! ( " " self node ) ; match state { & mut EntryState :: Completed { ref mut result , ref mut pollers , .. } => { // Notify all pollers (ignoring any that have gone away.) for poller in pollers . drain ( .. ) { let _ = poller . send ( ( ) ) ; } result . dirty ( ) ; return ; } & mut EntryState :: NotStarted { .. } => return , & mut EntryState :: Running { .. } if ! self . node . cacheable ( ) => { // An uncacheable node cannot be interrupted. return ; } & mut EntryState :: Running { .. } => { // Handled below: we need to move back to NotStarted. } } ; * state = match mem :: replace ( & mut * state , EntryState :: initial ( ) ) { EntryState :: Running { run_token , abort_handle , generation , previous_result , .. } => { // Dirtying a Running node immediately cancels it. trace ! ( " " self node ) ; abort_handle . abort ( ) ; EntryState :: NotStarted { run_token , generation , previous_result , } } _ => unreachable ! ( ) , } }
Dirties this Node, which will cause it to examine its dependencies the next time it is
requested, and re-run if any of them have changed generations.
Dirties this Node which will cause it to examine its dependencies the next time it is requested and re - run if any of them have changed generations .
&mut self
_graph
&mut super::InnerGraph<N>