abstract class Output in Zircon Profile 8

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 <[e-mail]>

Hierarchy

• class \Symfony\Component\Console\Output\Output implements OutputInterface

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

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

Name	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