abstract class AbstractOperation in Plug 7

Base catalogues binary operation class.

@author Jean-François Simon <[e-mail]>

Hierarchy

• class \Symfony\Component\Translation\Catalogue\AbstractOperation implements OperationInterface

File

lib/Symfony/translation/Catalogue/AbstractOperation.php, line 22

Namespace

Symfony\Component\Translation\Catalogue

abstract class AbstractOperation implements OperationInterface {

  /**
   * @var MessageCatalogueInterface
   */
  protected $source;

  /**
   * @var MessageCatalogueInterface
   */
  protected $target;

  /**
   * @var MessageCatalogue
   */
  protected $result;

  /**
   * @var null|array
   */
  private $domains;

  /**
   * @var array
   */
  protected $messages;

  /**
   * @param MessageCatalogueInterface $source
   * @param MessageCatalogueInterface $target
   *
   * @throws \LogicException
   */
  public function __construct(MessageCatalogueInterface $source, MessageCatalogueInterface $target) {
    if ($source
      ->getLocale() !== $target
      ->getLocale()) {
      throw new \LogicException('Operated catalogues must belong to the same locale.');
    }
    $this->source = $source;
    $this->target = $target;
    $this->result = new MessageCatalogue($source
      ->getLocale());
    $this->domains = null;
    $this->messages = array();
  }

  /**
   * {@inheritdoc}
   */
  public function getDomains() {
    if (null === $this->domains) {
      $this->domains = array_values(array_unique(array_merge($this->source
        ->getDomains(), $this->target
        ->getDomains())));
    }
    return $this->domains;
  }

  /**
   * {@inheritdoc}
   */
  public function getMessages($domain) {
    if (!in_array($domain, $this
      ->getDomains())) {
      throw new \InvalidArgumentException(sprintf('Invalid domain: %s.', $domain));
    }
    if (!isset($this->messages[$domain]['all'])) {
      $this
        ->processDomain($domain);
    }
    return $this->messages[$domain]['all'];
  }

  /**
   * {@inheritdoc}
   */
  public function getNewMessages($domain) {
    if (!in_array($domain, $this
      ->getDomains())) {
      throw new \InvalidArgumentException(sprintf('Invalid domain: %s.', $domain));
    }
    if (!isset($this->messages[$domain]['new'])) {
      $this
        ->processDomain($domain);
    }
    return $this->messages[$domain]['new'];
  }

  /**
   * {@inheritdoc}
   */
  public function getObsoleteMessages($domain) {
    if (!in_array($domain, $this
      ->getDomains())) {
      throw new \InvalidArgumentException(sprintf('Invalid domain: %s.', $domain));
    }
    if (!isset($this->messages[$domain]['obsolete'])) {
      $this
        ->processDomain($domain);
    }
    return $this->messages[$domain]['obsolete'];
  }

  /**
   * {@inheritdoc}
   */
  public function getResult() {
    foreach ($this
      ->getDomains() as $domain) {
      if (!isset($this->messages[$domain])) {
        $this
          ->processDomain($domain);
      }
    }
    return $this->result;
  }

  /**
   * @param string $domain
   */
  protected abstract function processDomain($domain);

}

Members

Name	Modifiers	Type	Description	Overrides
AbstractOperation::$domains	private	property
AbstractOperation::$messages	protected	property
AbstractOperation::$result	protected	property
AbstractOperation::$source	protected	property
AbstractOperation::$target	protected	property
AbstractOperation::getDomains	public	function	Returns domains affected by operation. Overrides OperationInterface::getDomains
AbstractOperation::getMessages	public	function	Returns all valid messages after operation. Overrides OperationInterface::getMessages
AbstractOperation::getNewMessages	public	function	Returns new messages after operation. Overrides OperationInterface::getNewMessages
AbstractOperation::getObsoleteMessages	public	function	Returns obsolete messages after operation. Overrides OperationInterface::getObsoleteMessages
AbstractOperation::getResult	public	function	Returns resulting catalogue. Overrides OperationInterface::getResult
AbstractOperation::processDomain	abstract protected	function		2
AbstractOperation::__construct	public	function