We just go an impact, so we go unreachable
        But only if we enable this state change in the conf

        :return: None
160304
def set_impact_state(self):
        
        cls = self.__class__
        if cls.enable_problem_impacts_states_change:
            logger.debug("%s is impacted and goes UNREACHABLE", self)

            # Track the old state (problem occured before a new check)
            self.state_before_impact = self.state
            self.state_id_before_impact = self.state_id
            # This flag will know if we override the impact state
            self.state_changed_since_impact = False
            # Set unreachable
            self.set_unreachable()
533173
@Override
    public boolean canLeave() {
      if (reached == 0) {
        return false;
      }
      if (namesystem.now() - reached < extension) {
        reportStatus("STATE* Safe mode ON.", false);
        return false;
      }
      return !needEnter();
    }
599699
public void dereferenceControllable()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "dereferenceControllable");
    _remoteDurableName = null;
    _anycastInputHandler = null;
    _destinationHandler = null;
    _messageProcessor = null;
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "dereferenceControllable");    
  }
142147
def pause(self):
        
        if self._status == TransferState.RUNNING:
            self._running.clear()
            self._status = TransferState.PAUSED
        else:
            raise SbgError('Can not pause. Download not in RUNNING state.')
1256681
def on_state_changed(self, state):
        
        if state:
            self.editor.sig_breakpoints_changed.connect(self.repaint)
            self.editor.sig_debug_stop.connect(self.set_current_line_arrow)
            self.editor.sig_debug_stop[()].connect(self.stop_clean)
            self.editor.sig_debug_start.connect(self.start_clean)
        else:
            self.editor.sig_breakpoints_changed.disconnect(self.repaint)
            self.editor.sig_debug_stop.disconnect(self.set_current_line_arrow)
            self.editor.sig_debug_stop[()].disconnect(self.stop_clean)
            self.editor.sig_debug_start.disconnect(self.start_clean)
1111915
def undefine(self):
        
        if lib.EnvUndeffunction(self._env, self._fnc) != 1:
            raise CLIPSError(self._env)

        self._env = None
258772
def freeze(self):
        
        self.target.disable()
        self.filter.configure(state='disable')
        self.prog_ob.configure(state='disable')
        self.pi.configure(state='disable')
        self.observers.configure(state='disable')
        self.comment.configure(state='disable')
411270
def temporarily_enabled(self):
        
        old_setting = self.options.enabled
        self.enable()
        try:
            yield
        finally:
            self.options.enabled = old_setting
132115
def set_available(self, show=None):
        
        show = self.state.show if show is None else show
        self.set_presence(PresenceState(available=True, show=show))
381392
def freeze(self):
        
        self._lazy = False
        for k, v in self.items():
            if k in self._env:
                continue
            for _k, _v in v.items():
                if isinstance(_v, Lazy):
                    if self.writable:
                        _v.get()
                    else:
                        try:
                            v.__setitem__(_k, _v.get(), replace=True)
                        except:
                            print "Error ini key:", _k
                            raise
                        del _v
        self._globals = SortedDict()
890258
protected void ensureTransitionAllowed(CmmnActivityExecution execution, CaseExecutionState expected, CaseExecutionState target, String transition) {
    String id = execution.getId();

    CaseExecutionState currentState = execution.getCurrentState();

    // the state "suspending" or "terminating" will set immediately
    // inside the corresponding AtomicOperation, that's why the
    // previous state will be used to ensure that the transition
    // is allowed.
    if (execution.isTerminating() || execution.isSuspending()) {
      currentState = execution.getPreviousState();
    }

    // is the case execution already in the target state
    if (target.equals(currentState)) {
      throw LOG.isAlreadyInStateException(transition, id, target);

    } else
    // is the case execution in the expected state
    if (!expected.equals(currentState)) {
      throw LOG.unexpectedStateException(transition, id, expected, currentState);
    }
  }
795435
function () {
					if(paused === true) {
						paused = false;
						node.onChangeWithPriority(options.priority, do_get);
						if(options.run_on_create !== false) {
							if (constraint_solver.semaphore >= 0) {
								node.get(false);
							} else {
								each(node._changeListeners, constraint_solver.add_in_call_stack, constraint_solver);
							}
						}
						return true; // successfully resumed
					}
					return false;
				}
642128
def temporarily_disabled(self):
        
        old_setting = self.options.enabled
        self.disable(clear_cache=False)
        try:
            yield
        finally:
            self.options.enabled = old_setting
364400
def shutdown(self):
        
        for connection in self.connections.copy():
            connection.shutdown()

        self.connections = None

        self.context.term()
        self.context = None
        if self.trigger:
            try:
                self.reactor.removeSystemEventTrigger(self.trigger)
            except Exception:
                pass
860266
def goBack(self):
        
        if not self.canGoBack():
            return ''
        
        self._blockStack = True
        self._index -= 1
        self.emitCurrentChanged()
        self._blockStack = False
        return self.currentUrl()
1316386
function(state, transitionContext)
  {
    // this check is necessary to make sure we don't re-enter a transient state
    // like Renewing when we're already in it
    if (currentState !== state)
    {
      // if we have a current state, exit it; the null check is necessary
      // because the currentState is undefined at bootstrap time when we
      // transition to the first state
      if (currentState)
      {
        currentState.exit();
      }

      // update the current state
      currentState = state;

      // enter the new state
      currentState.enter(transitionContext);
    }
  }
252697
def squash(change, is_ignored=False, options=None):
    

    if options:
        is_ignored = change.is_ignored(options)

    if isinstance(change, Removal):
        result = SquashedRemoval(change, is_ignored)
    elif isinstance(change, Addition):
        result = SquashedAddition(change, is_ignored)
    else:
        result = SquashedChange(change, is_ignored)

    return result