You are here

abstract class Output in Zircon Profile 8.0

Same name and namespace in other branches
  1. 8 vendor/symfony/console/Output/Output.php \Symfony\Component\Console\Output\Output

Base class for output classes.

There are five levels of verbosity:

  • normal: no option passed (normal output)
  • verbose: -v (more output)
  • very verbose: -vv (highly extended output)
  • debug: -vvv (all debug output)
  • quiet: -q (no output)

@author Fabien Potencier <fabien@symfony.com>

Hierarchy

Expanded class hierarchy of Output

6 files declare their use of Output
ApplicationTest.php in vendor/symfony/console/Tests/ApplicationTest.php
ApplicationTesterTest.php in vendor/symfony/console/Tests/Tester/ApplicationTesterTest.php
CommandTesterTest.php in vendor/symfony/console/Tests/Tester/CommandTesterTest.php
ConsoleOutputTest.php in vendor/symfony/console/Tests/Output/ConsoleOutputTest.php
OutputTest.php in vendor/symfony/console/Tests/Output/OutputTest.php

... See full list

File

vendor/symfony/console/Output/Output.php, line 30

Namespace

Symfony\Component\Console\Output
View source
abstract class Output implements OutputInterface {
  private $verbosity;
  private $formatter;

  /**
   * Constructor.
   *
   * @param int                           $verbosity The verbosity level (one of the VERBOSITY constants in OutputInterface)
   * @param bool                          $decorated Whether to decorate messages
   * @param OutputFormatterInterface|null $formatter Output formatter instance (null to use default OutputFormatter)
   */
  public function __construct($verbosity = self::VERBOSITY_NORMAL, $decorated = false, OutputFormatterInterface $formatter = null) {
    $this->verbosity = null === $verbosity ? self::VERBOSITY_NORMAL : $verbosity;
    $this->formatter = $formatter ?: new OutputFormatter();
    $this->formatter
      ->setDecorated($decorated);
  }

  /**
   * {@inheritdoc}
   */
  public function setFormatter(OutputFormatterInterface $formatter) {
    $this->formatter = $formatter;
  }

  /**
   * {@inheritdoc}
   */
  public function getFormatter() {
    return $this->formatter;
  }

  /**
   * {@inheritdoc}
   */
  public function setDecorated($decorated) {
    $this->formatter
      ->setDecorated($decorated);
  }

  /**
   * {@inheritdoc}
   */
  public function isDecorated() {
    return $this->formatter
      ->isDecorated();
  }

  /**
   * {@inheritdoc}
   */
  public function setVerbosity($level) {
    $this->verbosity = (int) $level;
  }

  /**
   * {@inheritdoc}
   */
  public function getVerbosity() {
    return $this->verbosity;
  }
  public function isQuiet() {
    return self::VERBOSITY_QUIET === $this->verbosity;
  }
  public function isVerbose() {
    return self::VERBOSITY_VERBOSE <= $this->verbosity;
  }
  public function isVeryVerbose() {
    return self::VERBOSITY_VERY_VERBOSE <= $this->verbosity;
  }
  public function isDebug() {
    return self::VERBOSITY_DEBUG <= $this->verbosity;
  }

  /**
   * {@inheritdoc}
   */
  public function writeln($messages, $type = self::OUTPUT_NORMAL) {
    $this
      ->write($messages, true, $type);
  }

  /**
   * {@inheritdoc}
   */
  public function write($messages, $newline = false, $type = self::OUTPUT_NORMAL) {
    if (self::VERBOSITY_QUIET === $this->verbosity) {
      return;
    }
    $messages = (array) $messages;
    foreach ($messages as $message) {
      switch ($type) {
        case OutputInterface::OUTPUT_NORMAL:
          $message = $this->formatter
            ->format($message);
          break;
        case OutputInterface::OUTPUT_RAW:
          break;
        case OutputInterface::OUTPUT_PLAIN:
          $message = strip_tags($this->formatter
            ->format($message));
          break;
        default:
          throw new \InvalidArgumentException(sprintf('Unknown output type given (%s)', $type));
      }
      $this
        ->doWrite($message, $newline);
    }
  }

  /**
   * Writes a message to the output.
   *
   * @param string $message A message to write to the output
   * @param bool   $newline Whether to add a newline or not
   */
  protected abstract function doWrite($message, $newline);

}

Members

Namesort descending Modifiers Type Description Overrides
Output::$formatter private property
Output::$verbosity private property
Output::doWrite abstract protected function Writes a message to the output. 3
Output::getFormatter public function Returns current output formatter instance. Overrides OutputInterface::getFormatter
Output::getVerbosity public function Gets the current verbosity of the output. Overrides OutputInterface::getVerbosity
Output::isDebug public function
Output::isDecorated public function Gets the decorated flag. Overrides OutputInterface::isDecorated
Output::isQuiet public function
Output::isVerbose public function
Output::isVeryVerbose public function
Output::setDecorated public function Sets the decorated flag. Overrides OutputInterface::setDecorated 1
Output::setFormatter public function Sets output formatter. Overrides OutputInterface::setFormatter 1
Output::setVerbosity public function Sets the verbosity of the output. Overrides OutputInterface::setVerbosity 1
Output::write public function Writes a message to the output. Overrides OutputInterface::write
Output::writeln public function Writes a message to the output and adds a newline at the end. Overrides OutputInterface::writeln
Output::__construct public function Constructor. 1
OutputInterface::OUTPUT_NORMAL constant
OutputInterface::OUTPUT_PLAIN constant
OutputInterface::OUTPUT_RAW constant
OutputInterface::VERBOSITY_DEBUG constant
OutputInterface::VERBOSITY_NORMAL constant
OutputInterface::VERBOSITY_QUIET constant
OutputInterface::VERBOSITY_VERBOSE constant
OutputInterface::VERBOSITY_VERY_VERBOSE constant