corresponding handler.
776743
public int addPoller(PollItem pollItem, IZLoopHandler handler, Object arg)
    {
        if (pollItem.getRawSocket() == null && pollItem.getSocket() == null) {
            return -1;
        }

        SPoller poller = new SPoller(pollItem, handler, arg);
        pollers.add(poller);

        dirty = true;
        if (verbose) {
            System.out.printf(
                              "I: zloop: register %s poller (%s, %s)\n",
                              pollItem.getSocket() != null ? pollItem.getSocket().getType() : "RAW",
                                      pollItem.getSocket(),
                                      pollItem.getRawSocket());
        }
        return 0;
    }
78288
def putSubHandler(self, prefix, handler):
        '''
        '''
        self.subHandlers[prefix] = handler
        handler._parent = self
        return self
593003
def _handle(self, msg):
        

        def handler_yielder():
            for handler in self.handlers:
                yield handler

        def handler_callback(_):
            if msg.propagate:
                try:
                    h = hyielder.next()
                    g = self._pool.spawn(handler_runner, h)
                    g.link(handler_callback)
                except StopIteration:
                    pass

        def handler_runner(h):
            for command in h.commands:
                if command == msg.command:
                    method = getattr(h, h.commands[command])
                    method(msg)

        hyielder = handler_yielder()
        try:
            next_handler = hyielder.next()
            g = self._pool.spawn(handler_runner, next_handler)
            g.link(handler_callback)
        except StopIteration:
            pass
70293
public function dispatch() {
		$handler = current($this->handlers);
		if (!$handler) {
			return;
		}

		$this->resolveHandler($handler);

		return $this;
	}
72786
public void handle() {
        try {
            for (handleIndex++; handleIndex < handlers.size(); handleIndex++) {
                handlers.get(handleIndex).handle(this);
            }
        } catch (final Exception e) {
            final String requestLog = Requests.getLog(request);
            LOGGER.log(Level.ERROR, "Handler process failed: " + requestLog, e);

            setRenderer(new Http500Renderer(e));
        }
    }
623222
public function handler()
    {
        $dependencies = $this->dependencies;
        foreach ($this->getDependencies() as $depenci => $value) {
            $this->register($depenci, function () use ($value) {
                return $value;
            });
        }
    }
900307
def _registerHandler(self, handler):
        
        self._logger.addHandler(handler)
        self._handlers.append(handler)
463911
function(handler, options) {
        var active = this.active;
        if(active) {
            this.deactivate();
        }
        this.handler = new handler(this, this.callbacks, options);
        if(active) {
            this.activate();
        }
    }
1294130
def _handle_dumps(self, handler, **kwargs):
    

    return handler.dumps(self.__class__, to_dict(self), **kwargs)
1072687
function Handler(level) {
	level = level || Logger.NOTSET;

	if (Logger.getLevelName(level) === '') {
		throw new Error('Argument 1 of Handler.constructor has unsupported'
			+ ' value \'' + level + '\'');
	}

	Filterer.call(this);

	/**
	 * @private
	 * @type {number}
	 */
	this._level = level;

	/**
	 * @private
	 * @type {Object}
	 */
	this._formatter = null;
}
293175
def handler(value)
      if value.zero?
        @up_callback.call if @up_callback
      else
        @last_press = Time.now
        @down_callback.call if @down_callback
      end

      if value.zero? && (Time.now - @last_press) > @hold_time
        @hold_callback.call if @hold_callback
      end
    end
871790
function() {
    if (this.handler) {
      this.handler();
      if (mindmaps.DEBUG) {
        console.log("handler called for", this.id);
      }
    } else {
      if (mindmaps.DEBUG) {
        console.log("no handler found for", this.id);
      }
    }
  }
610890
async def handler(event):
    """"""
    await asyncio.wait([
        event.delete(),
        event.respond(READ_FULL, reply_to=event.reply_to_msg_id)
    ])
163549
def _start_handler_thread(self):
        """"""
        # Create handler thread
        t = Thread(target=self._start_loop)
        t.daemon = True

        # Start handler thread
        t.start()
        self.thread_started = True
673406
def trigger(self, event, *args):
        """"""
        for handler in self._event_handlers[event]:
            handler(*args)
1258715
def handle(self):
        """"""
        rv = None
        try:
            rv = BaseHTTPRequestHandler.handle(self)
        except (_ConnectionError, socket.timeout) as e:
            self.connection_dropped(e)
        except Exception as e:
            if self.server.ssl_context is None or not is_ssl_error(e):
                raise
        if self.server.shutdown_signal:
            self.initiate_shutdown()
        return rv
1269975
def trigger(self, *args, **kwargs):
        """"""
        for h in self.handlers:
            h(*args, **kwargs)