PHP XMLWriter::setIndentString方法代码示例

 protected function setupStoreData()
 {
     // Using XMLWriter because SimpleXML namespaces on attribute names
     $this->doc = new XMLWriter();
     $this->doc->openMemory();
     $this->doc->setIndent(true);
     $this->doc->setIndentString('    ');
     $this->doc->startDocument('1.0', 'UTF-8');
     $this->doc->startElement('feed');
     $this->doc->writeAttribute('xmlns', 'http://www.w3.org/2005/Atom');
     $this->doc->writeAttribute('xmlns:g', 'http://base.google.com/ns/1.0');
     $this->doc->writeElement('title', $this->getConfig('title'));
     $this->doc->startElement('link');
     $this->doc->writeAttribute('rel', 'self');
     $this->doc->writeAttribute('href', $this->_store->getBaseUrl());
     $this->doc->endElement();
     $date = new Zend_Date();
     $this->doc->writeElement('updated', $date->get(Zend_Date::ATOM));
     $this->doc->startElement('author');
     $this->doc->writeElement('name', $this->getConfig('author'));
     $this->doc->endElement();
     $url = $this->_store->getBaseUrl();
     $day = $date->toString('yyyy-MM-dd');
     $path = $this->getConfig('output');
     $filename = $path . '/' . str_replace('+', '-', strtolower(urlencode($this->_store->getName()))) . '-products.xml';
     $this->doc->writeElement('id', 'tag:' . $url . ',' . $day . ':' . $filename);
 }

 /**
  * Create new XMLWriter
  *
  * @param int $tempLocation Temporary storage location
  * @param string $tempFolder Temporary storage folder
  */
 public function __construct($tempLocation = self::STORAGE_MEMORY, $tempFolder = './')
 {
     // Create internal XMLWriter
     $this->xmlWriter = new \XMLWriter();
     // Open temporary storage
     if ($tempLocation == self::STORAGE_MEMORY) {
         $this->xmlWriter->openMemory();
     } else {
         // Create temporary filename
         $this->tempFile = @tempnam($tempFolder, 'xml');
         // Open storage
         if ($this->xmlWriter->openUri($this->tempFile) === false) {
             // Fallback to memory...
             $this->xmlWriter->openMemory();
         }
     }
     // Set xml Compatibility
     $compatibility = Settings::getCompatibility();
     if ($compatibility) {
         $this->xmlWriter->setIndent(false);
         $this->xmlWriter->setIndentString('');
     } else {
         $this->xmlWriter->setIndent(true);
         $this->xmlWriter->setIndentString('  ');
     }
 }

 /**
  * Create a new PHPPowerPoint_Shared_XMLWriter instance
  *
  * @param int		$pTemporaryStorage			Temporary storage location
  * @param string	$pTemporaryStorageFolder	Temporary storage folder
  */
 public function __construct($pTemporaryStorage = self::STORAGE_MEMORY, $pTemporaryStorageFolder = './')
 {
     // Create internal XMLWriter
     $this->_xmlWriter = new XMLWriter();
     // Open temporary storage
     if ($pTemporaryStorage == self::STORAGE_MEMORY) {
         $this->_xmlWriter->openMemory();
     } else {
         // Create temporary filename
         $this->_tempFileName = @tempnam($pTemporaryStorageFolder, 'xml');
         // Open storage
         if ($this->_xmlWriter->openUri($this->_tempFileName) === false) {
             // Fallback to memory...
             $this->_xmlWriter->openMemory();
         }
     }
     // Set default values
     // proposed to be false in production version
     $this->_xmlWriter->setIndent(true);
     //$this->_xmlWriter->setIndent(false);
     // Set indent
     // proposed to be '' in production version
     $this->_xmlWriter->setIndentString('  ');
     //$this->_xmlWriter->setIndentString('');
 }

 /**
  * Create new XMLWriter
  *
  * @param int $tempLocation Temporary storage location
  * @param string $tempFolder Temporary storage folder
  */
 public function __construct($tempLocation = self::STORAGE_MEMORY, $tempFolder = './')
 {
     // Create internal XMLWriter
     $this->xmlWriter = new \XMLWriter();
     // Open temporary storage
     if ($tempLocation == self::STORAGE_MEMORY) {
         $this->xmlWriter->openMemory();
     } else {
         // Create temporary filename
         $this->tempFile = @tempnam($tempFolder, 'xml');
         // Fallback to memory when temporary file cannot be used
         // @codeCoverageIgnoreStart
         // Can't find any test case. Uncomment when found.
         if ($this->xmlWriter->openUri($this->tempFile) === false) {
             $this->xmlWriter->openMemory();
         }
         // @codeCoverageIgnoreEnd
     }
     // Set xml Compatibility
     $compatibility = Settings::hasCompatibility();
     if ($compatibility) {
         $this->xmlWriter->setIndent(false);
         $this->xmlWriter->setIndentString('');
     } else {
         $this->xmlWriter->setIndent(true);
         $this->xmlWriter->setIndentString('  ');
     }
 }

 /**
  * Set and instantiate new UTF-8 XML document
  */
 public function __construct()
 {
     $this->context = new \XMLWriter();
     $this->context->openMemory();
     $this->context->startDocument('1.0', 'UTF-8');
     $this->context->setIndent(true);
     $this->context->setIndentString("  ");
 }

 /**
  * Converts array with export data to XML format.
  *
  * @param array $array
  *
  * @return string
  */
 public function write(array $array)
 {
     $this->xmlWriter->openMemory();
     $this->xmlWriter->setIndent($this->formatOutput);
     $this->xmlWriter->setIndentString('    ');
     $this->xmlWriter->startDocument('1.0', 'UTF-8');
     $this->fromArray($array);
     $this->xmlWriter->endDocument();
     return $this->xmlWriter->outputMemory();
 }

 /**
  * Defined by ReportInterface.
  *
  * @see ReportInterface::start()
  */
 public function start()
 {
     $this->writer = new XMLWriter();
     $this->writer->openMemory();
     $this->writer->setIndent(true);
     $this->writer->setIndentString('    ');
     $this->writer->startDocument('1.0', 'UTF-8');
     $this->writer->startElement('checkstyle');
     $this->writer->writeAttribute('version', '5.5');
 }

 public function initialize(Config $config, $directory, $filenameWithDate = false)
 {
     $this->setFilename($config, $directory, $filenameWithDate);
     $this->xml = new \XMLWriter();
     $this->xml->openUri($this->filename);
     $this->xml->startDocument('1.0', 'utf-8');
     $this->xml->setIndent(true);
     $this->xml->setIndentString('    ');
     $this->xml->writeComment('list of ' . $config->getClassName());
     $this->elementName = strtolower($config->getClassNameLastPart());
     $this->xml->startElement(strtolower($config->getClassNameLastPart(true)));
 }

 /**
  * @param Definition $definition
  * @param \XMLWriter $writer
  */
 protected function initialize($writer, Definition $definition)
 {
     $writer->setIndent(true);
     $writer->setIndentString("    ");
     $writer->startDocument("1.0", "UTF-8");
     $writer->startElement($definition->getNodeName() ?: "root");
 }

 /**
  * Creates a new XML document.
  * 
  * @param	string		$rootElement
  * @param	string		$namespace
  * @param	string		$schemaLocation
  * @param	array<string>	$attributes
  */
 public function beginDocument($rootElement, $namespace, $schemaLocation, array $attributes = array())
 {
     if ($this->activeDocument) {
         throw new SystemException("Could not begin a new document unless the previous is finished");
     }
     if ($this->xml === null) {
         $this->xml = new \XMLWriter();
         $this->xml->openMemory();
         $this->xml->setIndent(true);
         $this->xml->setIndentString("\t");
     }
     $this->xml->startDocument('1.0', 'UTF-8');
     $this->startElement($rootElement);
     $attributes = array_merge($attributes, array('xmlns' => $namespace, 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance', 'xsi:schemaLocation' => $namespace . ' ' . $schemaLocation));
     $this->writeAttributes($attributes);
     $this->activeDocument = true;
 }

 public function testSetRebateName()
 {
     $xml = new \XMLWriter();
     $xml->openMemory();
     $xml->setIndent(true);
     $xml->setIndentString("\t");
     $node = new RebateType();
     $this->setExpectedException('InvalidArgumentException');
     $node->setRebateName(str_repeat('x', 300));
 }

 /**
  * 
  */
 function __construct($config = array())
 {
     if (!class_exists('XMLWriter')) {
         require_once 'Spizer/Logger/Exception.php';
         throw new Spizer_Logger_Exception('The XMLWriter PHP extension is not loaded');
     }
     $this->_config = array_merge($this->_config, $config);
     $this->_writer = new XMLWriter();
     if (!$this->_writer->openUri($this->_config['target'])) {
         require_once 'Spizer/Logger/Exception.php';
         throw new Spizer_Logger_Exception('Cannot open log file "' . $this->_config['target'] . '" for writing');
     }
     $this->_writer->setIndent($this->_config['indent']);
     $this->_writer->setIndentString($this->_config['indentstr']);
     $this->_writer->startDocument('1.0', 'UTF-8');
     $this->_writer->startElement('spizerlog');
     $this->_writer->writeAttribute('xmlns', 'http://arr.gr/spizer/xmllog/1.0');
     $this->_writer->writeAttribute('microtime', microtime(true));
 }

 public function testSetStandardProductId()
 {
     $xml = new \XMLWriter();
     $xml->openMemory();
     $xml->setIndent(true);
     $xml->setIndentString("\t");
     $node = new StandardProductId();
     $this->setExpectedException('InvalidArgumentException');
     $node->setType('Foo');
 }

 /**
  * Execute parsing
  *
  * @param \PhpHal\Resource $resource
  * @return mixed
  */
 public function execute(Resource $resource)
 {
     $writer = new BasicXmlWriter();
     $writer->openMemory();
     $writer->setIndentString('  ');
     $writer->setIndent($this->pretty);
     $writer->startDocument('1.0');
     $this->resourceToArray($writer, $resource);
     return $writer->outputMemory();
 }

 /**
  * @param string $resource
  */
 private function writeTo($resource)
 {
     $this->writer->openURI($resource);
     $this->writer->startDocument($this->version, $this->encoding);
     $this->writer->setIndent(true);
     $this->writer->setIndentString("\t");
     $this->getRoot()->save($this->writer);
     $this->writer->endDocument();
     $this->writer->flush();
 }