abstract class AbstractEntry in Zircon Profile 8.0

Hierarchy

• class \Zend\Feed\Reader\Entry\AbstractEntry

File

vendor/zendframework/zend-feed/src/Reader/Entry/AbstractEntry.php, line 18

Namespace

Zend\Feed\Reader\Entry

abstract class AbstractEntry {

  /**
   * Feed entry data
   *
   * @var array
   */
  protected $data = [];

  /**
   * DOM document object
   *
   * @var DOMDocument
   */
  protected $domDocument = null;

  /**
   * Entry instance
   *
   * @var DOMElement
   */
  protected $entry = null;

  /**
   * Pointer to the current entry
   *
   * @var int
   */
  protected $entryKey = 0;

  /**
   * XPath object
   *
   * @var DOMXPath
   */
  protected $xpath = null;

  /**
   * Registered extensions
   *
   * @var array
   */
  protected $extensions = [];

  /**
   * Constructor
   *
   * @param  DOMElement $entry
   * @param  int $entryKey
   * @param  string $type
   */
  public function __construct(DOMElement $entry, $entryKey, $type = null) {
    $this->entry = $entry;
    $this->entryKey = $entryKey;
    $this->domDocument = $entry->ownerDocument;
    if ($type !== null) {
      $this->data['type'] = $type;
    }
    elseif ($this->domDocument !== null) {
      $this->data['type'] = Reader\Reader::detectType($this->domDocument);
    }
    else {
      $this->data['type'] = Reader\Reader::TYPE_ANY;
    }
    $this
      ->loadExtensions();
  }

  /**
   * Get the DOM
   *
   * @return DOMDocument
   */
  public function getDomDocument() {
    return $this->domDocument;
  }

  /**
   * Get the entry element
   *
   * @return DOMElement
   */
  public function getElement() {
    return $this->entry;
  }

  /**
   * Get the Entry's encoding
   *
   * @return string
   */
  public function getEncoding() {
    $assumed = $this
      ->getDomDocument()->encoding;
    if (empty($assumed)) {
      $assumed = 'UTF-8';
    }
    return $assumed;
  }

  /**
   * Get entry as xml
   *
   * @return string
   */
  public function saveXml() {
    $dom = new DOMDocument('1.0', $this
      ->getEncoding());
    $deep = version_compare(PHP_VERSION, '7', 'ge') ? 1 : true;
    $entry = $dom
      ->importNode($this
      ->getElement(), $deep);
    $dom
      ->appendChild($entry);
    return $dom
      ->saveXml();
  }

  /**
   * Get the entry type
   *
   * @return string
   */
  public function getType() {
    return $this->data['type'];
  }

  /**
   * Get the XPath query object
   *
   * @return DOMXPath
   */
  public function getXpath() {
    if (!$this->xpath) {
      $this
        ->setXpath(new DOMXPath($this
        ->getDomDocument()));
    }
    return $this->xpath;
  }

  /**
   * Set the XPath query
   *
   * @param  DOMXPath $xpath
   * @return AbstractEntry
   */
  public function setXpath(DOMXPath $xpath) {
    $this->xpath = $xpath;
    return $this;
  }

  /**
   * Get registered extensions
   *
   * @return array
   */
  public function getExtensions() {
    return $this->extensions;
  }

  /**
   * Return an Extension object with the matching name (postfixed with _Entry)
   *
   * @param string $name
   * @return Reader\Extension\AbstractEntry
   */
  public function getExtension($name) {
    if (array_key_exists($name . '\\Entry', $this->extensions)) {
      return $this->extensions[$name . '\\Entry'];
    }
    return;
  }

  /**
   * Method overloading: call given method on first extension implementing it
   *
   * @param  string $method
   * @param  array $args
   * @return mixed
   * @throws Exception\RuntimeException if no extensions implements the method
   */
  public function __call($method, $args) {
    foreach ($this->extensions as $extension) {
      if (method_exists($extension, $method)) {
        return call_user_func_array([
          $extension,
          $method,
        ], $args);
      }
    }
    throw new Exception\RuntimeException(sprintf('Method: %s does not exist and could not be located on a registered Extension', $method));
  }

  /**
   * Load extensions from Zend\Feed\Reader\Reader
   *
   * @return void
   */
  protected function loadExtensions() {
    $all = Reader\Reader::getExtensions();
    $manager = Reader\Reader::getExtensionManager();
    $feed = $all['entry'];
    foreach ($feed as $extension) {
      if (in_array($extension, $all['core'])) {
        continue;
      }
      $plugin = $manager
        ->get($extension);
      $plugin
        ->setEntryElement($this
        ->getElement());
      $plugin
        ->setEntryKey($this->entryKey);
      $plugin
        ->setType($this->data['type']);
      $this->extensions[$extension] = $plugin;
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
AbstractEntry::$data	protected	property	Feed entry data
AbstractEntry::$domDocument	protected	property	DOM document object
AbstractEntry::$entry	protected	property	Entry instance
AbstractEntry::$entryKey	protected	property	Pointer to the current entry
AbstractEntry::$extensions	protected	property	Registered extensions
AbstractEntry::$xpath	protected	property	XPath object
AbstractEntry::getDomDocument	public	function	Get the DOM
AbstractEntry::getElement	public	function	Get the entry element
AbstractEntry::getEncoding	public	function	Get the Entry's encoding
AbstractEntry::getExtension	public	function	Return an Extension object with the matching name (postfixed with _Entry)
AbstractEntry::getExtensions	public	function	Get registered extensions
AbstractEntry::getType	public	function	Get the entry type
AbstractEntry::getXpath	public	function	Get the XPath query object
AbstractEntry::loadExtensions	protected	function	Load extensions from Zend\Feed\Reader\Reader
AbstractEntry::saveXml	public	function	Get entry as xml
AbstractEntry::setXpath	public	function	Set the XPath query	2
AbstractEntry::__call	public	function	Method overloading: call given method on first extension implementing it
AbstractEntry::__construct	public	function	Constructor	2