XML/DOM serialization

From Rosetta Code
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>

ABAP

<lang ABAP> DATA: xml_string TYPE string.

DATA(xml) = cl_ixml=>create( ). DATA(doc) = xml->create_document( ). DATA(root) = doc->create_simple_element( name = 'root' 

                                        parent = doc ).

doc->create_simple_element( name = 'element' 

                           parent = root
                           value  = 'Some text here' ).

DATA(stream_factory) = xml->create_stream_factory( ). DATA(stream) = stream_factory->create_ostream_cstring( string = xml_string ). DATA(renderer) = xml->create_renderer( document = doc 

                                            ostream  = stream ).

stream->set_pretty_print( abap_true ). renderer->render( ).

cl_demo_output=>display_text( xml_string ). </lang>

Output: 

<?xml version="1.0" encoding="utf-16"?>
<root>
<element>Some text here</element>
</root>

Ada

Works with: GNAT

Uses XML/Ada from AdaCore.

<lang Ada>with Ada.Text_IO.Text_Streams; with DOM.Core.Documents; with DOM.Core.Nodes;

procedure Serialization is 

  My_Implementation : DOM.Core.DOM_Implementation;
  My_Document       : DOM.Core.Document;
  My_Root_Node      : DOM.Core.Element;
  My_Element_Node   : DOM.Core.Element;
  My_Text_Node      : DOM.Core.Text;

begin 

  My_Document := DOM.Core.Create_Document (My_Implementation);
  My_Root_Node := DOM.Core.Documents.Create_Element (My_Document, "root");
  My_Root_Node := DOM.Core.Nodes.Append_Child (My_Document, My_Root_Node);
  My_Element_Node := DOM.Core.Documents.Create_Element (My_Document, "element");
  My_Element_Node := DOM.Core.Nodes.Append_Child (My_Root_Node, My_Element_Node);
  My_Text_Node := DOM.Core.Documents.Create_Text_Node (My_Document, "Some text here");
  My_Text_Node := DOM.Core.Nodes.Append_Child (My_Element_Node, My_Text_Node);
  DOM.Core.Nodes.Write
    (Stream => Ada.Text_IO.Text_Streams.Stream
       (Ada.Text_IO.Standard_Output),
     N => My_Document,
     Pretty_Print => True);

end Serialization;</lang>

It can be shortened a lot by adding "use" clauses and writing the creation functions into the declaration part.

Output: 

<?xml version="1.0" encoding="utf-8"?>
<root>
 <element>Some text here</element>
</root>

AutoHotkey

<lang AutoHotkey>version = "1.0" xmlheader := "<?xml version=" . version . "?>" . "<" . root . ">"

element("root", "child") element("root", "element", "more text here") element("root_child", "kid", "yak yak") MsgBox % xmlheader . serialize("root") Return

element(parent, name, text="") { 

 Global
 %parent%_children .= name . "`n"
 %parent%_%name% = %parent%_%name%
 %parent%_%name%_name := name
 %parent%_%name%_text := text

}

serialize(root){ 

 StringSplit, root, root, _
 xml .= "<" . root%root0% . ">"
 StringTrimRight, %root%_children, %root%_children, 1
 Loop, Parse, %root%_children, `n
 {
   If %root%_%A_LoopField%_children
     xml .= serialize(%root%_%A_LoopField%)
   Else
   {
     element := "<" . %root%_%A_LoopField%_name . ">"
     element .= %root%_%A_LoopField%_text
     element .= "</" . %root%_%A_LoopField%_name . ">"
     xml .= element
   }
 }
 Return xml .= "</" . root%root0% . ">"

}</lang>

Bracmat

To produce the XML including all indentations, we can do this: <lang bracmat>( ("?"."xml version=\"1.0\" ") 

     \n
     (root.,"\n    " (element.,"
       Some text here
   ") \n)
 : ?xml

& out$(toML$!xml) );</lang> If we do not care about indentation: <lang bracmat>( ("?"."xml version=\"1.0\"") (root.,(element.,"Some text here")) 

 : ?xml

& out$(toML$!xml) );</lang>

C

Library: libxml

<lang c>#include <stdio.h>

  1. include <stdlib.h>
  2. include <string.h>
  3. include <libxml/parser.h>
  4. include <libxml/tree.h>

int main() { 

 const char **next;
 int a;
 FILE *outFile;

 xmlDoc *doc = xmlNewDoc("1.0");
 xmlNode *root = xmlNewNode(NULL, "root");
 xmlDocSetRootElement(doc, root);

 xmlNode *node = xmlNewNode(NULL, "element");
 xmlAddChild(node, xmlNewText("some text here"));
 xmlAddChild(root, node);

 outFile = fopen("myfile.xml", "w");
 xmlElemDump(outFile, doc, root);
 fclose(outFile);

 xmlFreeDoc(doc);
 xmlCleanupParser();

 return EXIT_SUCCESS;

}</lang>

C#

Serialization using the built-in System.Xml.Serialization 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>

Caché ObjectScript

USER>set writer=##class(%XML.Writer).%New()
USER>set writer.Charset="UTF-8"
USER>Set writer.Indent=1
USER>Set writer.IndentChars="    "
USER>set sc=writer.OutputToString()
USER>set sc=writer.RootElement("root")
USER>set sc=writer.Element("element")
USER>set sc=writer.WriteChars("Some text here")
USER>set sc=writer.EndElement()
USER>set sc=writer.EndRootElement()
USER>Write writer.GetXMLString()

<?xml version="1.0" encoding="UTF-8"?>
<root>
    <element>Some text here</element>
</root>

Clojure

Library: clojure.data.xml

<lang clojure> (require '[clojure.data.xml :as xml])

(def xml-example (xml/element :root {} (xml/element :element {} "Some text here")))

(with-open [out-file (java.io.OutputStreamWriter. 

                       (java.io.FileOutputStream. "/tmp/output.xml") "UTF-8")]
 (xml/emit xml-example out-file))

</lang>

Output:
<?xml version="1.0" encoding="UTF-8"?><root><element>Some text here</element></root>

Common Lisp

Library: Closure XML

Assuming that matching the whitespace in the problem description isn't necessary and that character encodings are permitted (see the talk page):

<lang lisp>(let* ((doc (dom:create-document 'rune-dom:implementation nil nil nil)) 

      (root (dom:create-element doc "root"))
      (element (dom:create-element doc "element"))
      (text (dom:create-text-node doc "Some text here")))
 (dom:append-child element text)
 (dom:append-child root element)
 (dom:append-child doc root)
 (dom:map-document (cxml:make-rod-sink) doc))</lang>

gives the following output: 

<?xml version="1.0" encoding="UTF-8"?>
<root><element>Some text here</element></root>

Because dom:append-child returns the appended child, the same output can be produced while binding fewer variables:

<lang lisp>(let ((doc (dom:create-document 'rune-dom:implementation nil nil nil))) 

 (dom:append-child
  (dom:append-child
   (dom:append-child doc (dom:create-element doc "root"))
   (dom:create-element doc "element"))
  (dom:create-text-node doc "Some text here"))
 (write-string (dom:map-document (cxml:make-rod-sink) doc)))</lang>

The prefix notation makes this hard to decipher, however, and so a final version uses an auxiliary append-child*:

<lang lisp>(defun append-child* (parent &rest children) 

 (reduce 'dom:append-child children :initial-value parent))

(let* ((doc (dom:create-document 'rune-dom:implementation nil nil nil))) 

 (append-child* doc
                (dom:create-element doc "root")
                (dom:create-element doc "element")
                (dom:create-text-node doc "Some text here"))
 (write-string (dom:map-document (cxml:make-rod-sink) doc)))</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.

<lang e>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))</lang>

(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.)


F#

<lang fsharp>open System.Xml

[<EntryPoint>] let main argv = 

   let xd = new XmlDocument()
   // Create the required nodes:
   xd.AppendChild (xd.CreateXmlDeclaration("1.0", null, null)) |> ignore
   let root = xd.AppendChild (xd.CreateNode("element", "root", ""))
   let element = root.AppendChild (xd.CreateElement("element", "element", ""))
   element.AppendChild (xd.CreateTextNode("Some text here")) |> ignore
   // The same can be accomplished with:
   // xd.LoadXml("""<?xml version="1.0"?><root><element>Some text here</element></root>""")

   let xw = new XmlTextWriter(System.Console.Out)
   xw.Formatting <- Formatting.Indented
   xd.WriteContentTo(xw)
   0</lang>

Output 

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

Fantom

<lang fantom> using xml

class XmlDom { 

 public static Void main ()
 {
   doc := XDoc()
   root := XElem("root")
   doc.add (root)

   child := XElem("element")
   child.add(XText("Some text here"))
   root.add (child)

   doc.write(Env.cur.out)
 }

} </lang>

Output: 

<?xml version='1.0' encoding='UTF-8'?>
<root>
 <element>Some text here</element>
</root>

Forth

Library: Forth Foundation Library

<lang forth>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]</lang>

Go

Library: bitbucket.org/rj/xmldom-go

A partial solution based on an incomplete library. The library is missing functions needed to create a DOM piece by piece like other other solutions here. It can however create a DOM by parsing XML. Also, it lacks a function to access the processing instruction, so not surprisingly this is missing from the serialized output. <lang go>package main

import ( 

   "fmt"
   dom "bitbucket.org/rj/xmldom-go"

)

func main() { 

   d, err := dom.ParseStringXml(`

<?xml version="1.0" ?> <root> 

   <element>
       Some text here
   </element>

</root>`) 

   if err != nil {
       fmt.Println(err)
       return
   }
   fmt.Println(string(d.ToXml()))

}</lang>

Output:

<lang xml><root> 

   <element>
       Some text here
   </element>

</root></lang>

Groovy

<lang 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</lang>

Haskell

Using the XML.Light module from HackageDB

<lang Haskell>import Data.List import Text.XML.Light

xmlDOM :: String -> String xmlDOM txt = showTopElement $ Element 

   (unqual "root")
   []
   [ Elem $ Element
     (unqual "element")
     []
     [Text $ CData CDataText txt Nothing]
     Nothing
   ]
   Nothing</lang>

Output: 

*Main> mapM_ (putStrLn.ppContent) $ parseXML (xmlDOM "  Some text  ")
<?xml version="1.0" ?>
<root>
  <element>  Some text  </element>
</root>

J

There are probably better ways of doing this, but, here is a simple serializer for a rudimentary concept of a dom:

<lang j>serialize=: ('<?xml version="1.0" ?>',LF),;@serialize1& serialize1=:4 :0 

 if.L.x do.
   start=. y,'<',(0{::x),'>',LF
   middle=. ;;(}.x) serialize1&.> <'    ',y
   end=. y,'</',(0{::x),'>',LF
   <start,middle,end
 else.
   <y,x,LF
 end.

)</lang>

And here is a document object that matches this task:

<lang j>obj=: 'root';<'element';'some text here'</lang>

Example use:

<lang xml> serialize obj <?xml version="1.0" ?> <root> 

   <element>
       some text here
   </element>

</root></lang>

Java

Java's XML DOM tools don't really allow total control of the output format "out of the box" but the following program generates XML that is equivalent to the required output. <lang java> import java.io.StringWriter;

import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import javax.xml.transform.OutputKeys; import javax.xml.transform.Transformer; import javax.xml.transform.TransformerConfigurationException; import javax.xml.transform.TransformerException; import javax.xml.transform.TransformerFactory; import javax.xml.transform.TransformerFactoryConfigurationError; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.DOMImplementation; import org.w3c.dom.Document; import org.w3c.dom.Element;

public class RDOMSerialization { 

 private Document domDoc;

 public RDOMSerialization() {
   return;
 }

 protected void buildDOMDocument() {

   DocumentBuilderFactory factory;
   DocumentBuilder builder;
   DOMImplementation impl;
   Element elmt1;
   Element elmt2;

   try {
     factory = DocumentBuilderFactory.newInstance();
     builder = factory.newDocumentBuilder();
     impl = builder.getDOMImplementation();
     domDoc = impl.createDocument(null, null, null);
     elmt1 = domDoc.createElement("root");
     elmt2 = domDoc.createElement("element");
     elmt2.setTextContent("Some text here");

     domDoc.appendChild(elmt1);
     elmt1.appendChild(elmt2);
   }
   catch (ParserConfigurationException ex) {
     ex.printStackTrace();
   }

   return;
 }

 protected void serializeXML() {

   DOMSource domSrc;
   Transformer txformer;
   StringWriter sw;
   StreamResult sr;

   try {
     domSrc = new DOMSource(domDoc);

     txformer = TransformerFactory.newInstance().newTransformer();
     txformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
     txformer.setOutputProperty(OutputKeys.METHOD, "xml");
     txformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
     txformer.setOutputProperty(OutputKeys.INDENT, "yes");
     txformer.setOutputProperty(OutputKeys.STANDALONE, "yes");
     txformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");

     sw = new StringWriter();
     sr = new StreamResult(sw);

     txformer.transform(domSrc, sr);

     System.out.println(sw.toString());
   }
   catch (TransformerConfigurationException ex) {
     ex.printStackTrace();
   }
   catch (TransformerFactoryConfigurationError ex) {
     ex.printStackTrace();
   }
   catch (TransformerException ex) {
     ex.printStackTrace();
   }

   return;
 }

 public static void serializationDriver(String[] args) {

   RDOMSerialization lcl = new RDOMSerialization();
   lcl.buildDOMDocument();
   lcl.serializeXML();

   return;
 }

 public static void main(String[] args) {
   serializationDriver(args);
   return;
 }

} </lang>

Output:

<lang xml><?xml version="1.0" encoding="UTF-8" standalone="yes"?> <root> 

 <element>Some text here</element>

</root></lang>

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>

Julia

<lang julia>using LightXML

  1. Modified from the documentation for LightXML.jl
  1. create an empty XML document

xdoc = XMLDocument()

  1. create & attach a root node

xroot = create_root(xdoc, "States")

  1. create the first child

xs1 = new_child(xroot, "State")

  1. add the inner content

add_text(xs1, "Massachusetts")

  1. set attribute

set_attribute(xs1, "tag", "MA")

  1. likewise for the second child

xs2 = new_child(xroot, "State") add_text(xs2, "Illinois")

  1. set multiple attributes using a dict

set_attributes(xs2, Dict("tag"=>"IL", "cap"=>"Springfield"))

  1. now, the third child

xs3 = new_child(xroot, "State") add_text(xs3, "California")

  1. set attributes using keyword arguments

set_attributes(xs3; tag="CA", cap="Sacramento")

println(xdoc)

</lang>

Output:


<?xml version="1.0" encoding="utf-8"?>
<States>
  <State tag="MA">Massachusetts</State>
  <State tag="IL" cap="Springfield">Illinois</State>
  <State tag="CA" cap="Sacramento">California</State>
</States>


Kotlin

This is the closest I could get to the required output.

There appears to be no satisfactory way to prevent the default encoding and standalone attributes from appearing in the XML declaration using the standard JDK DOM implementation. If you set the standalone attribute to true - using doc.setXmlStandalone(true) - then this removes it from the declaration but unfortunately there is then no carriage return before the <root> tag!

So I've decided to leave it as it is. <lang scala>// version 1.1.3

import javax.xml.parsers.DocumentBuilderFactory import javax.xml.transform.dom.DOMSource import java.io.StringWriter import javax.xml.transform.stream.StreamResult import javax.xml.transform.TransformerFactory

fun main(args: Array<String>) { 

   val dbFactory = DocumentBuilderFactory.newInstance()
   val dBuilder  = dbFactory.newDocumentBuilder()
   val doc = dBuilder.newDocument()
   val root = doc.createElement("root")  // create root node
   doc.appendChild(root)
   val element = doc.createElement("element")  // create element node
   val text = doc.createTextNode("Some text here")  // create text node
   element.appendChild(text)
   root.appendChild(element)

   // serialize
   val source = DOMSource(doc)
   val sw = StringWriter()
   val result = StreamResult(sw)
   val tFactory = TransformerFactory.newInstance()
   tFactory.newTransformer().apply {
       setOutputProperty("indent", "yes")
       setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4") 
       transform(source, result)
   }
   println(sw)

}</lang>

Output:
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<root>
    <element>Some text here</element>
</root>

Lasso

<lang lasso> content_type( 'text/xml' );// set MIME type if serving

xml( '<?xml version="1.0" ?><root><element>Some text here</element></root>' );

</lang>

Lingo

Code based on Flash Xtra (comes with Director, i.e. "built-in") that allows to use AS2/AS3 classes in Lingo (in this case "XML" is an AS2 class). <lang lingo>-- create an XML document doc = newObject("XML", "<?xml version='1.0' ?>")

root = doc.createElement("root") doc.appendChild(root)

element = doc.createElement("element") root.appendChild(element)

textNode = doc.createTextNode("Some text here") element.appendChild(textNode)

put doc.toString() -- "<?xml version='1.0' ?><root><element>Some text here</element></root>"</lang>

Lua

Using the widely available 'LuaXML' module <lang Lua>require("LuaXML") local dom = xml.new("root") local element = xml.new("element") table.insert(element, "Some text here") dom:append(element) dom:save("dom.xml")</lang> Resulting contents of dom.xml: 

<?xml version="1.0"?>
<!-- file "dom.xml", generated by LuaXML -->

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

Mathematica

<lang Mathematica>DOM = XMLObject["Document"][{XMLObject["Declaration"]["Version" -> "1.0","Encoding" -> "utf-8"]}, XMLElement["root", {}, {XMLElement["element", {}, {"Some text here"}]}], {}];

ExportString[DOM, "XML", "AttributeQuoting" -> "\""]</lang> Output: 

<?xml version="1.0" encoding="utf-8"?>
<root>
 <element>Some text here</element>
</root>

MATLAB

<lang MATLAB>docNode = com.mathworks.xml.XMLUtils.createDocument('root'); docRootNode = docNode.getDocumentElement; thisElement = docNode.createElement('element'); thisElement.appendChild(docNode.createTextNode('Some text here')); docRootNode.appendChild(thisElement); </lang> Output: 

 xmlwrite(docNode)

ans =

<?xml version="1.0" encoding="utf-8"?>
<root>
   <element>Some text here</element>
</root>

NetRexx

Translation of: Java

<lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols nobinary

import java.io.StringWriter import javax.xml. import org.w3c.dom.

class RDOMSerialization public

properties private 

 domDoc = Document

method main(args = String[]) public static 

 lcl = RDOMSerialization()
 lcl.buildDOMDocument()
 lcl.serializeXML()

 return

method buildDOMDocument() inheritable 

 do
   factory = DocumentBuilderFactory.newInstance()
   builder = factory.newDocumentBuilder()
   impl = builder.getDOMImplementation()
   domDoc = impl.createDocument(null, null, null)
   elmt1 = domDoc.createElement("root")
   elmt2 = domDoc.createElement("element")
   elmt2.setTextContent("Some text here")

   domDoc.appendChild(elmt1)
   elmt1.appendChild(elmt2)
 
 catch exPC = ParserConfigurationException
   exPC.printStackTrace
 end
 
 return

method serializeXML() inheritable 

 do
   domSrc = DOMSource(domDoc)
   txformer = TransformerFactory.newInstance().newTransformer()
   txformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no")
   txformer.setOutputProperty(OutputKeys.METHOD, "xml")
   txformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8")
   txformer.setOutputProperty(OutputKeys.INDENT, "yes")
   txformer.setOutputProperty(OutputKeys.STANDALONE, "yes")
   txformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2")
 
   sw = StringWriter()
   sr = StreamResult(sw)
 
   txformer.transform(domSrc, sr)
 
   say sw.toString

 catch exTC = TransformerConfigurationException
   exTC.printStackTrace
 catch exTF = TransformerFactoryConfigurationError
   exTF.printStackTrace
 catch exTE = TransformerException
   exTE.printStackTrace
 end

 return

</lang>

Output:

<lang xml><?xml version="1.0" encoding="UTF-8" standalone="no"?> <root> 

 <element>Some text here</element>

</root></lang>

Nim

<lang nim>import xmldom

var 

 dom = getDOM()
 document = dom.createDocument("", "root")
 topElement = document.documentElement
 firstElement = document.createElement "element"
 textNode = document.createTextNode "Some text here"

topElement.appendChild firstElement firstElement.appendChild textNode

echo document</lang> Output: 

<?xml version="1.0" encoding="UTF-8" ?>
<root>
  <element>
    Some text here
  </element>
</root>

Objeck

<lang objeck>use XML;

bundle Default { 

 class Test {
   function : Main(args : String[]) ~ Nil {
     builder := XMLBuilder->New("root", "1.0");
     root := builder->GetRoot();
     element := XMLElement->New(XMLElementType->ELEMENT, "element", "Some text here");
     root->AddChild(element);
     builder->ToString()->PrintLine();
   }
 }

}</lang>

OpenEdge/Progress

The following example uses the X-DOCUMENT, for faster processing SAX can be used. <lang progress> DEFINE VARIABLE hxdoc AS HANDLE NO-UNDO. DEFINE VARIABLE hxroot AS HANDLE NO-UNDO. DEFINE VARIABLE hxelement AS HANDLE NO-UNDO. DEFINE VARIABLE hxtext AS HANDLE NO-UNDO. DEFINE VARIABLE lcc AS LONGCHAR NO-UNDO.

CREATE X-DOCUMENT hxdoc.

CREATE X-NODEREF hxroot. hxdoc:CREATE-NODE( hxroot, 'root', 'ELEMENT' ). hxdoc:APPEND-CHILD( hxroot ).

CREATE X-NODEREF hxelement. hxdoc:CREATE-NODE( hxelement, 'element', 'ELEMENT' ). hxroot:APPEND-CHILD( hxelement ).

CREATE X-NODEREF hxtext. hxdoc:CREATE-NODE( hxtext, 'element', 'TEXT' ). hxelement:APPEND-CHILD( hxtext ). hxtext:NODE-VALUE = 'Some text here'.

hxdoc:SAVE( 'LONGCHAR', lcc ). MESSAGE STRING( lcc ) VIEW-AS ALERT-BOX. </lang>

Oz

With the code from XML Creation#Oz, we can write:

<lang oz>declare 

 proc {Main}
  DOM = root(element("Some text here"))
 in
    {System.showInfo {Serialize DOM}}
 end
 ...</lang>

Output: <lang xml><?xml version="1.0" ?> <root> 

   <element>Some text here</element>

</root></lang>

Pascal

Works with: Free_Pascal
Library: Classes
Library: XMLWrite
Library: DOM

<lang pascal>program CrearXML;

{$mode objfpc}{$H+}

uses 

 Classes, XMLWrite, DOM;

var 

 xdoc: TXMLDocument;                                  // variable objeto documento XML
 NodoRaiz, NodoPadre, NodoHijo: TDOMNode;             // variables a los nodos

begin 

 //crear el documento
 xdoc := TXMLDocument.create;

 NodoRaiz := xdoc.CreateElement('root');               // crear el nodo raíz
 Xdoc.Appendchild(NodoRaiz);                           // guardar nodo raíz
 NodoPadre := xdoc.CreateElement('element');           // crear el nodo hijo
 NodoHijo := xdoc.CreateTextNode('Some text here');    // insertar el valor del nodo
 NodoPadre.Appendchild(NodoHijo);                      // guardar nodo
 NodoRaiz.AppendChild(NodoPadre);                      // insertar el nodo hijo en el correspondiente nodo padre
 writeXMLFile(xDoc,'prueba.xml');                      // escribir el XML
 Xdoc.free;

end.</lang>

Output:

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

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>

Perl 6

Works with: Rakudo version 2018.05

<lang perl6>use XML; use XML::Writer;

say my $document = XML::Document.new( 

   XML::Writer.serialize( :root[ :element['Some text here', ], ] )

);</lang>

Output:

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

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>

PicoLisp

<lang PicoLisp>(load "@lib/xm.l")

(xml? T) (xml '(root NIL (element NIL "Some text here")))</lang> Output: 

<?xml version="1.0" encoding="utf-8"?>
<root>
   <element>Some text here</element>
</root>

Pike

manually, one node at a time: <lang Pike>object dom = Parser.XML.Tree.SimpleRootNode(); dom->add_child(Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_HEADER, "", ([]), "")); object node = Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_ELEMENT, "root", ([]), ""); dom->add_child(node);

object subnode = Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_ELEMENT, "element", ([]), ""); node->add_child(subnode);

node = subnode; subnode = Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_TEXT, "", ([]), "Some text here"); node->add_child(subnode);

dom->render_xml(); Result: "<?xml version='1.0' encoding='utf-8'?><root><element>Some text here</element></root>"</lang>

from an array, using a conversion function: <lang Pike>object make_xml_node(array|string in, void|int level) { 

   level++;
   if (stringp(in))
       return Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_TEXT, "", ([]), in);
   else
   {
       object node = Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_ELEMENT, in[0], in[1], ""); 
       foreach(in[2..];; array|string child)
       {
           node->add_child(make_xml_node(child, level));
       }
       return node;
   }

}

object make_xml_tree(array input) { 

   object dom = Parser.XML.Tree.SimpleRootNode();
   dom->add_child(Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_HEADER, "", ([]), ""));
   dom->add_child(make_xml_node(input));
   return dom;

}

array input = ({ "root", ([]), ({ "element", ([]), "Some text here" }) }); make_xml_tree(input)->render_xml(); Result: "<?xml version='1.0' encoding='utf-8'?><root><element>Some text here</element></root>"</lang>

to render the output with indenting as specified in the task, this function adds the necessary text nodes: <lang Pike>object indent_xml(object parent, void|int indent_text, void|int level) { 

   int subnodes = false; 
   foreach(parent->get_children();; object child)
   {
       if (child->get_node_type() == Parser.XML.Tree.XML_ELEMENT || 
           (child->get_node_type() == Parser.XML.Tree.XML_TEXT && indent_text))
       {
           subnodes = true; 
           parent->add_child_before(Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_TEXT, "", ([]), "\r\n"+"    "*level), child); 
           indent_xml(child, indent_text, level+1);
       }
   }
   if (subnodes && level)
       parent->add_child(Parser.XML.Tree.SimpleNode(Parser.XML.Tree.XML_TEXT, "", ([]), "\r\n"+"    "*(level-1)));
   return parent;

}


indent_xml(make_xml_tree(input))->render_xml(); Result: "<?xml version='1.0' encoding='utf-8'?>\r\n" 

       "<root>\r\n"
       "    <element>Some text here</element>\r\n"
       "</root>"

indent_xml(make_xml_tree(input), 1)->render_xml(); Result: "<?xml version='1.0' encoding='utf-8'?>\r\n" 

       "<root>\r\n"
       "    <element>\r\n"
       "        Some text here\r\n"
       "    </element>\r\n"
       "</root>"</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>

Racket

<lang racket>

  1. lang at-exp racket

(require xml)

(define xml-str 

 @~a{<?xml version="1.0" ?>
      <root>
          <element>
              Some text here
          </element>
      </root>})
read & parse to get an xml value

(define xml (read-xml/document (open-input-string xml-str)))

print it out in xml form, which is identical to the input xml

(write-xml xml) (newline) </lang>

Rascal

<lang rascal>import lang::xml::DOM;

public void main(){ x = document(element(none(), "root", [element(none(), "element", [charData("Some text here")])])); return println(xmlPretty(x)); }</lang> Output example: <lang rascal>rascal>main() <?xml version="1.0" encoding="UTF-8"?> <root> 

 <element>Some text here</element>

</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>

Scala

<lang scala>val xml = <root><element>Some text here</element></root> scala.xml.XML.save(filename="output.xml", node=xml, enc="UTF-8", xmlDecl=true, doctype=null)</lang>

Sidef

Translation of: Perl

<lang ruby>require('XML::Simple'); print %S'XML::Simple'.XMLout( 

   :(root => :( element => 'Some text here' )),
   NoAttr => 1, RootName => ,

);</lang>

Output:
  <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>

XProc

<lang xml><p:pipeline xmlns:p="http://www.w3.org/ns/xproc" version="1.0"> 

 <p:identity>
   <p:input port="source">
     <p:inline>
       <root>
         <element>
           Some text here
         </element>
       </root>
     </p:inline>
   </p:input>
 </p:identity>

</p:pipeline></lang>

XQuery

In XQuery static element construction is like normal XML: <lang xquery><root> 

 <element>
   Some text here
 </element>

</root></lang>

Dynamic element construction looks quite different: <lang xquery>let $rootTagname := 'root' let $elementTagname := 'element' let $elementContent := 'Some text here'

return 

 element {$rootTagname}
         {
           element{$elementTagname}
                  {$elementContent}
         }</lang>

XSLT

<lang xml><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=13994"