start this event
16444
public function start()
    {
        $result = array();
        if(count($this->helper_callbacks) > 0){
            foreach($this->helper_callbacks as $callback){
                $return_value = call_user_func_array($callback, array($this));
                $result[] = $return_value;
            }
        }
        return $result;
    }
943797
private void start() {
        if (m_bRunning) {
            m_logger.warn("start: Already started -- ignoring");
            return;
        }
        Locale.setDefault(Locale.ROOT);
        m_logger.info("Doradus Version: {}", getDoradusVersion());
        hookShutdownEvent();
        startServices();
        m_bRunning = true;
    }
750383
def start(self, aug='EventLoopThread'):
        

        if self.stopping:
            raise LoopStoppingError("Cannot perform action while loop is stopping.")

        if not self.loop:
            self._logger.debug("Starting event loop")
            self.loop = asyncio.new_event_loop()
            self.thread = threading.Thread(target=self._loop_thread_main, name=aug, daemon=True)
            self.thread.start()
537246
public void start () {
    if (config.activationKey != null) {
      input().keyboardEvents.connect(new Slot<Keyboard.Event>() {
        public void onEmit (Keyboard.Event event) {
          if (event instanceof Keyboard.KeyEvent) {
            Keyboard.KeyEvent kevent = (Keyboard.KeyEvent)event;
            if (kevent.key == config.activationKey && kevent.down) {
              toggleActivation();
            }
          }
        }
      });
    }

    // make a note of the main thread
    synchronized (this) {
      mainThread = Thread.currentThread();
    }

    // run the game loop
    loop();

    // let the game run any of its exit hooks
    dispatchEvent(lifecycle, Lifecycle.EXIT);

    // shutdown our thread pool
    try {
      pool.shutdown();
      pool.awaitTermination(1, TimeUnit.SECONDS);
    } catch (InterruptedException ie) {
      // nothing to do here except go ahead and exit
    }

    // and finally stick a fork in the JVM
    System.exit(0);
  }
208661
def start(self):
		
		tracker = self.tracker_storage()
		if tracker is not None and self.track_start() is True:
			details = self.event_details(WTrackerEvents.start)
			tracker.register_start(self, event_details=details)
		WThreadTask.start(self)
968327
public void start() {
		lock.lock();
		try {
			if (State.NOT_STARTED.equals(state)) {
				spiderThread.addSpiderListener(this);
				spiderThread.start();
				state = State.RUNNING;
				SpiderEventPublisher.publishScanEvent(
						ScanEventPublisher.SCAN_STARTED_EVENT, this.scanId, this.target, user);
			}
		} finally {
			lock.unlock();
		}
	}
415068
def start(self):
        """"""
        if not self._started:
            self.sig_started.emit(self)
            self._started = True
468013
def start(self):
        """"""
        asyncio.ensure_future(self.register(), loop=self._event_loop)

        if self._own_loop:
            _LOGGER.info("Starting up our own event loop.")
            self._event_loop.run_forever()
            self._event_loop.close()
            _LOGGER.info("Connection shut down.")
760385
public void start() {
        if (this.started) {
            throw new IllegalStateException("Cannot start the EventStream because it isn't stopped.");
        }

        final long initialPosition;

        if (this.startingPosition == STREAM_POSITION_NOW) {
            BoxAPIRequest request = new BoxAPIRequest(this.api, EVENT_URL.build(this.api.getBaseURL(), "now"), "GET");
            BoxJSONResponse response = (BoxJSONResponse) request.send();
            JsonObject jsonObject = JsonObject.readFrom(response.getJSON());
            initialPosition = jsonObject.get("next_stream_position").asLong();
        } else {
            assert this.startingPosition >= 0 : "Starting position must be non-negative";
            initialPosition = this.startingPosition;
        }

        this.poller = new Poller(initialPosition);

        this.pollerThread = new Thread(this.poller);
        this.pollerThread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            public void uncaughtException(Thread t, Throwable e) {
                EventStream.this.notifyException(e);
            }
        });
        this.pollerThread.start();

        this.started = true;
    }
117510
def run(self):
        ''''''
        # We left-append rather than emit (right-append) because some message
        # may have been already queued for execution before the director runs.
        global_event_queue.appendleft((INITIATE, self, (), {}))
        while global_event_queue:
            self.process_event(global_event_queue.popleft())
207750
public function on_start()
    {
        $this->registerServiceProvider();
        $this->registerParsers();
        $this->app->make('director')->addSubscriber($this->app->make(EventSubscriber::class));
        if ($this->app->isRunThroughCommandLineInterface()) {
            $this->registerCLICommands();
        } else {
            $this->registerAssets();
            $this->registerRoutes();
        }
    }
1048952
public void start() {
    input.messageHandler(new Handler<Object>() {
      @Override
      public void handle(Object message) {
        output.send(message);
        pumped++;
      }
    });
  }
106062
public void start()
    {
        try
        {
            if (!isStarted)
            {
                isStarted = true;
                agent.onStart();
                isRunning = true;
            }
        }
        catch (final Throwable throwable)
        {
            errorHandler.onError(throwable);
            close();
        }
    }
1332221
public void start() {
        setState(STATE_RUNNING);
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Starting: " + this);
        }
    }
641033
def start(self):
        

        while not self.is_start(self.current_tag):
            self.next()
        self.new_entry()
476040
def start(self):
        
        self.__stop = False
        self._queue.start()
        self._zk.start()
1276641
def start(self):
        
        self._events_to_write = []
        self._new_contracts_to_write = []

        @events.on(SmartContractEvent.CONTRACT_CREATED)
        @events.on(SmartContractEvent.CONTRACT_MIGRATED)
        def call_on_success_event(sc_event: SmartContractEvent):
            self.on_smart_contract_created(sc_event)

        @events.on(SmartContractEvent.RUNTIME_NOTIFY)
        def call_on_event(sc_event: NotifyEvent):
            self.on_smart_contract_event(sc_event)

        Blockchain.Default().PersistCompleted.on_change += self.on_persist_completed