doctrine2/lib/vendor/Symfony/Components/Console/Input/Input.php

<?php

namespace Symfony\Components\Console\Input;

/*
 * This file is part of the symfony framework.
 *
 * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

/**
 * Input is the base class for all concrete Input classes.
 *
 * Three concrete classes are provided by default:
 *
 *  * `ArgvInput`: The input comes from the CLI arguments (argv)
 *  * `StringInput`: The input is provided as a string
 *  * `ArrayInput`: The input is provided as an array
 *
 * @package    symfony
 * @subpackage console
 * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
 */
abstract class Input implements InputInterface
{
  protected $definition;
  protected $options;
  protected $arguments;
  protected $interactive = true;

  /**
   * Constructor.
   *
   * @param InputDefinition $definition A InputDefinition instance
   */
  public function __construct(InputDefinition $definition = null)
  {
    if (null === $definition)
    {
      $this->definition = new InputDefinition();
    }
    else
    {
      $this->bind($definition);
      $this->validate();
    }
  }

  /**
   * Binds the current Input instance with the given arguments and options.
   *
   * @param InputDefinition $definition A InputDefinition instance
   */
  public function bind(InputDefinition $definition)
  {
    $this->arguments = array();
    $this->options = array();
    $this->definition = $definition;

    $this->parse();
  }

  /**
   * Processes command line arguments.
   */
  abstract protected function parse();

  public function validate()
  {
    if (count($this->arguments) < $this->definition->getArgumentRequiredCount())
    {
      throw new \RuntimeException('Not enough arguments.');
    }
  }

  public function isInteractive()
  {
    return $this->interactive;
  }

  public function setInteractive($interactive)
  {
    $this->interactive = (Boolean) $interactive;
  }

  /**
   * Returns the argument values.
   *
   * @return array An array of argument values
   */
  public function getArguments()
  {
    return array_merge($this->definition->getArgumentDefaults(), $this->arguments);
  }

  /**
   * Returns the argument value for a given argument name.
   *
   * @param string $name The argument name
   *
   * @return mixed The argument value
   */
  public function getArgument($name)
  {
    if (!$this->definition->hasArgument($name))
    {
      throw new \InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
    }

    return isset($this->arguments[$name]) ? $this->arguments[$name] : $this->definition->getArgument($name)->getDefault();
  }

  /**
   * Sets an argument value by name.
   *
   * @param string $name  The argument name
   * @param string $value The argument value
   */
  public function setArgument($name, $value)
  {
    if (!$this->definition->hasArgument($name))
    {
      throw new \InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
    }

    $this->arguments[$name] = $value;
  }

  /**
   * Returns true if an InputArgument object exists by name or position.
   *
   * @param string|integer $name The InputArgument name or position
   *
   * @return Boolean true if the InputArgument object exists, false otherwise
   */
  public function hasArgument($name)
  {
    return $this->definition->hasArgument($name);
  }

  /**
   * Returns the options values.
   *
   * @return array An array of option values
   */
  public function getOptions()
  {
    return array_merge($this->definition->getOptionDefaults(), $this->options);
  }

  /**
   * Returns the option value for a given option name.
   *
   * @param string $name The option name
   *
   * @return mixed The option value
   */
  public function getOption($name)
  {
    if (!$this->definition->hasOption($name))
    {
      throw new \InvalidArgumentException(sprintf('The "%s" option does not exist.', $name));
    }

    return isset($this->options[$name]) ? $this->options[$name] : $this->definition->getOption($name)->getDefault();
  }

  /**
   * Sets an option value by name.
   *
   * @param string $name  The option name
   * @param string $value The option value
   */
  public function setOption($name, $value)
  {
    if (!$this->definition->hasOption($name))
    {
      throw new \InvalidArgumentException(sprintf('The "%s" option does not exist.', $name));
    }

    $this->options[$name] = $value;
  }

  /**
   * Returns true if an InputOption object exists by name.
   *
   * @param string $name The InputOption name
   *
   * @return Boolean true if the InputOption object exists, false otherwise
   */
  public function hasOption($name)
  {
    return $this->definition->hasOption($name);
  }
}