Return output handler.

@return oxOutput
773672
protected function _getOutputManager()
    {
        if (!$this->_oOutput) {
            $this->_oOutput = oxNew(\OxidEsales\Eshop\Core\Output::class);
        }

        return $this->_oOutput;
    }
444243
public function getOutput()
    {
        $totalExecution = profiler()->getTotalExecution();
        $metrics = profiler()->getMetrics();

        $totalTime = 0;
        $totalMemory = 0;

        foreach ($metrics as $metric) {
            $totalTime += ($metric->endTime - $metric->startTime);
            $totalMemory += ($metric->endMemory - $metric->startMemory);
        }

        $segmentDuration = $this->roundTo($totalTime * 1000, 5);
        $segmentCount = (int)ceil($totalTime / $segmentDuration);

        $displayTime = $segmentCount * $segmentDuration;

        foreach ($metrics as $metric) {
            $metric->offset = (($metric->startTime - $totalExecution->startTime) * 1000 / $displayTime) * 100;
            $metric->length = (($metric->endTime - $metric->startTime) * 1000 / $displayTime) * 100;
        }

        $totalTime = $totalExecution->getFormattedTime($totalTime, 2);
        $totalMemory = $totalExecution->getFormattedMemorySize($totalMemory);
        $allocatedMemory = $totalExecution->getFormattedMemorySize(memory_get_usage(true));
        $peakMemory = $totalExecution->getFormattedMemorySize(memory_get_peak_usage(true));

        $files = $this->getFiles();
        $logs = $this->getLogs();
        $vars = $this->getVars();
        $database = $this->getDatabase();

        ob_start();
        include __DIR__ . '/Views/Toolbar.php';
        $output = ob_get_contents();
        ob_end_clean();

        return $output;
    }
69395
function ReportOutput()
    {
        $fp = fopen($this->filenosuffix . ".out", "wb");
        if (!$fp) {
            return;
        }
        for ($i = 0; $i < $this->nstate; $i++) {
            $stp = $this->sorted[$i];
            fprintf($fp, "State %d:\n", $stp->statenum);
            if ($this->basisflag) {
                $cfp = $stp->bp;
            } else {
                $cfp = $stp->cfp;
            }
            while ($cfp) {
                if ($cfp->dot == $cfp->rp->nrhs) {
                    $buf = sprintf('(%d)', $cfp->rp->index);
                    fprintf($fp, '    %5s ', $buf);
                } else {
                    fwrite($fp,'          ');
                }
                $cfp->ConfigPrint($fp);
                fwrite($fp, "\n");
                if (0) {
                    //SetPrint(fp,cfp->fws,$this);
                    //PlinkPrint(fp,cfp->fplp,"To  ");
                    //PlinkPrint(fp,cfp->bplp,"From");
                }
                if ($this->basisflag) {
                    $cfp = $cfp->bp;
                } else {
                    $cfp = $cfp->next;
                }
            }
            fwrite($fp, "\n");
            for ($ap = $stp->ap; $ap; $ap = $ap->next) {
                if ($ap->PrintAction($fp, 30)) {
                    fprintf($fp,"\n");
                }
            }
            fwrite($fp,"\n");
        }
        fclose($fp);
    }
352776
public function openOutput()
    {
        if (null === $this->_stdout) {
            return STDOUT;
        } else {
            $this->_stdout = fopen($this->_stdout, 'wb');

            return $this->_stdout;
        }
    }
689261
public function getHandle()
    {
        $handle = null;

        if($this->isSupported())
        {
            $callbacks = $this->getCommandCallbacks();

            if(!empty($callbacks)) {
                $handle = parent::getHandle();
            }
        }

        return $handle;
    }
1229296
public static function output()
    {

        $aArgs = func_get_args();
        $iArgs = func_num_args();

        $c = $aArgs[0];

        if(isset($GLOBALS[self::$pref.$c])){
            switch (true) {
                case ($c == 'js'):

                    $output = Asset::dump($GLOBALS[self::$pref.$c]);

                    break;
                case ($c == 'css'):
                    $output = Asset::dump($GLOBALS[self::$pref.$c]);
                    break;
                default:
                    $output = $GLOBALS[self::$pref.$c];
                    break;
            }
        } else {
            $output = false;
        }



        return $output;
    }
438597
public function getOutput() {
		// create stream handle for the output
		$handle = fopen('php://temp/maxmemory:'.(1*1024*1024), 'r+'); // 1MB

		foreach ($this->_content['content'] as $nr => $row) {
			// use first row for headlines
			if ($nr == 0 && $this->table_header === true) {
				fwrite($handle, $this -> _createRow(array_keys($row)));
			}

			fwrite($handle, $this -> _createRow($row));
		}

		return $handle;
	}
1161091
public function getOutput()
    {
        $response = [];

        if(($this->returnValue))
        {
            $response['jxnrv'] = $this->returnValue;
        }
        $response['jxnobj'] = [];

        foreach($this->aCommands as $xCommand)
        {
            $response['jxnobj'][] = $xCommand;
        }

        return json_encode($response);
    }
1333034
public function getErrorOutput()
    {
        $this->readPipesForOutput(__FUNCTION__);

        if (false === $ret = stream_get_contents($this->stderr, -1, 0)) {
            return '';
        }

        return $ret;
    }
445570
public function createOutput()
    {
        if ($this->output === null) {
            $this->output = new ConsoleOutput();
            $this->output->getFormatter()->setStyle('b', new OutputFormatterStyle(null, null, ['bold']));
            $this->output->getFormatter()->setStyle('i', new OutputFormatterStyle('black', 'white'));
            $this->output->getFormatter()->setStyle('u', new OutputFormatterStyle(null, null, ['underscore']));
            $this->output->getFormatter()->setStyle('em', new OutputFormatterStyle(null, null, ['reverse']));
            $this->output->getFormatter()->setStyle('strike', new OutputFormatterStyle(null, null, ['conceal']));
            $this->output->getFormatter()->setStyle('success', new OutputFormatterStyle('green'));
            $this->output->getFormatter()->setStyle('warning', new OutputFormatterStyle('black', 'yellow'));
            $this->output->getFormatter()->setStyle('notice', new OutputFormatterStyle('yellow'));
            $this->output->getFormatter()->setStyle('info', new OutputFormatterStyle('white', null, ['bold']));
            $this->output->getFormatter()->setStyle('debug', new OutputFormatterStyle('white'));
        }

        return $this->output;
    }
162878
public function getOutput()
    {
        $this->readPipesForOutput(__FUNCTION__);

        if (false === $ret = stream_get_contents($this->stdout, -1, 0)) {
            return '';
        }

        return $ret;
    }
474744
public function clearOutput()
    {
        ftruncate($this->stdout, 0);
        fseek($this->stdout, 0);
        $this->incrementalOutputOffset = 0;

        return $this;
    }
1212270
public function getInput()
    {
        $this->codeBufferOpen = false;

        do {
            // reset output verbosity (in case it was altered by a subcommand)
            $this->output->setVerbosity(ShellOutput::VERBOSITY_VERBOSE);

            $input = $this->readline();

            /*
             * Handle Ctrl+D. It behaves differently in different cases:
             *
             *   1) In an expression, like a function or "if" block, clear the input buffer
             *   2) At top-level session, behave like the exit command
             */
            if ($input === false) {
                $this->output->writeln('');

                if ($this->hasCode()) {
                    $this->resetCodeBuffer();
                } else {
                    throw new BreakException('Ctrl+D');
                }
            }

            // handle empty input
            if (\trim($input) === '' && !$this->codeBufferOpen) {
                continue;
            }

            $input = $this->onInput($input);

            // If the input isn't in an open string or comment, check for commands to run.
            if ($this->hasCommand($input) && !$this->inputInOpenStringOrComment($input)) {
                $this->addHistory($input);
                $this->runCommand($input);

                continue;
            }

            $this->addCode($input);
        } while (!$this->hasValidCode());
    }
1354719
private function getOutputCallback()
    {
        if (is_null($this->outputCallback)) {
            $this->outputCallback = function ($line, $depth) {
                if ($depth < 0) {
                    return;
                }
                $indent = str_repeat("  ", $depth);
                $this->output .= $indent . $line . "\n";
            };
        }
        return $this->outputCallback;
    }
727944
def getOutput(self):
        
        output = self.stdout
        if self.stdout:
            output += '\r\n'
        output += self.stderr
        return output
514842
public function execute()
	{
		if (count($this->children) && count($this->input->args))
		{
			$name = $this->input->args[0];

			try
			{
				return $this->executeSubCommand($name);
			}
			catch (CommandNotFoundException $e)
			{
				$e->getCommand()->renderAlternatives($e->getChild(), $e);

				return $e->getCode();
			}
			catch (\Exception $e)
			{
				$this->renderException($e);

				return $e->getCode();
			}
		}

		if ($this->handler)
		{
			if ($this->handler instanceof \Closure)
			{
				$code = $this->handler;

				return $code($this);
			}
			elseif (is_callable($this->handler))
			{
				return call_user_func($this->handler, $this);
			}
		}

		return $this->doExecute();
	}
1287768
private function fireOnBlockOutputEvent()
    {
        $event = new BlockOutput($this->block);
        $event->setContents($this->outputContent);

        $app = Application::getFacadeApplication();
        $app->make('director')->dispatch('on_block_output', $event);

        $this->outputContent = $event->getContents();
    }