Runs a node and process the result.

@param string $name Node to run.

@return void
@throws NodeException
190151
public function jumpTo($name)
    {
        if (!isset($this->nodes[$name])) {
            throw new NodeException("Unknown node: $name");
        }
        // Cant make this recursive because php does not support tail
        // recursion optimization.
        while ($name !== false) {
            $node = $this->nodes[$name];
            $this->logDebug("Running $name");
            $node->run();
            $name = $this->processNodeResult($node);
        }
    }
735461
public function setNodeName( $name )
	{
		if( $this->nodeName == (string) $name )
			return FALSE;
		$this->nodeName = (string) $name;
		return TRUE;
	}
219300
public function delete($name)
    {
        if (array_key_exists($name, $this->getData())) {
            $this->_db->createCommand()->delete($this->tableName, 'name = :name', [':name' => $name])->execute();
            unset($this->_data[$name]);
        }

        $this->_setCache();
    }
1058114
public function delete($name)
    {
        $this->stale = true;

        try {
            $this->model->where('name', '=', $name)->delete();
        } catch (Exception $e) {
            throw new WriteException($e);
        }
    }
925877
public function copy($name = null)
    {
        $this->_process($this->_list($name), true, $this->param('overwrite'));
    }
40505
public function process($node, $path = null)
    {
        if (!$this->_override) {
            return;
        }
        $this->_processTree($node);
        return $node;
    }
1294648
public function execDown(string $name): void{
        $this->down();
        DB::connection('default')->table('migrations')->where('name', $name)->delete();
    }
70539
public function setAttribute($node, $name, $value)
    {
        if (is_string($node)) {
            $node = $this->getNode($node);
        }

        if ($node) {
            $node->setAttribute($name, $value);
        }
    }
1276235
public function output(string $name): void
	{
		$parent = $this->close();

		$output = current($this->blocks[$name]);

		unset($this->blocks[$name]);

		if(!empty($parent))
		{
			$output = str_replace('__PARENT__', $parent, $output);
		}

		echo $output;
	}
987073
private function addChildNode(string $name, array $config, \XMLWriter $writer): void
    {
        $writer->startElement($name);

        foreach ($config as $nodeName => $nodeData) {
            $nodeName = \is_numeric($nodeName) ? 'num__'.$nodeName : $nodeName;

            if (\is_array($nodeData)) {
                $this->addChildNode($nodeName, $nodeData, $writer);
            } elseif (\is_bool($nodeData)) {
                $writer->writeElement($nodeName, $nodeData === true ? 'true' : 'false');
            } else {
                $writer->writeElement($nodeName, (string)$nodeData);
            }
        }

        $writer->endElement();
    }
264785
public function extension($name)
    {
        $paths = $this->getPaths($name);
        $files = $this->app->make('files');
        foreach ($paths as $path) {
            if ($files->isDirectory($path)) {
                $this->run($path);
            }
        }
        $this->seed($name);
    }
781929
public function addFlag(string $name): void
    {
        if (!$this->hasFlag($name)) {
            $flagEntry = $this->entry[PoTokens::FLAG];
            if ($flagEntry === null) {
                $this->set(PoTokens::FLAG, $name);
            } elseif (is_array($flagEntry)) {
                $flagEntry[] = $name;
                $this->set(PoTokens::FLAG, implode(',', $flagEntry));
            } else {
                $this->set(PoTokens::FLAG, $flagEntry . ',' . $name);
            }
        }
    }
1142576
public function run($name, $callback) {
        if (!is_callable($callback)) {
            throw new \InvalidArgumentException('$callback is not callable');
        }

        // Because, we need to remove exists Instance before fork
        $this->Storage->setup();

        $pid = pcntl_fork();
        if ($pid === -1) {
            return false;
        }
        if ($pid) {
            // main fork
            $this->pids[$name] = $pid;
            return true;
        } else {
            $result = call_user_func($callback);
            $this->Storage->set($this->getKey(), $name, $result);
            exit(0);
        }
    }
1282737
public function execUp(string $name): void{
        DB::connection('default')->table('migrations')->insert(['name' => $name]);
        $this->up();
    }
1325532
public static final void nodeName(String name)
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "nodeName", name);

        _nodeName = name;

        if (tc.isEntryEnabled())
            Tr.exit(tc, "nodeName");
    }
639393
public function runCallbacks($name, $recursive = true)
    {
        $instances = $recursive ? $this->parents(true) : [$this];
        if (strncmp($name, 'after', 5) === 0) {
            $instances = array_reverse($instances);
        }
        foreach ($instances as $instance) {
            foreach ($instance->_callbacks[$name] as $closure) {
                $this->_suite->runBlock($this, $closure, $name);
            }
        }
    }
364808
private function callback(string $name)
    {
        if (!$this->hasCallback($name)) {
            throw new XslCallbackException('A callback with the name ' . $name . ' does not exist.');
        }

        return $this->callbacks[$name];
    }