Connects to all the event listeners

@method startListening
@chainable
424
function () {
    this.events.on('report:run:browser', this.runBrowser.bind(this));
    this.events.on('report:assertion', this.assertion.bind(this));
    this.events.on('report:test:started', this.testStarted.bind(this));
    this.events.on('report:test:finished', this.testFinished.bind(this));
    this.events.on('report:runner:finished', this.runnerFinished.bind(this));
    this.events.on('report:testsuite:started', this.testsuiteStarted.bind(this));
    //this.events.on('report:testsuite:finished', this.testsuiteFinished.bind(this));
    return this;
  }
942953
public void startListening() {
        if (listenForCommands) {
            listeningThread = new Thread("kernel-command-listener") {
                @Override
                public void run() {
                    while (listenForCommands && acceptAndExecuteCommand()) {
                        //loop intentionally empty
                    }
                }
            };
            listeningThread.start();
        }
    }
410959
function() {
      var events = this.eventDelegates;
      log.events && (Object.keys(events).length > 0) && console.log('[%s] addHostListeners:', this.localName, events);
      // NOTE: host events look like bindings but really are not;
      // (1) we don't want the attribute to be set and (2) we want to support
      // multiple event listeners ('host' and 'instance') and Node.bind
      // by default supports 1 thing being bound.
      for (var type in events) {
        var methodName = events[type];
        PolymerGestures.addEventListener(this, type, this.element.getEventHandler(this, this, methodName));
      }
    }
637616
function() {
      _.each(this.__currentUpdateEvents, function(eventConfig) {
        this.stopListening(eventConfig.model, eventConfig.eventName);
      }, this);
      this.__currentUpdateEvents = [];
    }
1126399
function() {
          var self = this, list = this.$$conf.listeners.slice();
          // be sure to do this after setting up data and init state
          angular.forEach(list, function (parts) {
            parts[0].call(parts[1], {event: 'value', key: self.$id});
          });
        }
980444
function addStateListeners() {
  this.state.on('connect', this.onConnect);
  this.state.on('disconnect', this.onDisconnect);
  this.state.on('rejected', this.onRejected);
  this.state.store.on('hit', this.onHit);
  this.state.store.on('miss', this.onMiss);
  this.state.store.on('expired', this.onExpired);
}
858256
function(){
    if (this.eventQueue.length > 0){
      this.send(this.eventQueue);
      this.eventQueue = new Array();
    }
    // //reset the timer
    if (this.timer)  clearTimeout(this.timer);
    if (this.flushInterval) this.timer = setTimeout(this.flush.bind(this), this.flushInterval)
  }
1358277
function (callback) {
            debug('');

            self.eventStore.on('connect', function () {
              self.emit('connect');
            });

            self.eventStore.on('disconnect', function () {
              self.emit('disconnect');
            });

            self.eventStore.init(callback);
          }
1083297
private void setupStartEndListeners() {
        TransitionSetListener listener = new TransitionSetListener(this);
        for (Transition childTransition : mTransitions) {
            childTransition.addListener(listener);
        }
        mCurrentListeners = mTransitions.size();
    }
856224
def call(event, *args)
      return unless @listeners[event]
      @listeners[event].each do |callback|
        callback.call(*args)
      end
    end
67289
private function connectOutputToEvents(): void
    {
        Dispatcher::getInstance()->addListener(
            Transformer::EVENT_PRE_TRANSFORM,
            function (PreTransformEvent $event) {
                /** @var Transformer $transformer */
                $transformer = $event->getSubject();
                $templates = $transformer->getTemplates();
                $transformations = $templates->getTransformations();
                $this->logger->info(sprintf("\nApplying %d transformations", count($transformations)));
            }
        );
        Dispatcher::getInstance()->addListener(
            Transformer::EVENT_PRE_INITIALIZATION,
            function (WriterInitializationEvent $event) {
                if ($event->getWriter() instanceof WriterAbstract) {
                    $this->logger->info('  Initialize writer "' . get_class($event->getWriter()) . '"');
                }
            }
        );
        Dispatcher::getInstance()->addListener(
            Transformer::EVENT_PRE_TRANSFORMATION,
            function (PreTransformationEvent $event) {
                if ($event->getTransformation()->getWriter() instanceof WriterAbstract) {
                    $this->logger->info(
                        '  Execute transformation using writer "' . $event->getTransformation()->getWriter() . '"'
                    );
                }
            }
        );
    }
732794
function attachListener_() {
    if (isListening) { return; }
    isListening = true;

    unsubFunc = Events.eventListener(target, eventName, function() {
      if (outputStream.closed) {
        detachListener_();
      } else {
        Util.apply(boundEmit, arguments);
      }
    });

    onClose(outputStream, detachListener_);
  }
763084
function () {
                var eventListeners = this._cfg ? this._cfg.on : null;
                if (eventListeners) {
                    for (var listener in eventListeners) {
                        if (eventListeners.hasOwnProperty(listener)) {
                            eventListeners[listener] = this.$normCallback(eventListeners[listener]);
                        }
                    }
                }
            }
914765
void onJoinStart()
  {
    //long now = CurrentTime.getCurrentTime();
    ArrayList<UpdatePod> updatePods = new ArrayList<>();
    
    updateClusterRoot();

    /*
    for (UpdatePod updatePod : _podUpdateMap.values()) {
      if (updatePod.getSequence() == 0) {
        updatePods.add(new UpdatePod(updatePod, now));
      }
    }
    */
    
    /*
    for (UpdatePod updatePod : updatePods) {
      updatePod(updatePod);
    }
    */
    
    updatePods.addAll(_podUpdateMap.values());
    
    for (UpdatePod updatePod : updatePods) {
      updatePod(updatePod);
    }
    
    // XXX:
  }
1196585
static private function bindEventListenersEvents()
    {
    	if (self::$_eventListeners && !self::$_elInstances) {
    		foreach (self::$_eventListeners as $class => $listeners) {
    			if ($listeners) foreach ($listeners as $listener) {
    				
    				$listener = self::getListener($listener);
    				
    				$events = $listener->events();
    				
    				if ($events) foreach ($events as $name => $handler) {
    					Event::on($class, $name, is_string($handler) ? [$listener, $handler] : $handler);
    				}
    			}
    		}
    	}
    }
738991
function _initChildren() {
    if (!this._children) {
      return;
    }
    for (var child in this._children) {
      var childAttrs = this._attrs && this._attrs[child] ? this._attrs[child] : {};
      this[child] = new this._children[child](childAttrs, { parent: this, parse: true });
      this.listenTo(this[child], 'all', this._getEventBubblingHandler(child));
    }
  }
1116339
function relayEvents(listener, emitter, events) {
  events.forEach(eventName => listener.on(eventName, event => emitter.emit(eventName, event)));
}