/**
  * Remove all empty elements
  *
  * @param DOMNodeList $DOMNodeList The list of all elements we are checking
  * @return DOMNodeList The modified list of all remaining elements
  */
 protected function _filter_empty_elements(DOMNodeList $DOMNodeList)
 {
     $NodeListIndex = 0;
     // We might reduce $DOMNodeList->length during the loop
     for ($NodeListIndex = 0; $NodeListIndex < $DOMNodeList->length; ++$NodeListIndex) {
         $DOMNode = $DOMNodeList->item($NodeListIndex);
         if (!isset($DOMNode->nodeName) || !in_array($DOMNode->nodeName, $this->_checkTagNames, true)) {
             continue;
         }
         // Climb up to make sure we’re not in an Instant Article element (which should have proper handling elsewhere)
         $parentNode = $DOMNode;
         while (isset($parentNode->nodeName) && $parentNode->nodeName != 'body') {
             if ('figure' == $parentNode->nodeName && false !== strpos($parentNode->getAttribute('class'), 'op-')) {
                 // We found an element that’s likely to be an Instant Article element
                 continue 2;
             }
             $parentNode = $parentNode->parentNode;
         }
         // Check all childnodes first
         if (is_a($DOMNode, 'DOMElement') && isset($DOMNode->childNodes) && is_a($DOMNode->childNodes, 'DOMNodeList')) {
             $this->_filter_empty_elements($DOMNode->childNodes);
         }
         if (isset($DOMNode->nodeValue) && '' == trim($DOMNode->nodeValue)) {
             if (!isset($DOMNode->childNodes) || is_null($DOMNode->childNodes) || is_a($DOMNode->childNodes, 'DOMNodeList') && !$DOMNode->childNodes->length) {
                 // If the element is an empty node, remove it. But we must have a parentNode to remove a node
                 if (is_a($DOMNode->parentNode, 'DOMElement')) {
                     $DOMNode->parentNode->removeChild($DOMNode);
                 }
             }
         }
     }
     return $DOMNodeList;
 }

 /**
  * @param DOMNodeList $nodeList
  */
 protected function iterate(DOMNodeList $nodeList)
 {
     for ($i = 0; $i < $nodeList->length; $i++) {
         $node = $nodeList->item($i);
         $this->childrenVisitor->visit($node);
     }
 }

 /**
  * Get single dom node value from node list at 0-index, or null when empty result
  *
  * @param \DOMNodeList $item
  * @throws \Exception
  * @return string|null
  */
 protected function getDomNodeValue(\DOMNodeList $item)
 {
     if ($item->length == 0) {
         return null;
     }
     return $item->item(0) instanceof \DOMAttr ? trim($item->item(0)->value) : trim($item->item(0)->nodeValue);
 }

 /**
  * Transforms DOMNodeList to array of posts
  *
  * @param  DOMNodeList $nodeList
  * @return void
  */
 private function constructFromNodeList(\DOMNodeList $nodeList)
 {
     for ($i = 0; $i < $nodeList->length; $i++) {
         $curentNode = $nodeList->item($i);
         if ($curentNode->nodeName == 'post') {
             $this->addPost(new Post($this->service, $curentNode));
         }
     }
 }

 /**
  * Transforms DOMNodeList to array of posts
  *
  * @param  DOMNodeList $nodeList
  * @return void
  */
 private function _constructFromNodeList(DOMNodeList $nodeList)
 {
     for ($i = 0; $i < $nodeList->length; $i++) {
         $curentNode = $nodeList->item($i);
         if ($curentNode->nodeName == 'post') {
             $this->_addPost(new Zend_Service_Delicious_Post($this->_service, $curentNode));
         }
     }
 }

 /**
  * Check if tagName from $nodes are correct depending on $name
  *
  * @param DOMNodeList $nodes to check
  * @param string      $name  to compare with tagName
  *
  * @return array of nodes with correct $name
  */
 public static function filterNodeListByName($nodes, $name)
 {
     $res = array();
     for ($i = 0; $i < $nodes->length; $i++) {
         if ($nodes->item($i)->tagName === $name) {
             $res[] = $nodes->item($i);
         }
     }
     return $res;
 }

 /**
  * Fix a list of nodes corresponding to an array of objects.
  *
  * @param \DOMNodeList $nodeList the node list matching <var>$objects</var>
  * @param array $objects the objects array matching <var>$nodeList</var>
  * @param \DOMXPath $xpath the xpath object representing the DOM
  */
 private function FixXmlNodes(\DOMNodeList $nodeList, array $objects, \DOMXPath $xpath)
 {
     if ($nodeList->length == sizeof($objects)) {
         $i = 0;
         foreach ($objects as $object) {
             $this->FixXmlNode($nodeList->item($i), $object, $xpath);
             $i++;
         }
     }
 }

 /**
  * 
  * @param DOMNodeList $nodeList
  * @return type
  */
 public static function getFirstElement($nodeList)
 {
     if ($nodeList instanceof \DOMNodeList) {
         if ($nodeList->length > 0x0) {
             return $nodeList->item(0x0);
         } else {
             return null;
         }
     }
 }

 /**
  * Add all nodes from the fixtures xml document.
  *
  * If the root node is not called jcr:root, autogenerate a root node.
  *
  * @param string       $workspaceName
  * @param \DOMNodeList $nodes
  *
  * @return DBUnitFixtureXML
  */
 public function addNodes($workspaceName, \DOMNodeList $nodes)
 {
     $node = $nodes->item(0);
     if ('jcr:root' !== $node->getAttributeNS($this->namespaces['sv'], 'name')) {
         $this->addRootNode('tests');
     }
     foreach ($nodes as $node) {
         $this->addNode($workspaceName, $node);
     }
     return $this;
 }

 public static function getElementByNodeName(DOMNodeList $nodeList, $nodeName)
 {
     for ($i = 0; $i < $nodeList->length; $i++) {
         /*DOMNode*/
         $item = $nodeList->item($i);
         if (self::cleearNS($item->nodeName) == $nodeName) {
             return self::getDOMDocument($item);
         }
     }
     return null;
 }

 /**
  * Dispatch each element in the nodelist to the transformer
  *
  * Note that we work directly on the DOMNodeList itself. Objects are passed by ref.
  *
  * @since 0.1
  * @param DOMNodeList  $DOMNodeList  List of images
  * @return DOMNodeList  The DOMNodeList. If you want to chain.
  */
 protected function _transform_elements(DOMNodeList $DOMNodeList)
 {
     // A foreach won’t work as we are changing the elements
     for ($i = 0; $i < $DOMNodeList->length; ++$i) {
         $origLength = $DOMNodeList->length;
         $this->_transform_element($DOMNodeList->item($i));
         if ($origLength !== $DOMNodeList->length) {
             // The element is replaced by an element of another type and is no longer in the nodelist
             --$i;
         }
     }
     return $DOMNodeList;
 }

 /**
  *
  * @param DOMNodeList $node        	
  */
 private function parseRelease($node)
 {
     $extra = $node->item(3)->nodeValue;
     if (strlen($extra)) {
         list($size, $files) = explode("|", $extra);
         $size = trim($size);
         $files = trim($files);
     }
     $entry = new Release();
     $entry->release = $node->item(2)->nodeValue;
     $entry->type = $node->item(1)->nodeValue;
     $entry->date = new DateTime($node->item(0)->nodeValue, new DateTimeZone('UTC'));
     $entry->size = intval($size) * 1024 * 1024;
     // as bytes
     $entry->files = intval($files);
     $entry->nuke = $node->item(4)->nodeValue;
     return $entry;
 }

 /**
  * @param \DOMNodeList $list
  * @param null $parentEvent
  */
 protected function transcodeList(\DOMNodeList $list, $parentEvent = null)
 {
     $i = 0;
     while ($node = $list->item($i)) {
         switch ($node->nodeType) {
             case XML_TEXT_NODE:
                 $event = new TranscodeTextEvent($node, $parentEvent, $i);
                 $this->transcodeTextNode($event);
                 break;
             case XML_ELEMENT_NODE:
                 $event = new TranscodeElementEvent($node, $parentEvent, $i);
                 $this->transcodeElementNode($event);
                 break;
             default:
                 // ?
         }
         $i++;
     }
 }

 /**
  * @param DOMNodeList $node
  */
 private function parseRelease($node)
 {
     //		$extra = $node->item(3)->nodeValue;
     //		if (strlen($extra)) {
     //			list ($size, $files) = explode("|", $extra);
     //			$size = trim($size);
     //			$files = trim($files);
     //		}
     $entry =& new Pre_Release();
     $entry->release = $node->item(1)->nodeValue;
     $entry->type = $node->item(0)->nodeValue;
     if ($node->length == 3) {
         $entry->date = strtotime(substr($node->item(2)->nodeValue, 4)) + $vbulletin->options['release_time_offset'];
     } else {
         $entry->size = intval($node->item(2)->nodeValue) * 1024 * 1024;
         //as bytes
         $entry->files = intval($files);
     }
     return $entry;
 }

 /**
  * 
  * @param DOMNodeList $elements
  * @return multitype:multitype:NULL
  */
 protected function xmlToArray($elements)
 {
     if ($elements instanceof DOMNodeList) {
         if ($elements->length == 1) {
             return $this->xmlToArray($elements->item(0));
         } else {
             $result = array();
             foreach ($elements as $element) {
                 $result[] = $this->xmlToArray($element);
             }
             return $result;
         }
     } elseif ($elements instanceof DOMNode) {
         if ($elements->hasChildNodes()) {
             $result = array();
             foreach ($elements->childNodes as $element) {
                 if ($element->nodeType != 3) {
                     if (isset($result[$element->nodeName])) {
                         if (is_array($result[$element->nodeName]) && !self::isAssociative($result[$element->nodeName])) {
                             $result[$element->nodeName][] = $this->xmlToArray($element);
                         } else {
                             $v = $result[$element->nodeName];
                             $result[$element->nodeName] = array();
                             $result[$element->nodeName][] = $v;
                             $result[$element->nodeName][] = $this->xmlToArray($element);
                         }
                     } else {
                         $result[$element->nodeName] = $this->xmlToArray($element);
                     }
                 }
             }
             if (count($result) == 0) {
                 return $elements->nodeValue;
             } else {
                 return $result;
             }
         } else {
             return $elements->nodeValue;
         }
     }
 }

 /**
  * The Instant Articles spec says we can only use each image once.
  *
  * @param DOMNodeList $DOMNodeList the list of images in the document
  * @return DOMNodeList The modified list of images in the document
  */
 protected function _filter_multiple_uses(DOMNodeList $DOMNodeList)
 {
     $used_images = array();
     $NodeListIndex = 0;
     // We’ll increase $NodeListIndex and/or reduce $DOMNodeList->length
     while ($NodeListIndex < $DOMNodeList->length) {
         $DOMNode = $DOMNodeList->item($NodeListIndex);
         $src = $DOMNode->getAttribute('src');
         // See how far up the tree we can go
         $removeDOMNode = $DOMNode;
         while ('body' != $removeDOMNode->parentNode->nodeName && 1 === $removeDOMNode->parentNode->childNodes->length) {
             $removeDOMNode = $removeDOMNode->parentNode;
         }
         // If the image is used already, remove it
         if (in_array($src, $used_images, true)) {
             // Please note that when we remove the node, $DOMNodeList->length is n-1. Our $NodeListIndex will thus point to the next item in the list.
             $removeDOMNode->parentNode->removeChild($removeDOMNode);
         }
         // Add the src to the stack so we can check for multiple uses later
         $used_images[] = $src;
         ++$NodeListIndex;
     }
     return $DOMNodeList;
 }

 /**
  * @param UCS $ucs
  * @param \DOMNodeList $cols
  * @param \DomXPath $xpath
  */
 function __construct($ucs, $cols, $xpath)
 {
     $this->ucs = $ucs;
     $this->contract_id = $ucs->getContractId();
     $date_str = $cols->item(0)->nodeValue;
     list($date_str) = explode("*", $date_str, 2);
     $this->date = new \DateTime($date_str);
     $this->currency = $cols->item(1)->nodeValue;
     $this->total_amount = floatval(str_replace(" ", "", $cols->item(2)->nodeValue));
     $this->total_commission = floatval(str_replace(" ", "", $cols->item(3)->nodeValue));
     $link = $cols->item(6);
     while (!$link->getAttribute("href")) {
         $link = $link->firstChild;
     }
     $this->terminals_url = UCS::URL_REPORTS . $link->getAttribute("href");
 }

 /**
  * Start the cleaning with tags, then we move onto attributes and hrefs later
  *
  * @param \DOMNodeList $elements
  */
 protected function startClean(\DOMNodeList $elements)
 {
     // loop through all elements
     // we do this backwards so we don't skip anything if we delete a node
     // see comments at: http://php.net/manual/en/class.domnamednodemap.php
     for ($i = $elements->length - 1; $i >= 0; $i--) {
         $currentElement = $elements->item($i);
         // If the tag isn't in the whitelist, remove it and continue with next iteration
         if (!in_array($currentElement->tagName, $this->allowedTags)) {
             $currentElement->parentNode->removeChild($currentElement);
             continue;
         }
         $this->cleanAttributesOnWhitelist($currentElement);
         $this->cleanXlinkHrefs($currentElement);
         $this->cleanHrefs($currentElement);
     }
 }

 /**
  * Find where to start, iterate through a list, add elements to a
  * new DomDocument, return resulting xhtml
  *
  * @param \DOMNodeList $dom_list
  * @param int $index
  * @param string $chapter_title
  *
  * @return string XHTML
  */
 protected function getChapter(\DOMNodeList $dom_list, $index, $chapter_title)
 {
     if ('' == $chapter_title) {
         $chapter_title = 'unknown';
     }
     $chapter = new \DOMDocument('1.0', 'UTF-8');
     // create a new node element
     $root = $chapter->createElement('div');
     $root->setAttribute('class', $chapter_title);
     $chapter->appendChild($root);
     // Start at the beginning if no h1 tags are found.
     // In other words...bring in the whole document.
     '__UNKNOWN__' == $chapter_title ? $i = 0 : ($i = $index);
     do {
         $node = $chapter->importNode($dom_list->item($i), true);
         $chapter->documentElement->appendChild($node);
         $i++;
         // TODO
         // This is problematic
         // DOMNodeList can be made up of DOMElement(s)
         // *and* DOMText(s) which do not have the property ->tagName
     } while (@$dom_list->item($i)->tagName != $this->tag && $i < $dom_list->length);
     // h1 tag will not be needed in the body of the html
     $h1 = $chapter->getElementsByTagName($this->tag)->item(0);
     // removeChild is quick to throw a fatal error
     if ($h1 && $this->tag == $h1->nodeName && 'div' == $h1->parentNode->nodeName) {
         $chapter->documentElement->removeChild($h1);
     }
     // hyperlinks
     $chapter = $this->addHyperlinks($chapter);
     // footnotes
     $chapter = $this->addFootnotes($chapter);
     $result = $chapter->saveHTML($chapter->documentElement);
     // appendChild brings over the namespace which is superfluous on every html element
     // the string below is from the xslt file
     // @see includes/modules/import/ooxml/xsl/docx2html.xsl
     $result = preg_replace('/xmlns="http:\\/\\/www.w3.org\\/1999\\/xhtml"/', '', $result);
     return $result;
 }

 public function processEntries(DOMNodeList $entries, DOMElement $feed, $source)
 {
     for ($i = 0; $i < $entries->length; $i++) {
         $entry = $entries->item($i);
         try {
             $this->processEntry($entry, $feed, $source);
         } catch (AlreadyFulfilledException $e) {
             common_debug('We already had this entry: ' . $e->getMessage());
         } catch (ServerException $e) {
             // FIXME: This should be UnknownUriException and the ActivityUtils:: findLocalObject should only test one URI
             common_log(LOG_ERR, 'Entry threw exception while processing a feed from ' . $source . ': ' . $e->getMessage());
         }
     }
 }