private function xmlToArray(\SimpleXMLIterator $sxi)
{
$a = array();
for ($sxi->rewind(); $sxi->valid(); $sxi->next()) {
$t = array();
$current = $sxi->current();
$attributes = $current->attributes();
$name = isset($attributes->_key) ? strval($attributes->_key) : $sxi->key();
// save attributes
foreach ($attributes as $att_key => $att_value) {
if ($att_key !== '_key') {
$t[$att_key] = strval($att_value);
}
}
// we parse nodes
if ($sxi->hasChildren()) {
// children
$t = array_merge($t, $this->xmlToArray($current));
} else {
// it's a leaf
if (empty($t)) {
$t = strval($current);
// strval will call _toString()
} else {
$t['_value'] = strval($current);
// strval will call _toString()
}
}
$a[$name] = $t;
}
return $a;
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$fileInfo = new \SplFileInfo($this->getContainer()->getParameter('kernel.root_dir') . '/../web/sitemap.xml');
if ($fileInfo->isFile() && $fileInfo->isReadable()) {
$output->write('Reading sitemap.xml...');
$file = $fileInfo->openFile();
$xml = '';
while (!$file->eof()) {
$xml .= $file->fgets();
}
$output->writeln(' done.');
$output->write('Updating sitemap.xml...');
$sitemap = new \SimpleXMLIterator($xml);
$sitemap->rewind();
$lastmodDate = new \DateTime();
$lastmodDate->sub(new \DateInterval('P1D'));
$lastmodDateFormatted = $lastmodDate->format('Y-m-d');
while ($sitemap->valid()) {
$sitemap->current()->lastmod = $lastmodDateFormatted;
$sitemap->next();
}
$file = $file->openFile('w');
$file->fwrite($sitemap->asXML());
$output->writeln(' done.');
} else {
$output->writeln('Error: Cannot open file web/sitemap.xml');
}
}
/**
* Create the ResultSet
*
* @param object $result
* @return void
*/
public function __construct($result)
{
$xmlIterator = new \SimpleXMLIterator($result);
for ($xmlIterator->rewind(); $xmlIterator->valid(); $xmlIterator->next()) {
$temp = new \stdClass();
foreach ($xmlIterator->getChildren()->attributes() as $name => $value) {
switch ($name) {
case 'orderId':
case 'brokerTicketId':
case 'quantity':
case 'purchaseOrderId':
$temp->{$name} = (int) $value;
break;
case 'cost':
$temp->{$name} = (double) $value;
break;
case 'electronicDelivery':
$temp->{$name} = (bool) $value;
break;
default:
$temp->{$name} = (string) $value;
}
}
$this->_results[] = $temp;
}
unset($xmlIterator, $temp, $name, $value);
}
function get_elements_from_supplied_file($file)
{
$found_elements = array();
if ($xml = file_get_contents($file)) {
//print_r($xml);
//SimpleXMLIterator just runs over the xml and returns the elements found in this file. I think this is just top level
//which is what I want.
//echo $xml;
/* Some safety against XML Injection attack
* see: http://phpsecurity.readthedocs.org/en/latest/Injection-Attacks.html
*
* Attempt a quickie detection of DOCTYPE - discard if it is present (cos it shouldn't be!)
*/
$collapsedXML = preg_replace("/[[:space:]]/", '', $xml);
//echo $collapsedXML;
if (preg_match("/<!DOCTYPE/i", $collapsedXML)) {
//throw new InvalidArgumentException(
// 'Invalid XML: Detected use of illegal DOCTYPE'
// );
//echo "fail";
return FALSE;
}
$loadEntities = libxml_disable_entity_loader(true);
$dom = new DOMDocument();
$dom->loadXML($xml);
foreach ($dom->childNodes as $child) {
if ($child->nodeType === XML_DOCUMENT_TYPE_NODE) {
throw new Exception\ValueException('Invalid XML: Detected use of illegal DOCTYPE');
libxml_disable_entity_loader($loadEntities);
return FALSE;
}
}
libxml_disable_entity_loader($loadEntities);
//Iterate over elements now
if (simplexml_import_dom($dom)) {
$xmlIterator = new SimpleXMLIterator($xml);
for ($xmlIterator->rewind(); $xmlIterator->valid(); $xmlIterator->next()) {
foreach ($xmlIterator->getChildren() as $name => $data) {
//echo "The $name is '$data' from the class " . get_class($data) . "\n";
$found_elements[] = $name;
}
}
} else {
return FALSE;
}
}
return $found_elements;
}
protected function parseDependencyType(\SimpleXMLIterator $iterator, DependencyCollection $dependencies, $required = true)
{
$iterator->rewind();
while ($iterator->valid()) {
$elt = $iterator->current();
$name = $elt->getName();
$iterator->next();
if ($name === 'php') {
$dependencies->import($this->parsePhpCondition($elt));
} elseif ($name === 'pearinstaller') {
// Let's just ignore this for now!
} else {
// TODO do not ignore recommended, nodefault and uri, providesextension
$identifier = 'pear2://' . (string) $elt->channel . '/' . (string) $elt->name;
$dependencies[] = new Dependency($identifier, isset($elt->min) ? (string) $elt->min : null, isset($elt->max) ? (string) $elt->max : null, isset($elt->conflicts) ? Dependency::CONFLICT : ($required ? Dependency::REQUIRED : Dependency::OPTIONAL));
foreach ($elt->exclude as $exclude) {
$dependencies[] = new Dependency($identifier, (string) $exclude, (string) $exclude, Dependency::CONFLICT);
}
}
}
}
<pre>
<?php
$xml = <<<XML
<books>
<book>
<title>PHP Basics</title>
<author>Jim Smith</author>
</book>
<book>XML basics</book>
</books>
XML;
$xmlIterator = new SimpleXMLIterator($xml);
//books
for ($xmlIterator->rewind(); $xmlIterator->valid(); $xmlIterator->next()) {
foreach ($xmlIterator->getChildren() as $name => $data) {
echo "The {$name} is '{$data}' from the class " . get_class($data) . "\n";
}
echo $xmlIterator->getName() . "\n";
//2 times of books will be print out
}
?>
</pre>
}*/
echo '----------------------------------- DirectoryIterator END ---------------------------------', '<br />';
echo '--------------------------------- SimpleXMLIterator START-----------------------------------', '<br />';
/**
* SimpleXMLIterator 遍历xml文件
*
*/
try {
$xmlString = file_get_contents('spl.xml');
$simpleIt = new SimpleXMLIterator($xmlString);
// 循环所有的节点
foreach (new RecursiveIteratorIterator($simpleIt, 1) as $name => $data) {
//echo $name, '=>', $data, "<br />";
}
// while 循环
$simpleIt->rewind();
while ($simpleIt->valid()) {
/*var_dump($simpleIt->key());
echo '=>';
var_dump($simpleIt->current());*/
// getChildren() 获得当前节点的子节点
if ($simpleIt->hasChildren()) {
//var_dump($simpleIt->getChildren());
}
$simpleIt->next();
}
// xpath 可以通过path直接获得指定节点的值
var_dump($simpleIt->xpath('animal/category/species'));
} catch (Exception $e) {
echo $e->getMessage();
}
/**
* Parses object. Turns raw XML(NPRML) into various object properties.
*/
function parse()
{
if (!empty($this->xml)) {
$xml = $this->xml;
} else {
$this->notices[] = 'No XML to parse.';
return;
}
$object = simplexml_load_string($xml);
$this->add_simplexml_attributes($object, $this);
if (!empty($object->message)) {
$this->message->id = $this->get_attribute($object->message, 'id');
$this->message->level = $this->get_attribute($object->message, 'level');
}
if (!empty($object->list->story)) {
foreach ($object->list->story as $story) {
$parsed = new NPRMLEntity();
$this->add_simplexml_attributes($story, $parsed);
//Iterate trough the XML document and list all the children
$xml_iterator = new SimpleXMLIterator($story->asXML());
$key = NULL;
$current = NULL;
for ($xml_iterator->rewind(); $xml_iterator->valid(); $xml_iterator->next()) {
$current = $xml_iterator->current();
$key = $xml_iterator->key();
if ($key == 'image' || $key == 'audio' || $key == 'link') {
// images
if ($key == 'image') {
$parsed->{$key}[] = $this->parse_simplexml_element($current);
}
// audio
if ($key == 'audio') {
$parsed->{$key}[] = $this->parse_simplexml_element($current);
}
// links
if ($key == 'link') {
$type = $this->get_attribute($current, 'type');
$parsed->{$key}[$type] = $this->parse_simplexml_element($current);
}
} else {
//if ->$key exist, see if it's an array. if it is, add the next child.
if (!empty($parsed->{$key})) {
//if it's not an array, make an array, add the existing element to it
if (!is_array($parsed->{$key})) {
$parsed->{$key} = array($parsed->{$key});
}
// then add the new child.
$parsed->{$key}[] = $this->parse_simplexml_element($current);
} else {
//The key wasn't parsed already, so just add the current element.
$parsed->{$key} = $this->parse_simplexml_element($current);
}
}
}
$body = '';
if (!empty($parsed->textWithHtml->paragraphs)) {
foreach ($parsed->textWithHtml->paragraphs as $paragraph) {
$body = $body . $paragraph->value . "\n\n";
}
}
$parsed->body = $body;
$this->stories[] = $parsed;
}
//if the query didn't have a sort parameter, reverse the order so that we end up with
//stories in reverse-chron order.
//there are no params and 'sort=' is not in the URL
if (empty($this->request->params) && !stristr($this->request->request_url, 'sort=')) {
$this->stories = array_reverse($this->stories);
}
//there are params, and sort is not one of them
if (!empty($this->request->params) && !array_key_exists('sort', $this->request->params)) {
$this->stories = array_reverse($this->stories);
}
}
}
/**
* (PHP 5 >= 5.0.0)<br/>
* Rewind the Iterator to the first element
* @link http://php.net/manual/en/iterator.rewind.php
* @return void Any returned value is ignored.
*/
public function rewind()
{
$this->_current = null;
$this->_xmlIterator->rewind();
}
function rewind()
{
echo __METHOD__ . "\n";
return parent::rewind();
}
/**
*
* Realiza busca no xmlRoot pelas referências de arquivo
* @return \stdClass
*/
public function find()
{
$get = self::$_config['attrs']->src->root;
$xmlIterator = new SimpleXMLIterator(self::$_config['valueObject']->get());
$references = "";
for ($xmlIterator->rewind(); $xmlIterator->valid(); $xmlIterator->next()) {
foreach ($xmlIterator->getChildren() as $name => $data) {
$references .= '<reference>' . $data . '</reference>';
}
}
$result = new \stdClass();
$result->references = $references;
return $result;
}
/**
* @param SimpleXMLIterator $sxi
*/
public function sxiToArray($sxi)
{
$a = array();
for ($sxi->rewind(); $sxi->valid(); $sxi->next()) {
if (!array_key_exists($sxi->key(), $a)) {
$a[$sxi->key()] = array();
}
if ($sxi->hasChildren()) {
$a[$sxi->key()]['children'] = $this->sxiToArray($sxi->current());
} else {
$a[$sxi->key()][] = strval($sxi->current());
}
}
return $a;
}
private function ParseXML($data_content)
{
$xmlIterator = new SimpleXMLIterator($data_content);
$xmlIterator->rewind();
$xmlIterator->next();
while ($xmlIterator->current() != Null) {
$current = $xmlIterator->current();
$Item = $this->ParsePerItem($current);
$Parsed[$Item["sku"]] = $Item;
$xmlIterator->next();
}
return $Parsed;
}
unlink(COOKIE_FILE);
die("Cannot log in to BGZ!" . PHP_EOL);
}
if (!$quiet) {
printf("Done." . PHP_EOL . "Getting cash import file list ... ");
}
$files = get_files();
if (!$files) {
unlink(COOKIE_FILE);
die("Cannot get file list!" . PHP_EOL);
}
if (!$quiet) {
printf("Done." . PHP_EOL);
}
$xml = new SimpleXMLIterator($files);
$xml->rewind();
while ($xml->valid()) {
if ($xml->key() == "rows") {
$rows = $xml->getChildren();
$rows->rewind();
while ($rows->valid()) {
if ($rows->key() == "row") {
$fileid = $filename = NULL;
$props = $rows->getChildren();
$props->rewind();
while ($props->valid()) {
switch ($props->key()) {
case "id":
$fileid = strval($props->current());
break;
case "file_name":
/**
* Converts a SimpleXMLIterator structure into an associative array.
*
* Used to parse an XML response from Mollom servers into a PHP array. For
* example:
* @code
* $elements = new SimpleXmlIterator($response_body);
* $parsed_response = $this->parseXML($elements);
* @endcode
*
* @param SimpleXMLIterator $sxi
* A SimpleXMLIterator structure of the server response body.
*
* @return array
* An associative, possibly multidimensional array.
*/
public static function parseXML(SimpleXMLIterator $sxi)
{
$a = array();
$remove = array();
for ($sxi->rewind(); $sxi->valid(); $sxi->next()) {
$key = $sxi->key();
// Recurse into non-scalar values.
if ($sxi->hasChildren()) {
$value = self::parseXML($sxi->current());
} else {
$value = strval($sxi->current());
}
if (!isset($a[$key])) {
$a[$key] = $value;
} else {
// First time we reach here, convert the existing keyed item. Do not
// remove $key, so we enter this path again.
if (!isset($remove[$key])) {
$a[] = $a[$key];
// Mark $key for removal.
$remove[$key] = $key;
}
// Add the new item.
$a[] = $value;
}
}
// Lastly, remove named keys that have been converted to indexed keys.
foreach ($remove as $key) {
unset($a[$key]);
}
return $a;
}
<pre>
<?php
$xmlIterator = new SimpleXMLIterator('<books><book>PHP basics</book><book>XML basics</book></books>');
var_dump($xmlIterator->current());
$xmlIterator->rewind();
// rewind to first element
var_dump($xmlIterator->current());
/**
* NULL
object(SimpleXMLIterator)#2 (0) {
}
*/
?>
</pre>
/**
* Converts SimpleXMLIterator object into an array.
* @param SimpleXMLIterator $xmlIterator
* @return string[]
*/
public function simplexmlToArray($xmlIterator)
{
$xmlStringArray = array();
for ($xmlIterator->rewind(); $xmlIterator->valid(); $xmlIterator->next()) {
if ($xmlIterator->hasChildren()) {
$object = $xmlIterator->current();
$xmlStringArray[$object->getName()] = $this->simplexmlToArray($object);
} else {
$object = $xmlIterator->current();
$xmlStringArray[$object->getName()] = (string) $xmlIterator->current();
}
}
return $xmlStringArray;
}
/**
* Convert XML iterator to array
*
* @static
* @param \SimpleXMLIterator $xml
* @param null $ns
* @return array
*/
public static function xmlToArray(\SimpleXMLIterator $xml, $ns = null)
{
$a = [];
for ($xml->rewind(); $xml->valid(); $xml->next()) {
$key = $xml->key();
if (!isset($a[$key])) {
$a[$key] = [];
}
foreach ($xml->current()->attributes() as $k => $v) {
$a[$key][self::INDEX_ATTRIBUTES][$k] = (string) $v;
}
if ($ns) {
foreach ($ns as $name) {
foreach ($xml->current()->attributes($name) as $k => $v) {
$a[$key][self::INDEX_ATTRIBUTES][$k] = (string) $v;
}
}
}
if ($xml->hasChildren()) {
$a[$key][self::INDEX_CONTENT] = self::xmlToArray($xml->current(), $ns);
} else {
$a[$key][self::INDEX_CONTENT] = strval($xml->current());
}
}
return $a;
}