halt: None -> None

        Stop the event, and remove the FD from the loop handler
558332
def halt(self):
        
        if self._callback:
            self._running.clear()
            self._ioloop.remove_handler(self.serial.fd)

            if self._frame_future is not None:
                self._frame_future.set_result(None)
                self._frame_future = None
228003
function abort() {
    var event,
        me = this,
        resetting = calledBy.reset;

    if (me.running) {
      event = Event('abort');
      me.emit(event);
      if (!event.cancelled || resetting) {
        // avoid infinite recursion
        calledBy.abort = true;
        me.reset();
        delete calledBy.abort;

        if (support.timeout) {
          clearTimeout(me._timerId);
          delete me._timerId;
        }
        if (!resetting) {
          me.aborted = true;
          me.running = false;
        }
      }
    }
    return me;
  }
995512
def stop(self, timeout=None):
        

        self.stopping = True

        for process in list(self.processes):
            self.stop_process(process, timeout=timeout)
157532
void stopNow() {
        assert currentThread() != this : "stopNow must not be called on the migration thread";
        running = false;
        queue.clear();
        interrupt();
        boolean currentThreadInterrupted = false;
        while (true) {
            try {
                join();
            } catch (InterruptedException e) {
                currentThreadInterrupted = true;
                continue;
            }
            break;
        }
        if (currentThreadInterrupted) {
            currentThread().interrupt();
        }
    }
198175
def unhandle(self, handler):
        
        with self._hlock:
            try:
                self._handler_list.remove(handler)
            except ValueError:
                raise ValueError("Handler is not handling this event, so cannot unhandle it.")
        return self
48039
def halt(self, message, emitter, *args, **kwargs):
        ''''''
        self.process_event((FINISH, self, (), {}))
        global_event_queue.clear()
219101
def deregister(self, event, fn):
        
        if event in self._handler_dict and fn in self._handler_dict[event]:
            self._handler_dict[event].remove(fn)
966727
def cleanup_event_loop(self):
        
        for task in asyncio.Task.all_tasks(loop=self.loop):
            if self.debug:
                warnings.warn('Cancelling task: %s' % task)
            task._log_destroy_pending = False
            task.cancel()
        self.loop.close()
        self.loop.set_exception_handler(self.loop_exception_handler_save)
        self.loop_exception_handler_save = None
        self.loop_policy = None
        self.loop = None
194085
def stop_event(self):
        
        self.logger.debug('stopping')
        try:
            self.on_stop()
        except Exception as ex:
            self.logger.exception(ex)
        for name in self.outputs:
            self.send(name, None)
930496
async def stop(self):
        
        # negate pid so that signals apply to process group
        pgid = -self.process.pid
        try:
            os.kill(pgid, signal.SIGTERM)
            await asyncio.sleep(1)
            os.kill(pgid, signal.SIGKILL)
        except (OSError, ProcessLookupError):
            return
1322241
def off(self, event):
        ''
        try:
            self._once_events.remove(event)
        except KeyError:
            pass
        self._callback_by_event.pop(event, None)
1315961
def stop(self):
    
    with self.lock:
      self.halting = True
      self.go.clear()
788336
def stop(self, sig=signal.SIGINT):
        ''''''
        for cpid in self.sandboxes:
            logger.warn('Stopping %i...' % cpid)
            try:
                os.kill(cpid, sig)
            except OSError:  # pragma: no cover
                logger.exception('Error stopping %s...' % cpid)

        # While we still have children running, wait for them
        # We edit the dictionary during the loop, so we need to copy its keys
        for cpid in list(self.sandboxes):
            try:
                logger.info('Waiting for %i...' % cpid)
                pid, status = os.waitpid(cpid, 0)
                logger.warn('%i stopped with status %i' % (pid, status >> 8))
            except OSError:  # pragma: no cover
                logger.exception('Error waiting for %i...' % cpid)
            finally:
                self.sandboxes.pop(cpid, None)
406660
def stop(self, timeout=None):
        
        ioloop = getattr(self, 'ioloop', None)
        if not ioloop:
            raise RuntimeError('Call start() before stop()')
        if timeout:
            if get_thread_ident() == self.ioloop_thread_id:
                raise RuntimeError('Cannot block inside ioloop')
            self._running.wait_with_ioloop(self.ioloop, timeout)

        def _cleanup():
            self._running.clear()
            self._disconnect()
        self._ioloop_manager.stop(timeout=timeout, callback=_cleanup)
77196
def event_listen_stop(self):
		''''''
		self._loop_stop = True
		c.pa.mainloop_wakeup(self._loop)
575322
def off(self, event, handler=None):
        """"""
        if handler:
            self.events[event].off(handler)
        else:
            del self.events[event]
            delattr(self, event)
765762
function off(name, fn, elem) {
  var useCapture = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;

  return (elem || doc).removeEventListener(name, fn, useCapture);
}