Starts the "cache engine"
@return boolean Returns true if engine started or inactivated, returns false if previous cache is loaded
19392
public function start()
    {
        if (!$this->isActive()) {
            return true;
        }

        if (!$this->hasCache()) {
            ob_start();
            return true;
        }

        $this->getCache(true);
        return false;
    }
765214
public function start()
    {
        $this->bufferized = true;
        $newHelper = clone $this;
        $this->bufferized = false;
        return $newHelper;
    }
809726
public function isStarted()
    {
        $started = \session_status() === PHP_SESSION_ACTIVE;

        // if the session was started externally, move the flash values forward
        if ($started && !$this->flashMoved) {
            $this->moveFlash();
        }

        // done
        return $started;
    }
394505
public function canStart()
    {
        if ($this->state === self::STATE_NOT_STARTED) {
            return true;
        }

        if ($this->state === self::STATE_PAUSED) {
            return true;
        }

        return false;
    }
320002
public function start()
    {
        RequestContext::destroy();
        PoolManager::clearPools();
        CacheManager::clearPools();
        App::createServers();
        ServerManage::getServer('main')->getSwooleServer()->start();
    }
746383
public function start(): bool
    {
        if (!$this->started) {
            // check headers
            if (headers_sent($file, $line)) {
                throw new SessionException(sprintf("Cannot use '%s()', headers already sent in %s:%s",
                    __method__, $file, $line));
            }

            // start session
            $this->started = session_start();
            if (!$this->started) {
                session_write_close();
                throw new SessionException(sprintf("Session start failed in '%s()'", __method__));
            }

            // check id for last time
            if (session_id() !== $this->id) {
                session_write_close();
                throw new SessionException(sprintf("Session ID match failed in '%s()'", __method__));
            }

            // init sub-array
            if (!isset($_SESSION[$this->name])) {
                $_SESSION[$this->name] = [];
            }
        }

        return $this->started;
    }
1289430
public function loadConfigurationCache(): bool
    {
        $cachePathAndFilename = $this->constructConfigurationCachePath();
        $configurations = @include $cachePathAndFilename;
        if ($configurations !== false) {
            $this->configurations = $configurations;
            return true;
        }

        return false;
    }
98540
public function start()
    {
		$this->_starttime = microtime(true);
        if (extension_loaded('xdebug') === false) {
            return false;
        }

        if (is_null($this->_traceFile) === true) {
            $this->_traceFile = tempnam(sys_get_temp_dir(), 'PHPConsistent_');
        }

        ini_set('xdebug.auto_trace', 1);
        ini_set('xdebug.trace_format', 1);
        ini_set('xdebug.collect_return', 1);
        ini_set('xdebug.collect_params', 1);
        ini_set('xdebug.trace_options', 0);
        xdebug_start_trace($this->_traceFile);

        if ($this->_log === self::LOG_TO_FIREPHP) {
            ob_start();
            break;
        }

        if ($this->_log !== self::LOG_TO_PHPUNIT) {
            register_shutdown_function(array($this, 'stop'));
            register_shutdown_function(array($this, 'analyze'));
        }

        return true;
    }
489786
private function bootCacher()
    {
        /** @var Cacher $cacher */
        $cacher = Cacher::getInstance();

        // Default cacher if FileCache, so we do not check it
        if (MemcachedCache::itWorks()) { // Distributed cache new version
            $cacher->setDefaultCacher('MemcachedCache');
        } elseif (MemcacheCache::itWorks()) { // Distributed cache old version
            $cacher->setDefaultCacher('MemcacheCache');
        } elseif (RedisCache::itWorks()) { // No-sql database
            $cacher->setDefaultCacher('RedisCache');
        }
    }
635771
private boolean doStart()
  {
    if (! _lifecycle.isActive()) {
      return false;
    }
    
    if (! isEnable()) {
      return false;
    }
    
    int startingCount = _startingCount.get();

    int threadCount = _threadCount.get() + startingCount;

    if (_threadMax < threadCount) {
      onThreadMax();
      
      return false;
    }
    else if (! isIdleTooLow(startingCount)) {
      return false;
    }
    
    _idleCount.incrementAndGet();

    startConnection();
      
    return true;
  }
845815
protected static function initCache()
    {
        // Build namespace for cache
        $namespace = self::$registry->getParameter('doozr.namespace.flat').'.cache';
        $container = self::$registry->getParameter('doozr.kernel.caching.container');
        $unix      = self::$registry->getParameter('doozr.unix');
        $caching   = self::$registry->getParameter('doozr.kernel.caching');

        // Store cache ...
        self::$registry->setCache(
            Doozr_Loader_Serviceloader::load(
                'cache',
                $container,
                $namespace,
                [],
                $unix,
                $caching
            )
        );

        // Important for bootstrap result
        return true;
    }
170614
public static function start() : bool
  {
    $capsule = new Capsule();

    $capsule->addConnection(Config::$database);
    $capsule->setAsGlobal();
    $capsule->bootEloquent();

    if ($capsule->connection()->getDatabaseName()) {
      return true;
    }

    return false;
  }
337267
public function Start() {
		if ($this->triedstart) {
			return $this->triedresult;
		}
		BLog::addToLog('[Users.Session]: Start()');
		$this->triedresult = false;
		$this->triedstart = true;
		$secret = explode(':', $_COOKIE['brillsecret']);
		if (count($secret) < 2) {
			$this->triedresult = false;
			return false;
		}
		$bCache = BFactory::getCache();
		if (!empty($bCache)) {
			$sess = $bCache->get('session:' . $secret[1]);
			if (($sess !== false) && ($sess !== NULL)) {
				$this->load($sess);
				$this->triedresult = true;
				return true;
			}
		}
		$db = BFactory::getDBO();
		if (empty($db)) {
			return false;
		}
		$qr = 'SELECT * from `sessions` WHERE (sessionid=' . $db->escapeString($secret[1]) . '&&userid=' . (int)$secret[0] . ')';
		$q = $db->Query($qr);
		if (empty($q)) {
			if (DEBUG_MODE) {
				BLog::addToLog('[Session]: Could not execute query! MySQL error: ' . $db->lasterror(), LL_ERROR);
			}
			return false;
		}
		$l = $db->fetch($q);
		if (empty($l)) {
			setcookie('brillsecret', '', time(), '/', BHOSTNAME);
			return false;
		}
		if (!empty($bCache)) {
			$bCache->set('session:' . $l['sessionid'], $l, 600);
		}
		$this->load($l, true);
		$this->triedstart = true;
		$this->triedresult = true;
		return true;
	}
380672
public function startOrResume() : bool
    {
        if (!$this->session->isStarted()) {
            return $this->session->start();
        }

        return $this->session->resume();
    }
735080
public function loadRoutesCache(): bool
    {
        if (!$this->isCacheEnable()) {
            return false;
        }

        $file = $this->cacheFile;
        if (!$file || !\file_exists($file)) {
            return false;
        }

        // load routes
        $map = require $file;
        $this->routeCounter = 0;
        $staticRoutes = $regularRoutes = $vagueRoutes = [];

        foreach ($map['staticRoutes'] as $key => $info) {
            $this->routeCounter++;
            $staticRoutes[$key] = Route::createFromArray($info);
        }

        foreach ($map['regularRoutes'] as $key => $routes) {
            foreach ($routes as $info) {
                $this->routeCounter++;
                $regularRoutes[$key][] = Route::createFromArray($info);
            }
        }

        foreach ($map['vagueRoutes'] as $key => $routes) {
            foreach ($routes as $info) {
                $this->routeCounter++;
                $vagueRoutes[$key][] = Route::createFromArray($info);
            }
        }

        $this->staticRoutes = $staticRoutes;
        $this->regularRoutes = $regularRoutes;
        $this->vagueRoutes = $vagueRoutes;
        $this->cacheLoaded = true;

        return true;
    }
794467
public function isStarted()
    {
        return (!is_null($this->userSession) && !is_null($this->getUserConfiguration()->getStartAt())) &&
            !is_null($this->session->get('user_session'));
    }
1178448
public function start()
    {
        if (!$this->isStarted()) {
            if ($this->cookie
                && !empty($_COOKIE[session_name()])
            ) {
                session_id($_COOKIE[session_name()]);
            }

            session_start();
        }

        return $this;
    }