PHP SimpleXmlElement::asXml方法代码示例

/** @Assertions(2) */
function test()
{
    $x = new SimpleXmlElement();
    $a = $x->asXml();
    $b = $x->asXml(__FILE__);
    /** @type string|false */
    $a;
    /** @type boolean */
    $b;
}

 public function fetch($params)
 {
     $feed = null;
     //debug($params);
     if (isset($params['source'])) {
         $handle = fopen($params['source'], "rb");
         $feed = stream_get_contents($handle);
         fclose($handle);
     } else {
         echo 'A source is required.';
     }
     //debug($feed);
     $feed = new SimpleXmlElement($feed);
     if (isset($params['limit']) and $params['limit'] > 0) {
         // Not possible in SimpleXmlElement objects
     }
     //debug($feed); exit;
     if (isset($params['raw']) and $params['raw'] === true) {
         echo $feed->asXml();
     }
     if (isset($params['convert']) and $params['convert'] == 'json') {
         $feed = $this->convertToJson($feed->asXml());
     }
     //debug($feed);
     echo $feed;
 }

 /**
  * @param ExerciseCompleted $event
  */
 public function afterExercise(ExerciseCompleted $event)
 {
     $dom = new \DOMDocument('1.0');
     $dom->preserveWhitespace = false;
     $dom->formatOutput = true;
     $dom->loadXml($this->xml->asXml());
     $this->printer->write($dom->saveXML());
 }

 public function asXml()
 {
     $xml = new SimpleXmlElement("<blueprint></blueprint>");
     $xml->addAttribute("key", $this->getKey());
     $xml->addAttribute("type", "form");
     $xml->addAttribute("name", $this->getName());
     foreach ($this->fields() as $field) {
         $f = $xml->addChild("field");
         $f->addAttribute("key", $field->getKey());
         $f->addChild("displayName", $field->getDisplayName());
         $f->addChild("format", $field->getFormat());
         $f->addChild("href", $field->getHref());
     }
     return $xml->asXml();
 }

 public function serialize($fmt, $app)
 {
     if (trim($fmt) === '') {
         $fmt = 'application/json';
     }
     $types = explode(',', $fmt);
     $count = count($types);
     $base = $app->request->getUrl() . $app->request->getRootUri();
     for ($i = 0; $i < $count; $i++) {
         if (strstr($types[$i], 'application/xml') !== false) {
             $app->response->headers->set('Content-Type', 'application/xml;odata.metadata=minimal');
             $xml = new SimpleXmlElement('<?xml version="1.0" encoding="utf-8"?><service/>');
             $xml->addAttribute('xmlns', 'http://www.w3.org/2007/app');
             $xml->addAttribute('xmlns:atom', 'http://www.w3.org/2005/Atom');
             $xml->addAttribute('xmlns:m', 'http://docs.oasis-open.org/odata/ns/metadata');
             $xml->addAttribute('xml:base', $base);
             $xml->addAttribute('m:context', $base . '/$metadata');
             $workspace = $xml->addChild('workspace');
             $title = $workspace->addChild('atom:title', 'Default');
             $title->addAttribute('type', 'text');
             foreach ($this->collections as $collection) {
                 $col = $workspace->addChild('collection');
                 $col->addAttribute('href', $collection->getUrl());
                 $title = $col->addChild('atom:title', $collection->getName());
                 $title->addAttribute('type', 'text');
             }
             echo $xml->asXml();
             return;
         } else {
             if (strstr($types[$i], 'application/json') !== false) {
                 $app->response->headers->set('Content-Type', 'application/json;odata.metadata=minimal');
                 $resp = array();
                 $resp['@odata.context'] = $base . '/$metadata';
                 $collections = array();
                 foreach ($this->collections as $collection) {
                     array_push($collections, array('name' => $collection->getName(), 'kind' => 'EntitySet', 'url' => $collection->getUrl()));
                 }
                 $resp['value'] = $collections;
                 echo json_encode($resp);
                 return;
             }
         }
     }
     $app->response->setStatus(406);
     echo 'Unknown format for Service Doc: ' . $fmt;
     error_log($fmt);
 }

 public function asXml()
 {
     $xml = new SimpleXmlElement("<blueprint></blueprint>");
     $xml->addAttribute("key", $this->getKey());
     $xml->addAttribute("type", "join");
     foreach ($this->fields() as $field) {
         $f = $xml->addChild("field");
         $f->addAttribute("key", $field->getKey());
         $f->addChild("displayName", $field->getDisplayName());
         $f->addChild("dataType", $field->getDataType());
         if ($field->isRequired()) {
             $f->addChild("required", "true");
         } else {
             $f->addChild("required", "false");
         }
         $f->addChild("minimum", $field->getMin());
         $f->addChild("maximum", $field->getMax());
         if ($field->isUnique()) {
             $f->addChild("unique", "true");
         } else {
             $f->addChild("unique", "false");
         }
         $f->addChild("example", $field->getExample());
         $f->addChild("foreignKey", $field->getForeignKey());
         $f->addChild("foreignValue", $field->getForeignValue());
         switch ($field->getDataType()) {
             case "string":
                 $f->addChild("encType", $field->getEncType());
                 $f->addChild("regexp", $field->getRegexp());
                 break;
             case "decimal":
                 $f->addChild("precision", $field->getPrecision());
                 break;
             case "enum":
                 $e = $f->addChild("enumOptions");
                 foreach ($field->getEnumOptions() as $option) {
                     $o = $e->addChild("option", $option);
                 }
                 break;
             case "text":
             case "binary":
                 $f->addChild("mimeType", $field->getMimeType());
                 break;
         }
     }
     return $xml->asXml();
 }

 /**
  * Get the help as an xml string.
  *
  * @param boolean $string
  *        	Return the SimpleXml object or a string. Defaults to true.
  * @return mixed. See $string
  */
 public function xml($string = true)
 {
     $parser = $this->_parser;
     $xml = new SimpleXmlElement('<shell></shell>');
     $xml->addChild('command', $parser->command());
     $xml->addChild('description', $parser->description());
     $xml->addChild('epilog', $parser->epilog());
     $subcommands = $xml->addChild('subcommands');
     foreach ($parser->subcommands() as $command) {
         $command->xml($subcommands);
     }
     $options = $xml->addChild('options');
     foreach ($parser->options() as $option) {
         $option->xml($options);
     }
     $arguments = $xml->addChild('arguments');
     foreach ($parser->arguments() as $argument) {
         $argument->xml($arguments);
     }
     return $string ? $xml->asXml() : $xml;
 }

 /**
  *	function parse()
  *	Gera um rss a partir de uma busca
  *	@version
  *	    0.1 03/06/2009  Método inicial
  *	    1.0 16/05/2010  Método refatorado completamente, renomeado, trocados
  *	        seus parâmetros, etc.
  *	
  *	@param $model O model a ser feita a busca
  *	@param $params Os parâmetros para a busca, será passado diretamente
  *	para o Model::all()
  */
 public function parse($model, $params = array())
 {
     //fazendo a busca
     $this->results = Loader::instance('Model', $model)->all($params);
     //pegando somente os campos
     $this->fields = !empty($this->results) ? array_keys(reset($this->results)) : array();
     //Limpando os campos "relations" que não existem em $this->allowedItems
     foreach ($this->config['relations'] as $key => $value) {
         if (!in_array($key, $this->allowedItems)) {
             unset($this->config['relations'][$key]);
         }
     }
     //Criando o cabeçalho
     $rss = new SimpleXmlElement('<?xml version="1.0" encoding="UTF-8" ?><rss xmlns:atom="http://www.w3.org/2005/Atom"></rss>');
     $rss->addAttribute('version', '2.0');
     $channel = $rss->addChild('channel');
     //verificando pelas tags permitidas, evitará a
     //inclusão de tags inválidas e poupará vários IFs.
     foreach ($this->allowedHeaders as $header) {
         if (!empty($this->config['headers'][$header])) {
             $channel->addChild($header, $this->format($this->config['headers'][$header], $header));
         }
     }
     //Procuro nos resultados
     foreach ($this->results as $row => $result) {
         $item = $channel->addChild("item");
         foreach ($this->config['relations'] as $key => $field) {
             $item->addChild($key, $this->format(String::insert($field, $result), $key));
             //                $item->addChild($key, $this->format($this->extract($field, $row), $key));
         }
     }
     return $rss->asXml();
 }

 function parseFormattedText($inputText, $bookName = "")
 {
     // Trim the carriage return characters in the input text
     $inputText = $this->trimCarriageReturns($inputText);
     // Get the line of $inputText
     $inputTextArray = explode("\n", $inputText);
     // Create root node
     $book = new SimpleXmlElement("<book></book>");
     $conjunctionAvailable = False;
     $currentChapter = "";
     $currentVerse = "";
     $currentClause = "";
     for ($i = 0; $i < count($inputTextArray); $i++) {
         $line = $inputTextArray[$i];
         $line = $this->trimSpaces($line);
         // Clause
         if (!$this->isLineNewChapterVerse($line) && !$this->isLineConjunction($line)) {
             $currentClause = $book->addChild("clause");
             //$currentClause->addChild("conj", "X");
             // Add text to the current clause
             $text = $currentClause->addChild("text", $line);
             // Set chapter and verse to the current chapter and verse
             $this->addChapterVerse($text, $currentChapter, $currentVerse);
         } else {
             if ($this->isLineConjunction($line)) {
                 // Add <conj> and </conj> tags into new clause
                 $currentClause = $book->addChild("clause");
                 // Add conj to current clause
                 $currentClause->addChild("conj", $line);
             } else {
                 // Store chapter, verse, and conj into variables
                 $chapterVerseConj = $this->getChapterVerseConj($line);
                 $chapter = $chapterVerseConj['chapter'];
                 $verse = $chapterVerseConj['verse'];
                 $conj = $chapterVerseConj['conj'];
                 // Set the chapter and verse to the current chapter and verse
                 $currentChapter = $chapter;
                 $currentVerse = $verse;
                 // Create a new clause for the conj
                 $currentClause = $book->addChild("clause");
                 // Add conj to current clause
                 $currentClause->addChild("conj", $conj);
                 $text = $currentClause->addChild("text", " ");
                 $this->addChapterVerse($text, $currentChapter, $currentVerse);
             }
         }
     }
     // After looping through the file, get the xml string
     $xml = $book->asXml();
     $pconjs = $this->getPconjList();
     return "{$pconjs}\n{$xml}";
 }

 /**
  * @param $root
  * @param $type
  * @param $href
  * @param $content
  *
  * @return mixed
  */
 private function create_xml($root, $type, $href, $content)
 {
     global $client;
     $xml = new SimpleXmlElement('<' . $root . ' />');
     $xml->addAttribute('Type', $type);
     $xml->addAttribute('xmlns', 'http://www.veeam.com/ent/v1.0');
     $xml->addAttribute('xmlns:xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance');
     $xml->addAttribute('Href', $this->client->getBaseUrl() . "{$href}");
     $content = array_flip($content);
     array_walk_recursive($content, array($xml, 'addChild'));
     return $xml->asXml();
 }

 /**
 	Build an XML-RPC HTTP request for an XML-RPC call.
 
 	Parameters:
  		methodName - (string) name of the XML-RPC method to call
  		parameters - (array) parameters for the call
 
 	Returns:
 		(string) HTTP header + body
 */
 protected function _buildRequest($methodName, array $parameters = array())
 {
     if (!preg_match('~^[a-z0-9_.:/]+$~i', $methodName)) {
         throw new OpenReact_XmlRpc_Client_InvalidMethodNameException('The method name `%s` contains invalid characters.', array($methodName));
     }
     $methodCall = new SimpleXmlElement('<?xml version="1.0" encoding="' . self::ENCODING . '"?><methodCall></methodCall>');
     $methodCall->addChild('methodName', $methodName);
     $methodCall->addChild('params');
     foreach ($parameters as $value) {
         $param = $methodCall->params->addChild('param');
         $this->_encodeParam($param, $value);
     }
     $endpoint = parse_url($this->_endpoint);
     $body = $methodCall->asXml();
     $userAgent = 'OpenReact-XmlRpcClient/' . self::VERSION;
     if (isset($this->_userAgentSuffix)) {
         $userAgent .= ' ' . $this->_userAgentSuffix;
     }
     $headers = array('Host' => $endpoint['host'], 'User-Agent' => $userAgent, 'Content-Type' => 'text/xml;chartype=' . self::ENCODING, 'Content-Length' => strlen($body));
     $request = 'POST ' . $endpoint['path'] . ' HTTP/1.0' . "\r\n";
     foreach ($headers as $name => $value) {
         $request .= sprintf("%s: %s\r\n", $name, $value);
     }
     $request .= "\r\n" . $body;
     return $request;
 }

 function build($args)
 {
     if (isset($args["Parts"])) {
         $parts = $args["Parts"];
         $xml = new SimpleXmlElement('<CompleteMultipartUpload></CompleteMultipartUpload>');
         if (is_array($parts)) {
             foreach ($parts as $part) {
                 $partXml = $xml->addChild("Part");
                 foreach ($part as $key => $value) {
                     if (in_array($key, Consts::$PartsElement)) {
                         $partXml->addChild($key, $value);
                     }
                 }
             }
         }
         return $xml->asXml();
     }
 }

 /**
  * Returns the object as XML.
  *
  * @return string The response as an XML string
  */
 public function __toString()
 {
     $xml = $this->element->asXml();
     return str_replace('<?xml version="1.0" ?>', '<?xml version="1.0" encoding="UTF-8" ?>', $xml);
 }

 /**
  * Processa todas as informações e devolve o Xml
  * 
  * @version
  *     0.1 19/05/2010
  *         Inicial
  *     0.2 02/11/2010
  *         Modificado o uso para SimpleXml
  *  
  * @return string Xml contendo o sitemap já pronto
  */
 public function parse()
 {
     //Criando o cabeçalho
     $sitemap = new SimpleXmlElement('<?xml version="1.0" encoding="UTF-8" ?><urlset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd" xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"></urlset>');
     //parseando as páginas
     foreach ($this->output as $items) {
         $url = $sitemap->addChild('url');
         foreach ($items as $key => $part) {
             $url->addChild($key, $part);
         }
     }
     return $sitemap->asXml();
 }