Start the tracer.
@return [type] [description]
493045
public function trace()
    {
        foreach ($this->files as $file) {
            ($this->debug === true) ? $this->addTrace($file) : $this->removeTrace($file);
        }
    }
228371
public function start()
    {
        if ( ! $this->isOpened()) {
            $this->open();
        }
        if ( ! $this->isLoaded()) {
            $this->read();
        }
        return $this;
    }
399284
public function start()
    {
        $time = microtime(true);

        $this->startTime = $time;
        $this->lastTime = $time;

        $this->displayLine('step', 'time', 'delta', 'memory', 'peak');
        $this->addStep('Init debug');

        return $this;
    }
411875
public function start() {
        foreach ($this->modules as $module) {
            $module->start();
        }

        if (php_sapi_name() == "cli") {
            Commands::handleCommand();
        }
        else {
            Routes::handleRequest();
        }
    }
205397
public function Start()
    {
        if(!file_exists($this->definitions_path))
        {
            throw new \Exception(
                t("Trying to import symbols from a non existent directory.")
            );
        }
        
        $this->SendMessage(
            sprintf(
                t("Starting import of definitions stored in %s format."),
                $this->import_type
            )
        );
        
        if($this->import_type == Type::JSON)
        {
            $this->LoadFromJSON($this->definitions_path);
        }
        else
        {
            $this->LoadFromPHP($this->definitions_path);
        }
        
        $this->SendMessage(t("Import completed."));
    }
1125270
public function start() {
        switch ($this->state) {
            case self::STATE_NONE:
                $this->state = self::STATE_SHEDULED;
                $this->counter = 1;
                break;
            default:
                $this->counter += 1;
        }
        return true;
    }
1358336
public function start()
    {
        if ($collector = end(static::$_collectors)) {
            $collector->add($collector->_driver->stop());
        }
        static::$_collectors[] = $this;
        $this->_driver->start();
        return true;
    }
506529
public function Start()
    {
        foreach($this->symbols->headers as $header_name=>$header_object)
        {
            // Skip disabled headers
            if(!$header_object->enabled)
            {
                $this->RemoveHeader($header_name);
                continue;
            }

            // Generate header file
            $header_content = $this->GenerateHeader($header_name);

            $this->AddHeader($header_name, $header_content);

            // Generate classes header file
            $classes_header_content = $this->GenerateClassesHeader($header_name);

            $this->AddHeader(
                $header_name,
                $classes_header_content,
                "includes/classes"
            );

            // Generate source file
            $source_content = $this->GenerateSource($header_name);

            $this->AddSource($header_name, $source_content);
        }

        $this->GenerateOtherSources();

        $this->GenerateCustomSources();

        $this->GenerateConfigs();
    }
659130
protected function startTraefik()
    {
        if ($this->hasTraefik()) {
            $this->createTraefikNetworkProxy();

            if (!$this->isTraefikRunning()) {
                $container = self::TRAEFIK_CONTAINER_NAME;

                if ($this->hasDockerContainer($container)) {
                    $result = $this->taskDockerStart($container)
                        ->run();
                } else {
                    $version = self::TRAEFIK_VERSION;
                    $result = $this->taskDockerRun("traefik:{$version}")
                        ->detached()
                        ->printOutput(false)
                        ->exec('--api --docker')
                        ->name($container)
                        ->option('publish', '80:80')
                        ->option('publish', '8080:8080')
                        ->option('network', self::TRAEFIK_NETWORK)
                        ->volume('/var/run/docker.sock', '/var/run/docker.sock')
                        ->run();
                }

                $this->validateTaskResult($result);
            }
        }

        return $this;
    }
765214
public function start()
    {
        $this->bufferized = true;
        $newHelper = clone $this;
        $this->bufferized = false;
        return $newHelper;
    }
1006087
public static function start() {
		$transformers = [ ];
		if (CacheManager::$cache->exists ( self::$key )) {
			$transformers = CacheManager::$cache->fetch ( self::$key );
		}
		self::$transformers = array_merge ( self::$transformers, $transformers );
	}
1277958
private function start()
    {
        Loop\queue(function () { // Asynchronously start the observable.
            if (null === $this->emitter) {
                return;
            }

            /**
             * Emits a value from the observable.
             *
             * @coroutine
             *
             * @param mixed $value If $value is an instance of \Icicle\Awaitable\Awaitable, the fulfillment value is
             *     used as the value to emit or the rejection reason is thrown from this coroutine.
             *
             * @return \Generator
             *
             * @resolve mixed The emitted value (the resolution value of $value)
             *
             * @throws \Icicle\Observable\Exception\CompletedError If the observable has been completed.
             */
            $emit = function ($value = null): \Generator {
                return $this->queue->push($value);
            };

            try {
                $generator = ($this->emitter)($emit);

                if (!$generator instanceof Generator) {
                    throw new UnexpectedTypeError('Generator', $generator);
                }

                $this->coroutine = new Coroutine($generator);
                $this->coroutine->done([$this->queue, 'complete'], [$this->queue, 'fail']);
            } catch (Throwable $exception) {
                $this->queue->fail(new InvalidEmitterError($this->emitter, $exception));
            }

            $this->emitter = null;
        });
    }
1055842
public function startTrans() {
        $this->connect();
        $this->transTimes++;
        if (1 == $this->transTimes) {
            $this->pdo->beginTransaction();
        }
    }
411753
static function start($flag = 0, array $ignoreFunctions = array())
    {
        if (self::$sample) {
            throw new \RuntimeException('The profiler has been started');
        }

        self::$sample = new XhprofSample($flag, $ignoreFunctions);

        xhprof_enable($flag, $ignoreFunctions);
    }
618651
private function path_tracer() {
		
		//TODO: consider working out how to trace paths one at a time, so the list of valid paths comes back in a more predictable manner.
		
		$tracerData = array();
		$this->validPaths = array();
		//build the initial tracerData for exploring the depths of this beastly array...
		foreach($this->data as $path=>$data) {
			if(is_array($data)) {
				$tracerData[] = array(
					'path'	=> "/". $path,
					'data'	=> $data
				);
			}
			else {
				//initial key ($path) doesn't have an array beneath it, so it's a blank root path.
				$this->validPaths[] = '/'. $path;
			}
		}
		
		//If we have anything left, we'll need to do some crazy while() looping madness.
		if(is_array($tracerData) && count($tracerData)) {
			while($myData = array_shift($tracerData)) {
				if(is_array($myData['data']) && count($myData['data'])) {
					$basePath = $myData['path'];
					foreach($myData['data'] as $key=>$val) {
						$tracerData[] = array(
							'path'	=> $basePath .'/'. $key,
							'data'	=> $val
						);
					}
				}
				else {
					$this->validPaths[] = $myData['path'];
				}
			}
		}
		
		
	}
794533
public static function start() : void
  {
    $required = Config::$environment;
    $dotenv   = new Dotenv(Config::$root);

    $dotenv->overload();
    $dotenv->required($required);
  }
792414
public static function start() {
    	$controller = (self::$route->module).'Controller';
    	$view = (self::$route->module).'View';
    	$model = (self::$route->module).'Model';
        $action = (self::$route->action).'Action';

        $module_root = MODULES_ROOT.'/'.self::$route->module;

        switch (true) {
			case (file_exists($module_root) &&
				 file_exists($module_root."/$model.php") &&
				 file_exists($module_root."/$view.php") &&
				 file_exists($module_root."/$controller.php")):
				$namespace = self::$route->module;

				if (class_exists("Module\\$namespace\\$controller")) {
					$app_controller = "Module\\$namespace\\$controller";
					$AppController = new $app_controller();
				} else {
					throw MvcException::UndefinedModule(self::$route->module);
				}

				if (method_exists($AppController, $action)) { $content = $AppController->$action(); } else {
					throw MvcException::UndefinedMethodInController($action, get_class($AppController));
				}
				break;

			default: throw MvcException::UndefinedModule(self::$route->module); break;
		}

        self::setContent($content);
    }