Start running the game

@throws SlickException Indicates a failure to initialise the system
175130
public void start() throws SlickException {
		try {
			setup();
			
			getDelta();
			while (running()) {
				gameLoop();
			}
		} finally {
			destroy();
		}
		
		if (forceExit) {
			System.exit(0);
		}
	}
1272122
public void start() {
		Thread thread = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					onPreExecute();
					Value value = execute();
					onPostExecute(value);
				} catch (Throwable throwable) {
					onThrowable(throwable);
				}
			}
		});
		thread.start();
	}
1188068
public void start() throws IllegalStateException {
        Log.d(TAG, "start");

        if (mediaPlayer != null) {
            currentState = State.STARTED;
            mediaPlayer.setOnCompletionListener(this);
            mediaPlayer.start();
        } else throw new RuntimeException("Media Player is not initialized");
    }
1178947
def start(self):
        """"""
        if self._is_already_running():
            LOGGER.error('Is already running')
            sys.exit(1)
        try:
            self._daemonize()
            self.controller.start()
        except Exception as error:
            sys.stderr.write('\nERROR: Startup of %s Failed\n.' %
                             sys.argv[0].split('/')[-1])
            exception_log = self._get_exception_log_path()
            if exception_log:
                with open(exception_log, 'a') as handle:
                    timestamp = datetime.datetime.now().isoformat()
                    handle.write('{:->80}\n'.format(' [START]'))
                    handle.write('%s Exception [%s]\n' % (sys.argv[0],
                                                          timestamp))
                    handle.write('{:->80}\n'.format(' [INFO]'))
                    handle.write('Interpreter: %s\n' % sys.executable)
                    handle.write('CLI arguments: %s\n' % ' '.join(sys.argv))
                    handle.write('Exception: %s\n' % error)
                    handle.write('Traceback:\n')
                    output = traceback.format_exception(*sys.exc_info())
                    _dev_null = [(handle.write(line),
                                 sys.stdout.write(line)) for line in output]
                    handle.write('{:->80}\n'.format(' [END]'))
                    handle.flush()
                sys.stderr.write('\nException log: %s\n\n' % exception_log)
            sys.exit(1)
160589
public void start() {
        if (this.isActive)
            return;

        if (clock == null) {
            throw new IllegalStateException("Clock is not set");
        }

        this.isActive = true;

        logger.info("Starting ");

        cpuThread.activate();

        logger.info("Started ");
    }
553427
@Override
   public void run()
   {
      try {
         startBarrier.await();

         int idleCount = 0;
         while (!isRunning.compareAndSet(idleCount > LINGER_ITERATIONS && deadPool.isEmpty() && completionKeyToProcessMap.isEmpty(), false)) {
            idleCount = (!shutdown && process()) ? 0 : (idleCount + 1);
         }
      }
      catch (Exception e) {
         // TODO: how to handle this error?
         e.printStackTrace();
         isRunning.set(false);
      }
   }
126714
@Validate
    public void start() {
        Boolean enabled = configuration.getBooleanWithDefault("ehcache.enabled", true);
        if (!enabled) {
            return;
        }

        File config = new File(configuration.getBaseDir(), CUSTOM_CONFIGURATION);
        final ClassLoader original = Thread.currentThread().getContextClassLoader();
        try {
            Thread.currentThread().setContextClassLoader(this.getClass().getClassLoader());
            if (config.isFile()) {
                manager = CacheManager.create(config.getAbsolutePath());
            } else {
                URL url = EhCacheService.class.getClassLoader().getResource(INTERNAL_CONFIGURATION);
                if (url != null) {
                    manager = CacheManager.create(url);
                } else {
                    throw new ExceptionInInitializerError("Cannot instantiate EhCache, " +
                            "cannot load " + INTERNAL_CONFIGURATION + " file");
                }
            }
            manager.addCache(WISDOM_KEY);
            cache = manager.getCache(WISDOM_KEY);

            registration = context.registerService(Cache.class, this, new Hashtable<String, Object>());
        } finally {
            Thread.currentThread().setContextClassLoader(original);
        }


    }
962390
@Override
  public void start(CoprocessorEnvironment e) throws IOException {
    if (e instanceof RegionCoprocessorEnvironment) {
      RegionCoprocessorEnvironment env = (RegionCoprocessorEnvironment) e;
      Supplier<TransactionStateCache> cacheSupplier = getTransactionStateCacheSupplier(env);
      this.cache = cacheSupplier.get();

      HTableDescriptor tableDesc = env.getRegion().getTableDesc();
      for (HColumnDescriptor columnDesc : tableDesc.getFamilies()) {
        String columnTTL = columnDesc.getValue(TxConstants.PROPERTY_TTL);
        long ttl = 0;
        if (columnTTL != null) {
          try {
            ttl = Long.parseLong(columnTTL);
            LOG.info("Family " + columnDesc.getNameAsString() + " has TTL of " + columnTTL);
          } catch (NumberFormatException nfe) {
            LOG.warn("Invalid TTL value configured for column family " + columnDesc.getNameAsString() +
                       ", value = " + columnTTL);
          }
        }
        ttlByFamily.put(columnDesc.getName(), ttl);
      }

      this.allowEmptyValues = env.getConfiguration().getBoolean(TxConstants.ALLOW_EMPTY_VALUES_KEY,
                                                                TxConstants.ALLOW_EMPTY_VALUES_DEFAULT);
      this.readNonTxnData = Boolean.valueOf(tableDesc.getValue(TxConstants.READ_NON_TX_DATA));
      if (readNonTxnData) {
        LOG.info("Reading pre-existing data enabled for table " + tableDesc.getNameAsString());
      }
    }
  }
305743
public void start()
  {
    _systemManager.start();
    
    logStartComplete();

    // non-daemon thread to prevent quick exit
    Thread thread = new Thread(this::join);
    thread.setName("baratine-join");
    thread.start();
  }
755680
public void start() {
                // Log.d("EglHelper" + instanceId, "start()");
                if (mEgl == null) {
                        // Log.d("EglHelper" + instanceId, "getting new EGL");
                        /*
                         * Get an EGL instance
                         */
                        mEgl = (EGL10) EGLContext.getEGL();
                } else {
                        // Log.d("EglHelper" + instanceId, "reusing EGL");
                }

                if (mEglDisplay == null) {
                        // Log.d("EglHelper" + instanceId, "getting new display");
                        /*
                         * Get to the default display.
                         */
                        mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
                } else {
                        // Log.d("EglHelper" + instanceId, "reusing display");
                }

                if (mEglConfig == null) {
                        // Log.d("EglHelper" + instanceId, "getting new config");
                        /*
                         * We can now initialize EGL for that display
                         */
                        int[] version = new int[2];
                        mEgl.eglInitialize(mEglDisplay, version);
                        mEglConfig = mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
                } else {
                        // Log.d("EglHelper" + instanceId, "reusing config");
                }

                if (mEglContext == null) {
                        // Log.d("EglHelper" + instanceId, "creating new context");
                        /*
                         * Create an OpenGL ES context. This must be done only once, an OpenGL context is a somewhat heavy object.
                         */
                        mEglContext = mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
                        if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
                                throw new RuntimeException("createContext failed");
                        }
                } else {
                        // Log.d("EglHelper" + instanceId, "reusing context");
                }

                mEglSurface = null;
        }
1043563
@Override
  public void run()
  {
    try {
      runImpl();
    } catch (final Throwable e) {
      // env/0203 vs env/0206
      if (e instanceof DisplayableException)
        log.warning(e.getMessage());
      else
        log.warning(e.toString());
      
      _exception = e;
    } finally {
      notifyComplete();
    }
  }
1358784
public function initialize()
    {
        $driver = $this->_class;

        if (empty($driver)) {
            throw new Exception\InvalidArgumentException(
                "The session driver is invalid."
            );
        }

        // Load user defined driver
        if (class_exists($driver)) {
            $driverObj = new $driver($this->_options);
            if (is_a($driverObj, '\Slick\Session\Driver\DriverInterface')) {
                return $driverObj;
            } else {
                throw new Exception\InvalidArgumentException(
                    "The session type '{$driver}' doesn't inherited from "
                    ."Slick\Session\Driver\DriverInterface."
                );
            }
        }

        // Load module predefined drivers
        switch ($driver) {
            case 'server':
                $driverObj = new Driver\Server($this->_options);
                break;

            default:
                throw new Exception\InvalidArgumentException(
                    "The session type '{$driver}' isn't implemented."
                );
        }
       
        return $driverObj;
    }
1068065
public function start()
    {
        if ($this->isRunning()) {
            throw new LogicException('Process is already running');
        }

        $this->reset();

        $cmd = $this->cmd;
        if (substr($cmd, 0, 4) == 'php ') {
            $php = PHP_BINARY ?: PHP_BINDIR . '/php';
            $cmd = $php . substr($cmd, 3);
        }

        $descriptorspec = [
            0 => ['pipe', 'r'], // STDIN
            1 => ['pipe', 'w'], // STDOUT
            2 => ['pipe', 'w']  // STDERR
        ];

        $options = [
            'suppress_errors' => true,
            'binary_pipes'    => true,
        ];

        $this->process = proc_open($cmd, $descriptorspec, $this->pipes, base_path(), $this->env, $options);

        if (!is_resource($this->process)) {
            throw new RuntimeException('Unable to launch a new process.');
        }
    }
786032
@Override
  public void start()
  {
    LOGGER.debug("Start Loading");
    // validate parameters
    validateParameters();

    if (_op == null)
    {
      this.abort(new ConnectionError("Loader started with no operation"));
      return;
    }

    initDateFormats();

    initQueues();

    if (_is_first_start_call)
    {
      // is this the first start call?

      try
      {
        if (_startTransaction)
        {
          LOGGER.debug("Begin Transaction");
          _processConn.createStatement().execute("begin transaction");
        }
        else
        {
          LOGGER.debug("No Transaction started");
        }
      }
      catch (SQLException ex)
      {
        abort(new Loader.ConnectionError("Failed to start Transaction",
                                         Utils.getCause(ex)));
      }

      if (_truncate)
      {
        truncateTargetTable();
      }

      try
      {
        if (_before != null)
        {
          LOGGER.debug("Running Execute Before SQL");
          _processConn.createStatement().execute(_before);
        }
      }
      catch (SQLException ex)
      {
        abort(new Loader.ConnectionError(
            String.format("Execute Before SQL failed to run: %s", _before),
            Utils.getCause(ex)));
      }
    }
  }
1043787
public void start()
        throws Exception
    {
        super.start();
        
        if (!javax.servlet.Filter.class
            .isAssignableFrom(_class))
        {
            super.stop();
            throw new IllegalStateException(_class+" is not a javax.servlet.Filter");
        }

        _filter=(Filter)newInstance();
        _config=new Config();
        _filter.init(_config);
    }
1112803
@Override
    public void start() throws JMSException {
        checkClosed();
        actionOnConnectionTaken = true;

        if (running) {
            return;
        }
        synchronized (stateLock) {
            checkClosing();
            if (!running) {
                try {
                    for (Session session : sessions) {
                        SQSSession sqsSession = (SQSSession) session;
                        sqsSession.start();
                    }
                } finally {
                    running = true;
                }
            }
        }
    }
285448
@Override
    public void start() {
        register(STATUS_PASSED);
        register(STATUS_FIXED);
        register(STATUS_DEFECTIVE);
        register(STATUS_EXPLAINED, FIXED);
        register(STATUS_INVESTIGATING, DEFECTIVE, EXPLAINED, FIXED);
        register(STATUS_INTERRUPTED, INVESTIGATING, FIXED);
        register(STATUS_FAILED, INTERRUPTED, INVESTIGATING, EXPLAINED, DEFECTIVE);
        register(STATUS_WARNING, INTERRUPTED, INVESTIGATING, EXPLAINED, DEFECTIVE);
        // TODO Participation from extensions
        // Checks the tree
        for (ValidationRunStatusID statusID : statuses.values()) {
            for (String nextStatus : statusID.getFollowingStatuses()) {
                if (!statuses.containsKey(nextStatus)) {
                    throw new ValidationRunStatusUnknownDependencyException(statusID.getId(), nextStatus);
                }
            }
        }
        // Logging
        for (ValidationRunStatusID statusID : statuses.values()) {
            logger.info(
                    "[status] {} -> {}",
                    statusID.getId(),
                    StringUtils.join(statusID.getFollowingStatuses(), ",")
            );
        }
    }