'Takes a single step in a given stash.
:param stash:           The name of the stash.
:param successor_func:  If provided, this function is called with the state as its only argument. It should
return the state\'s successors. If this is None, state.successors is used, instead.
:param selector_func:   If provided, should be a lambda that takes a state and returns a boolean. If True, the
state will be stepped. Otherwise, it will be kept as-is.
:returns:               The successor SimulationManager.
:rtype:                 SimulationManager'

def _one_step(self, stash, selector_func=None, successor_func=None, **kwargs):

    if (len(self._hooks_step) != 0):
        hook = self._hooks_step.pop()
        pg = (self.copy() if self._immutable else self)
        pg._immutable = False
        out = hook(pg, stash, selector_func=selector_func, successor_func=successor_func, **kwargs)
        out._immutable = self._immutable
        self._hooks_step.append(hook)
        if (out is not self):
            out._hooks_step.append(hook)
        return out
    new_stashes = self._copy_stashes()
    new_active = []
    if (selector_func is None):
        to_tick = list(self.stashes[stash])
    else:
        to_tick = []
        for a in self.stashes[stash]:
            if selector_func(a):
                to_tick.append(a)
            else:
                new_active.append(a)
    new_stashes[stash] = []
    for a in to_tick:
        result_stashes = self._one_state_step(a, successor_func=successor_func, **kwargs)
        self._record_step_results(new_stashes, new_active, result_stashes)
    new_stashes[stash].extend(new_active)
    return self._successor(new_stashes)
