/**
  * create jasper config information used for input for executing the report
  *
  * @param string $report_source full path to the jrxml-report definition file
  *
  * @return array Array with referense to the config-file and report name
  */
 protected static function _create_jasper_info($report_source)
 {
     $info = pathinfo($report_source);
     $base_name = basename($report_source, '.' . $info['extension']);
     $report_name = "report_{$base_name}";
     $memory = xmlwriter_open_memory();
     xmlwriter_start_document($memory, '1.0', 'UTF-8');
     xmlwriter_start_element($memory, 'JasperConfig');
     // <JasperConfig>
     xmlwriter_start_element($memory, 'Reports');
     // <Reports>
     xmlwriter_start_element($memory, 'Report');
     // <Report>
     xmlwriter_write_attribute($memory, 'name', $report_name);
     xmlwriter_write_attribute($memory, 'source', $report_source);
     xmlwriter_end_element($memory);
     // </Report>
     xmlwriter_end_element($memory);
     // </Reports>
     xmlwriter_end_element($memory);
     // </JasperConfig>
     $xml = xmlwriter_output_memory($memory, true);
     $jasper_info = array('config' => $GLOBALS['phpgw_info']['server']['temp_dir'] . '/' . uniqid('config_') . "{$base_name}.xml", 'report_name' => $report_name);
     $fp = fopen($jasper_info['config'], "wb");
     fwrite($fp, $xml);
     if (!fclose($fp)) {
         throw new Exception('jasper_wrapper::create_jasper_config did not write any config file');
     }
     return $jasper_info;
 }

 /**
  * Make recursive elements
  * @param   array   $data   Data
  */
 function dataElement($data, $last_tag)
 {
     if (!empty($data)) {
         foreach ($data as $key => $val) {
             $last_tag = !is_int($key) ? $key : $last_tag;
             if ($last_tag != '') {
                 if (is_scalar($val) || is_null($val)) {
                     xmlwriter_start_element($this->xml, $last_tag);
                     $this->xmlwriter_write_cdata($val);
                     xmlwriter_end_element($this->xml);
                 } elseif (is_array($val)) {
                     if (!is_int(key($val))) {
                         xmlwriter_start_element($this->xml, $last_tag);
                         $this->dataElement($val, $last_tag);
                         xmlwriter_end_element($this->xml);
                     } else {
                         $this->dataElement($val, $last_tag);
                     }
                 }
             }
         }
     }
 }

<?php

$file = dirname(__FILE__) . '/010.tmp';
$xw = xmlwriter_open_uri($file);
var_dump(xmlwriter_start_element($xw, "tag"));
var_dump(xmlwriter_start_attribute($xw, "attr"));
var_dump(xmlwriter_end_attribute($xw));
var_dump(xmlwriter_start_attribute($xw, "-1"));
var_dump(xmlwriter_end_attribute($xw));
var_dump(xmlwriter_start_attribute($xw, "\""));
var_dump(xmlwriter_end_attribute($xw));
var_dump(xmlwriter_end_element($xw));
unset($xw);
var_dump(file_get_contents($file));
@unlink($file);
echo "Done\n";

<?php

/* $Id$ */
/*
Libxml 2.6.24 and up adds a new line after a processing instruction (PI)
*/
$xw = xmlwriter_open_memory();
xmlwriter_set_indent($xw, TRUE);
xmlwriter_start_document($xw, NULL, "UTF-8");
xmlwriter_start_element($xw, 'root');
xmlwriter_write_attribute($xw, 'id', 'elem1');
xmlwriter_start_element($xw, 'elem1');
xmlwriter_write_attribute($xw, 'attr1', 'first');
xmlwriter_write_comment($xw, 'start PI');
xmlwriter_start_element($xw, 'pi');
xmlwriter_write_pi($xw, 'php', 'echo "hello world"; ');
xmlwriter_end_element($xw);
xmlwriter_start_element($xw, 'cdata');
xmlwriter_start_cdata($xw);
xmlwriter_text($xw, '<>&"');
xmlwriter_end_cdata($xw);
xmlwriter_end_element($xw);
xmlwriter_end_element($xw);
xmlwriter_end_element($xw);
xmlwriter_end_document($xw);
// Force to write and empty the buffer
$output = xmlwriter_flush($xw, true);
print $output;

 /**
  * We want to check that we get the expected structure from
  * xmlwriter & an idea of how it works, once we have this
  * down we can start working on the actual methods needed
  * to authenticate.
  *
  */
 function testXMLWriterCanCreateOurNeededXML()
 {
     $xml = xmlwriter_open_memory();
     xmlwriter_start_element($xml, 'Authentication');
     xmlwriter_write_element($xml, 'client', 'blah');
     xmlwriter_write_element($xml, 'password', 'blah');
     xmlwriter_end_element($xml);
     $result = xmlwriter_output_memory($xml, true);
     $expected = '<Authentication><client>blah</client><password>blah</password></Authentication>';
     $this->assertContains('Authentication', $result);
     $this->assertXmlStringEqualsXmlString($expected, $result);
 }

<?php

/* $Id$ */
$doc_dest = '001.xml';
$xw = xmlwriter_open_uri($doc_dest);
xmlwriter_start_dtd($xw, 'foo', NULL, 'urn:bar');
xmlwriter_end_dtd($xw);
xmlwriter_start_element($xw, 'foo');
xmlwriter_write_element_ns($xw, 'foo', 'bar', 'urn:foo', 'dummy content');
xmlwriter_end_element($xw);
// Force to write and empty the buffer
$output_bytes = xmlwriter_flush($xw, true);
echo file_get_contents($doc_dest);
unset($xw);
unlink('001.xml');

<?php

/* $Id$ */
$xw = xmlwriter_open_memory();
xmlwriter_set_indent($xw, TRUE);
xmlwriter_set_indent_string($xw, '   ');
xmlwriter_start_document($xw, '1.0', "UTF-8");
xmlwriter_start_element($xw, 'root');
xmlwriter_start_element_ns($xw, 'ns1', 'child1', 'urn:ns1');
xmlwriter_write_attribute_ns($xw, 'ns1', 'att1', 'urn:ns1', '<>"\'&');
xmlwriter_write_element($xw, 'chars', "special characters: <>\"'&");
xmlwriter_end_element($xw);
xmlwriter_end_document($xw);
// Force to write and empty the buffer
$output = xmlwriter_flush($xw, true);
print $output;

<?php

$xw = xmlwriter_open_memory();
xmlwriter_start_document($xw, NULL, "UTF-8");
xmlwriter_start_dtd($xw, "root");
xmlwriter_write_dtd_entity($xw, "ent2", "val2");
xmlwriter_end_dtd($xw);
xmlwriter_start_element($xw, "root");
xmlwriter_end_document($xw);
print xmlwriter_flush($xw, true);
print "\n";
$xw = new XMLWriter();
$xw->openMemory();
$xw->startDocument(NULL, "UTF-8");
$xw->startDtd("root");
$xw->writeDtdEntity("c", NULL, 0, "-//W3C//TEXT copyright//EN", "http://www.w3.org/xmlspec/copyright.xml");
$xw->endDtd();
$xw->startElement("root");
$xw->endDocument();
print $xw->flush(true);

xmlwriter_start_document($xw, '1.0', 'UTF-8');
// A first element
xmlwriter_start_element($xw, 'tag1');
// Attribute 'att1' for element 'tag1'
xmlwriter_start_attribute($xw, 'att1');
xmlwriter_text($xw, 'valueofatt1');
xmlwriter_end_attribute($xw);
xmlwriter_write_comment($xw, 'this is a comment.');
// Start a child element
xmlwriter_start_element($xw, 'tag11');
xmlwriter_text($xw, utf8_encode('This is a sample text, ä'));
xmlwriter_end_element($xw);
// tag11
xmlwriter_end_element($xw);
// tag1
// CDATA
xmlwriter_start_element($xw, 'testc');
xmlwriter_write_cdata($xw, "This is a cdata content");
xmlwriter_end_element($xw);
// testctag
xmlwriter_start_element($xw, 'testc');
xmlwriter_start_cdata($xw);
xmlwriter_text($xw, "test cdata2");
xmlwriter_end_cdata($xw);
xmlwriter_end_element($xw);
// testctag
// A processing instruction
xmlwriter_start_pi($xw, 'php');
xmlwriter_text($xw, '$foo=2;echo $foo;');
xmlwriter_end_pi($xw);
xmlwriter_end_document($xw);

<?php

$xw = xmlwriter_open_memory();
xmlwriter_set_indent($xw, TRUE);
xmlwriter_start_document($xw, NULL, "UTF-8");
xmlwriter_start_element($xw, 'root');
xmlwriter_write_attribute_ns($xw, 'prefix', '', 'http://www.php.net/uri');
xmlwriter_start_element($xw, 'elem1');
xmlwriter_write_attribute($xw, 'attr1', 'first');
xmlwriter_end_element($xw);
xmlwriter_full_end_element($xw);
xmlwriter_end_document($xw);
$output = xmlwriter_flush($xw, true);
print $output;
// write attribute_ns without start_element first
$xw = xmlwriter_open_memory();
var_dump(xmlwriter_write_attribute_ns($xw, 'prefix', 'id', 'http://www.php.net/uri', 'elem1'));
print xmlwriter_output_memory($xw);

<?php

/* $Id$ */
$xw = xmlwriter_open_memory();
xmlwriter_set_indent($xw, TRUE);
xmlwriter_set_indent_string($xw, '   ');
xmlwriter_start_document($xw, '1.0', "UTF-8");
xmlwriter_start_element($xw, 'root');
xmlwriter_start_element_ns($xw, 'ns1', 'child1', 'urn:ns1');
xmlwriter_write_attribute_ns($xw, 'ns1', 'att1', 'urn:ns1', '<>"\'&');
xmlwriter_write_element($xw, 'chars', "special characters: <>\"'&");
xmlwriter_end_element($xw);
xmlwriter_start_element($xw, 'empty');
xmlwriter_full_end_element($xw);
xmlwriter_full_end_element($xw);
// Force to write and empty the buffer
$output = xmlwriter_flush($xw, true);
print $output;

<?php

$writer = xmlwriter_open_memory();
xmlwriter_set_indent_string($writer, '#');
// The second arg is supposedly required. But just keep executing anyway and use
// the previous value...
xmlwriter_set_indent_string($writer);
xmlwriter_set_indent($writer, true);
xmlwriter_start_document($writer, '1.0');
xmlwriter_start_element($writer, 'foo');
xmlwriter_start_element($writer, 'bar');
xmlwriter_end_element($writer);
xmlwriter_end_element($writer);
xmlwriter_end_document($writer);
var_dump(xmlwriter_output_memory($writer));

VERIFY(xmlwriter_write_element($xml, "subnode", "some text"));
VERIFY(xmlwriter_end_element($xml));
VERIFY(xmlwriter_start_element_ns($xml, "fb", "node", "http://www.facebook.com/"));
VERIFY(xmlwriter_write_attribute_ns($xml, "fb", "attr", "http://www.facebook.com/", "value"));
VERIFY(xmlwriter_start_attribute_ns($xml, "fb", "attr2", "http://www.facebook.com/"));
VERIFY(xmlwriter_end_attribute($xml));
VERIFY(xmlwriter_write_element_ns($xml, "prefix", "name", "http://some.url/", 1337));
VERIFY(xmlwriter_start_element($xml, "node"));
VERIFY(xmlwriter_full_end_element($xml));
VERIFY(xmlwriter_end_element($xml));
VERIFY(xmlwriter_start_element($xml, "node"));
VERIFY(xmlwriter_start_cdata($xml));
VERIFY(xmlwriter_text($xml, "Raw text"));
VERIFY(xmlwriter_end_cdata($xml));
VERIFY(xmlwriter_end_element($xml));
VERIFY(xmlwriter_start_element($xml, "node"));
VERIFY(xmlwriter_write_cdata($xml, "More CDATA"));
VERIFY(xmlwriter_end_element($xml));
VERIFY(xmlwriter_start_comment($xml));
VERIFY(xmlwriter_text($xml, "Comments"));
VERIFY(xmlwriter_end_comment($xml));
VERIFY(xmlwriter_write_comment($xml, "More comments"));
VERIFY(xmlwriter_start_pi($xml, "lol"));
VERIFY(xmlwriter_end_pi($xml));
VERIFY(xmlwriter_write_pi($xml, "php", "print 'Hello world!';"));
VERIFY(xmlwriter_write_raw($xml, "<node>Raw XML</node>"));
VERIFY(xmlwriter_write_dtd($xml, "name", "publicID", "systemID", "subset"));
VERIFY(xmlwriter_start_dtd($xml, "name", "publicID", "systemID"));
VERIFY(xmlwriter_end_dtd($xml));
VERIFY(xmlwriter_start_dtd_element($xml, "name"));
VERIFY(xmlwriter_end_dtd_element($xml));

/**
 * Renders an xml_element structure to XMLWriter memory. This
 * basically acts as a wrapper for api_xml2_render_object, first
 * parsing through xml_element layers and then calling api_xml2_render_object
 * to actually render the objects and arrays found.
 *
 * @param $xml_memory the xmlwriter memory to use (created with xmlwriter_open_memory())
 * @param $object     the xml_element to be rendered
 */
function api_xml3_render_object($xml_memory, $object)
{
    if (is_array($object->value) && isset($object->value[0]) && $object->value[0] instanceof xml_element) {
        xmlwriter_start_element($xml_memory, $object->name);
        if (isset($object->attrs)) {
            foreach ($object->attrs as $k => $v) {
                xmlwriter_write_attribute($xml_memory, $k, $v);
            }
        }
        foreach ($object->value as $elem) {
            api_xml3_render_object($xml_memory, $elem);
        }
        xmlwriter_end_element($xml_memory);
    } else {
        api_xml2_render_object($xml_memory, $object->name, $object->value, $object->attrs);
    }
}

<?php

/* $Id$ */
$doc_dest = '001.xml';
$xw = xmlwriter_open_memory($doc_dest);
xmlwriter_start_document($xw, '1.0', 'UTF-8');
xmlwriter_start_element($xw, "tag1");
xmlwriter_end_document($xw);
// Force to write and empty the buffer
echo xmlwriter_flush($xw, true);
?>
===DONE===

<?php

$xw = xmlwriter_open_uri('./a.xml');
xmlwriter_set_indent($xw, 1);
$res = xmlwriter_set_indent_string($xw, ' ');
xmlwriter_start_document($xw, '1.0', 'utf8');
// A first element
xmlwriter_start_element($xw, 'tag1');
// Attribute 'att1' for element 'tag1'
xmlwriter_start_attribute($xw, 'att1');
xmlwriter_text($xw, 'valueofatt1');
xmlwriter_end_attribute($xw);
xmlwriter_write_comment($xw, 'this is a comment.');
// Start a child element
xmlwriter_start_element($xw, 'tag11');
xmlwriter_text($xw, utf8_encode('This is a sample text, ä'));
xmlwriter_end_element($xw);
// tag11
xmlwriter_end_element($xw);
// tag1
// partial example

 /**
  * Sets our 3DSecure request to confirm the transaction.
  *
  * @param string $pares
  * @param string $reference
  * @param string $method
  * @return SimpleXML
  * 
  */
 function set3DSecureAuthRequest($pares, $reference, $method = 'deposits')
 {
     if (is_null($pares) || empty($pares)) {
         throw new Zend_Exception('PaRes is not set');
     }
     if (strlen($reference) !== 16) {
         throw new Zend_Exception('Reference must be 16 characters long');
     }
     $xml = xmlwriter_open_memory();
     xmlwriter_start_element($xml, 'Request');
     $auth = $this->_handleAuth($method);
     xmlwriter_write_raw($xml, $auth);
     xmlwriter_start_element($xml, 'Transaction');
     xmlwriter_start_element($xml, 'HistoricTxn');
     xmlwriter_write_element($xml, 'reference', $reference);
     xmlwriter_start_element($xml, 'method');
     xmlwriter_write_attribute($xml, 'tx_status_u', 'accept');
     xmlwriter_write_raw($xml, 'threedsecure_authorization_request');
     xmlwriter_end_element($xml);
     xmlwriter_write_element($xml, 'pares_message', $pares);
     xmlwriter_end_element($xml);
     xmlwriter_end_element($xml);
     xmlwriter_end_element($xml);
     return xmlwriter_output_memory($xml, true);
 }

 /**
  * Take an array of any size, and make it into xml
  * @param xmlwriter	An xmlwriter instance
  * @param array			The array which is to be transformed
  * @param mixed			Either a string, or an array of elements defining element names for each level in the XML hierarchy
  *									 In the case of multiple lists of differently titled items at the same level, adding an array inside the array will allow for this to be constructed.
  * @param int				Internal use (the index of the child item in question - corresponds to the index in the second level array above)
  */
 public function toxml($writer, $data, $node, $childindex = 0)
 {
     $nodename = $node;
     if (is_array($node)) {
         $nodename = array_shift($node);
     }
     $childcount = -1;
     foreach ($data as $key => $value) {
         $childcount++;
         if (is_numeric($key)) {
             if (is_array($nodename)) {
                 $key = $nodename[$childindex];
             } else {
                 $key = $nodename;
             }
         }
         if (is_array($value)) {
             xmlwriter_start_element($writer, $key);
             $this->toxml($writer, $value, $node, $childcount);
             xmlwriter_end_element($writer);
         } else {
             xmlwriter_write_element($writer, $key, $value);
         }
     }
     if (is_array($node)) {
         array_unshift($node, $nodename);
     }
 }

<?php

// use xmlwriter_open_uri() for direct file writes
$w = xmlwriter_open_memory();
xmlwriter_set_indent($w, TRUE);
xmlwriter_start_element($w, "source");
xmlwriter_start_element($w, "php");
// add raw data via CDATA
xmlwriter_start_cdata($w);
xmlwriter_text($w, "<?php phpinfo(); ?>");
xmlwriter_end_cdata($w);
xmlwriter_end_element($w);
xmlwriter_end_element($w);
echo '<pre>' . htmlentities(xmlwriter_output_memory($w)) . '</pre>';

 public static function toXml($writer, $data, $node)
 {
     foreach ($data as $key => $value) {
         if (is_numeric($key)) {
             $key = $node;
         }
         if (is_array($value)) {
             xmlwriter_start_element($writer, $key);
             OC_OCS::toxml($writer, $value, $node);
             xmlwriter_end_element($writer);
         } else {
             xmlwriter_write_element($writer, $key, $value);
         }
     }
 }