XML/DOM serialization

From Rosetta Code
< XML
Revision as of 05:28, 17 June 2009 by rosettacode>Tinku99 (+ AutoHotkey)
Task
XML/DOM serialization
You are encouraged to solve this task according to the task description, using any language you may know.

Create a simple DOM and having it serialize to: 

 <?xml version="1.0" ?>
 <root>
     <element>
         Some text here
     </element>
 </root>

AutoHotkey

<lang AutoHotkey> root = root element("root", "element", "some text here") msgbox % serialize("root") return

element(parent, name, text) { 

 global
 %parent%_elements .= name . "`n"
 %parent%_%name%_name := name
 %parent%_%name%_text := text

}


serialize(root){ 

 version = "1.0"
 xml := "<?xml version=" . version . "?>" . "<" . root . ">"
 loop, parse, %root%_elements , `n

{ 

 element := "<" . %root%_%A_LoopField%_name . ">"
 element .= %root%_%A_LoopField%_text
 element .= "</" . %root%_%A_LoopField%_name . ">"
 xml .= element

} 

Return xml .= "</root>"

} </lang>

C#

Serialization using the built-in XML.Serilazation library of .Net. <lang csharp> using System.Xml; using System.Xml.Serialization; [XmlRoot("root")] public class ExampleXML { 

   [XmlElement("element")]
   public string element = "Some text here";
   static void Main(string[] args)
   {
       var xmlnamespace = new XmlSerializerNamespaces();
       xmlnamespace.Add("", ""); //used to stop default namespaces from printing
       var writer = XmlWriter.Create("output.xml");
       new XmlSerializer(typeof(ExampleXML)).Serialize(writer, new ExampleXML(), xmlnamespace);
   }
   //Output: <?xml version="1.0" encoding="utf-8"?><root><element>Some text here</element></root>

} </lang>

D

Works with: D version 2.011+

<lang d> module xmltest ;

import std.stdio ; import std.xml ;

void main() { 

 auto doc = new Document("root") ;

//doc.prolog = q"/<?xml version="1.0"?>/" ; // default 

 doc ~= new Element("element", "Some text here") ;
 writefln(doc) ;

// output: <?xml version="1.0"?><root><element>Some text here</element></root> } </lang>

E

Works with: E-on-Java

This makes use of XML libraries provided with Java. 

def document := <unsafe:javax.xml.parsers.makeDocumentBuilderFactory> \
                  .newInstance() \
                  .newDocumentBuilder() \
                  .getDOMImplementation() \
                  .createDocument(null, "root", null)
def root := document.getDocumentElement()
root.appendChild(
  def element := document.createElement("element"))
element.appendChild(
  document.createTextNode("Some text here"))
println(document.saveXML(root))

(On the use of <unsafe>: The class has not yet been reviewed for E safety, so <import:...makeDocumentBuilderFactory> is not yet allowed. The review would probably be straightforward.)

Forth

Library: Forth Foundation Library
include ffl/dom.fs

\ Create a dom variable 'doc' in the dictionary

dom-create doc

\ Add the document root with its version attribute

dom.document doc dom-append-node

s" version" s" 1.0" dom.attribute doc dom-append-node

\ Add root and element

doc dom-parent 2drop

s" root"    dom.element doc dom-append-node

s" element" dom.element doc dom-append-node

\ Add the text

s" Some text here" dom.text doc dom-append-node

\ Convert the document to a string and print

doc dom-write-string [IF]
  type cr
[THEN]

Groovy

import groovy.xml.MarkupBuilder
def writer = new StringWriter() << '<?xml version="1.0" ?>\n'
def xml = new MarkupBuilder(writer)
xml.root() {
    element('Some text here' ) 
}
println writer

JavaScript

Works with: Firefox version 2.0

DOM

<lang javascript> var doc = document.implementation.createDocument( null, 'root', null ); var root = doc.documentElement; var element = doc.createElement( 'element' ); root.appendChild( element ); element.appendChild( document.createTextNode('Some text here') ); var xmlString = new XMLSerializer().serializeToString( doc ); </lang>

E4X

<lang javascript> var xml = <root> 

 <element>Some text here</element>

</root>; var xmlString = xml.toXMLString(); </lang>

E4X — with processing instruction

<lang javascript> XML.ignoreProcessingInstructions = false; var xml = <?xml version="1.0"?> <root> 

 <element>Some text here</element>

</root>; var xmlString = xml.toXMLString(); </lang>

Perl

Library: XML::SimpleSimple

<lang perl> use XML::Simple; print XMLout( { root => { element => "Some text here" } }, NoAttr => 1, RootName => "" ); </lang>

Output: 

<root>
  <element>Some text here</element>
</root>
Library: XML::DOM::BagOfTricksDOM::BagOfTricks

<lang perl> use XML::DOM::BagOfTricks qw(createDocument createTextElement);

my ($doc, $root) = createDocument('root'); $root->appendChild( 

   createTextElement($doc, 'element', 'Some text here')

); print $doc->toString; </lang>

Output: 

<root><element>Some text here</element></root>
Library: LibXML

<lang perl> use XML::LibXML;

$xml = XML::LibXML::Document->new('1.0'); $node = $xml->createElement('root'); $xml->setDocumentElement($node); $node2 = $xml->createElement('element'); $text = $xml->createTextNode('Some text here'); $node2->addChild($text); $node->appendWellBalancedChunk('text'); $node->addChild($node2);

print $xml->toString; </lang>

Output: 

<?xml version="1.0"?>
<root>text<element>Some text here</element></root>

PHP

Works with: PHP version 5

<lang php> <?php $dom = new DOMDocument();//the constructor also takes the version and char-encoding as it's two respective parameters $dom->formatOutput = true;//format the outputted xml $root = $dom->createElement('root'); $element = $dom->createElement('element'); $element->appendChild($dom->createTextNode('Some text here')); $root->appendChild($element); $dom->appendChild($root); $xmlstring = $dom->saveXML(); </lang>

Python

Works with: Python version 2.5

<lang python> from xml.dom.minidom import getDOMImplementation

dom = getDOMImplementation() document = dom.createDocument(None, "root", None)

topElement = document.documentElement firstElement = document.createElement("element") topElement.appendChild(firstElement) textNode = document.createTextNode("Some text here") firstElement.appendChild(textNode)

xmlString = document.toprettyxml(" " * 4) </lang>

<lang python> from xml.etree import ElementTree as et

root = et.Element("root") et.SubElement(root, "element").text = "Some text here" xmlString = et.tostring(root) </lang>

Ruby

Library: REXML

<lang ruby>require("rexml/document") include REXML (doc = Document.new) << XMLDecl.new root = doc.add_element('root') element = root.add_element('element') element.add_text('Some text here')

  1. save to a string
  2. (the first argument to write() needs an object that understands "<<")

serialized = String.new doc.write(serialized, 4) puts serialized</lang>

produces 

<?xml version='1.0'?>
<root>
    <element>
        Some text here
    </element>
</root>

Tcl

Library: tDOM

<lang tcl>package require tdom set d [dom createDocument root] set root [$d documentElement] $root appendChild [$d createElement element] [$root firstChild] appendChild [$d createTextNode "Some text here"] $d asXML</lang> 

<root>
    <element>Some text here</element>
</root>

Using TclDOM <lang tcl>package require dom set doc [dom::DOMImplementation create] set root [dom::document createElement $doc root] set elem [dom::document createElement $root element] set text [dom::document createTextNode $elem "Some text here"] dom::DOMImplementation serialize $doc -newline {element}</lang> 

<?xml version='1.0'?>
<!DOCTYPE root>
<root>
<element>
Some text here
</element>
</root>

XSLT

<lang> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 

 <xsl:output method="xml" indent="yes" />
 <xsl:template match="/">   
   <xsl:element name="root">
     <xsl:element name="element">
       <xsl:text>Some text here</xsl:text>
     </xsl:element>
   </xsl:element>
 </xsl:template>

</xsl:stylesheet> </lang>

Retrieved from "https://rosettacode.org/wiki/XML/DOM_serialization?oldid=13919"