public function Voice($MediaId)
 {
     $w = new \XMLWriter();
     $w->openMemory();
     $w->writeElement('MediaId', $MediaId);
     $this->add('Voice', $w->outputMemory(), true);
 }

 public function setElementFromArray(XMLWriter $xml, $rootNode, array $config)
 {
     $config = $this->normalize($config);
     if (!empty($config)) {
         foreach ($config as $key => $val) {
             $numeric = 0;
             if (is_numeric($key)) {
                 $numeric = 1;
                 $key = $rootNode;
             }
             if (is_array($val)) {
                 $isAssoc = $this->isAssoc($val);
                 if ($isAssoc || $numeric) {
                     $xml->startElement($key);
                 }
                 $this->setElementFromArray($xml, $key, $val);
                 if ($isAssoc || $numeric) {
                     $xml->endElement();
                 }
                 continue;
             }
             $xml->writeElement($key, $val);
         }
     }
 }

 /**
  * Takes an array and produces XML based on it.
  *
  * @param XMLWriter $xmlw       XMLWriter object that was previously instanted
  * and is used for creating the XML.
  * @param array     $data       Array to be converted to XML.
  * @param string    $defaultTag Default XML tag to be used if none specified.
  * 
  * @return void
  */
 private function _arr2xml(\XMLWriter $xmlw, $data, $defaultTag = null)
 {
     foreach ($data as $key => $value) {
         if ($key === Resources::XTAG_ATTRIBUTES) {
             foreach ($value as $attributeName => $attributeValue) {
                 $xmlw->writeAttribute($attributeName, $attributeValue);
             }
         } else {
             if (is_array($value)) {
                 if (!is_int($key)) {
                     if ($key != Resources::EMPTY_STRING) {
                         $xmlw->startElement($key);
                     } else {
                         $xmlw->startElement($defaultTag);
                     }
                 }
                 $this->_arr2xml($xmlw, $value);
                 if (!is_int($key)) {
                     $xmlw->endElement();
                 }
             } else {
                 $xmlw->writeElement($key, $value);
             }
         }
     }
 }

 public function write(PlatformInterface $platform, \XMLWriter $xmlWriter)
 {
     $xmlWriter->startElement('video:platform');
     $xmlWriter->writeAttribute('relationship', $platform->relationship());
     $xmlWriter->text(implode(' ', $platform->types()));
     $xmlWriter->endElement();
 }

 protected function _internalRender($name)
 {
     $vars = $this->getVars();
     $file = $this->getStream();
     if ($file === false) {
         throw new GlobalServiceException("Impossible to create xml file");
     }
     // Start response object
     fputs($file, '<?xml version="1.0" encoding="UTF-8"?><response>');
     // Temp memory
     $memXml = new XMLWriter();
     $memXml->openMemory();
     $memXml->setIndent(true);
     if (isset($vars['count']) && $this->_countKey) {
         $this->_writeXmlElem($memXml, $this->_countKey, (int) $vars['count']);
         fputs($file, $memXml->outputMemory());
     }
     // Designed for lists only!!!
     if (!empty($vars['data']) && count($vars['data']) && $this->_dataKey) {
         fputs($file, '<' . $this->_dataKey . '>');
         foreach ($vars['data'] as $k => $v) {
             $v = $this->_filterData($v);
             if ($this->_skipEmptyItems && empty($v)) {
                 continue;
             }
             $this->_writeXmlElem($memXml, $k, $v);
             fputs($file, $memXml->outputMemory());
         }
         fputs($file, '</' . $this->_dataKey . '>');
     }
     // End response object
     fputs($file, '</response>');
 }

 /**
  * @param XMLWriter $xml
  * @param $data
  */
 public static function write(XMLWriter $xml, $data)
 {
     foreach ($data as $key => $value) {
         if (is_array($value) && isset($value[0])) {
             foreach ($value as $itemValue) {
                 //$xml->writeElement($key, $itemValue);
                 if (is_array($itemValue)) {
                     $xml->startElement($key);
                     self::write($xml, $itemValue);
                     $xml->endElement();
                     continue;
                 }
                 if (!is_array($itemValue)) {
                     $xml->writeElement($key, $itemValue . "");
                 }
             }
         } else {
             if (is_array($value)) {
                 $xml->startElement($key);
                 self::write($xml, $value);
                 $xml->endElement();
                 continue;
             }
         }
         if (!is_array($value)) {
             $xml->writeElement($key, $value . "");
         }
     }
 }

 public function write(RestrictionInterface $restriction, \XMLWriter $xmlWriter)
 {
     $xmlWriter->startElement('video:restriction');
     $xmlWriter->writeAttribute('relationship', $restriction->relationship());
     $xmlWriter->text(implode(' ', $restriction->countryCodes()));
     $xmlWriter->endElement();
 }

 private function writeNamespaceAttributes(\XMLWriter $xmlWriter)
 {
     $xmlWriter->writeAttribute(UrlSetInterface::XML_NAMESPACE_ATTRIBUTE, UrlSetInterface::XML_NAMESPACE_URI);
     $xmlWriter->writeAttribute(ImageInterface::XML_NAMESPACE_ATTRIBUTE, ImageInterface::XML_NAMESPACE_URI);
     $xmlWriter->writeAttribute(NewsInterface::XML_NAMESPACE_ATTRIBUTE, NewsInterface::XML_NAMESPACE_URI);
     $xmlWriter->writeAttribute(VideoInterface::XML_NAMESPACE_ATTRIBUTE, VideoInterface::XML_NAMESPACE_URI);
 }

 protected function getItem()
 {
     $xml = new \XMLWriter();
     $xml->openMemory();
     $xml->setIndent(true);
     $item = new Price($xml);
     return $item;
 }

 /**
  * Write XML to output
  * 
  * @param \XMLWriter $xml
  * @param string $nodeName
  * 
  * @return CurrencyAmount 
  */
 public function writeXml(\XMLWriter $xml, $nodeName)
 {
     $xml->startElement($nodeName);
     $xml->writeAttribute('currency', $this->get('baseCurrencyCode'));
     $xml->text($this->get('value'));
     $xml->endElement();
     return $this;
 }

 private function generateXML(XmlEntityInterface $xmlEntity)
 {
     $xmlWriter = new \XMLWriter();
     $xmlWriter->openMemory();
     $xmlWriter->setIndent(false);
     $xmlEntity->toXML($xmlWriter);
     return $xmlWriter->outputMemory(true);
 }

 public function writeXML(\XMLWriter $xmlWriter)
 {
     if ($this->mailAttributes != NULL) {
         $xmlWriter->startELement(Constants::MESSAGE_ATTRIBUTES);
         $this->mailAttributes->writeXML($xmlWriter);
         $xmlWriter->endElement();
     }
 }

 public function write(\XMLWriter $writer, \DateTimeZone $timezone, $stringTag)
 {
     if ($stringTag) {
         $writer->writeElement('string', $this->value);
     } else {
         $writer->text($this->value);
     }
 }

 public static function encodeXml($var)
 {
     $xmlWriter = new \XMLWriter();
     $xmlWriter->openMemory();
     $xmlWriter->setIndent(true);
     $xmlWriter->startDocument('1.0', 'UTF-8');
     self::encodeXmlNode($xmlWriter, 'root', $var);
     return $xmlWriter->flush();
 }

 public function writeXML(\XMLWriter $xmlWriter)
 {
     if ($this->maximumMessageSize != NULL) {
         $xmlWriter->writeElement(Constants::MAXIMUM_MESSAGE_SIZE, $this->maximumMessageSize);
     }
     if ($this->messageRetentionPeriod != NULL) {
         $xmlWriter->writeElement(Constants::MESSAGE_RETENTION_PERIOD, $this->messageRetentionPeriod);
     }
 }

 public function testSetCarrierCode()
 {
     $xml = new \XMLWriter();
     $xml->openMemory();
     $xml->setIndent(true);
     $f = new OrderFulfillment($xml);
     $this->setExpectedException('InvalidArgumentException');
     $f->setCarrierCode('Foo');
 }

 private function writeLastModified(\XMLWriter $xmlWriter, \DateTimeInterface $lastModified = null)
 {
     if ($lastModified === null) {
         return;
     }
     $xmlWriter->startElement('lastmod');
     $xmlWriter->text($lastModified->format('c'));
     $xmlWriter->endElement();
 }

 public function build($name, $node, \XMLWriter &$writer, $under_root)
 {
     // always inside an xsd:element
     $writer->startElementNs('xsd', 'element', null);
     $writer->writeAttribute('name', $name);
     $this->addRequired($node, $writer, $under_root);
     $writer->writeAttribute('type', 'xsd:boolean');
     $writer->endElement();
 }

 public function write(\XMLWriter $writer, \DateTimeZone $timezone, $stringTag)
 {
     if (strpos(static::XMLRPC_TYPE, '}') !== false) {
         list($ns, $tagName) = explode('}', static::XMLRPC_TYPE, 2);
         $ns = (string) substr($ns, 1);
         return $writer->writeElementNS('ex', $tagName, $ns, gmp_strval($this->value));
     }
     return $writer->writeElement(static::XMLRPC_TYPE, gmp_strval($this->value));
 }

 public function testSetImageType()
 {
     $xml = new \XMLWriter();
     $xml->openMemory();
     $xml->setIndent(true);
     $image = new Image($xml);
     $this->setExpectedException('InvalidArgumentException');
     $image->setImageType('Foo');
 }