XML/DOM serialization: Difference between revisions

</element>

</root>

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program createXml64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

=={{header|ABAP}}==

DATA: xml_string TYPE string.

 

 

cl_demo_output=>display_text( xml_string ).

 

Output:

Uses [http://libre.adacore.com/libre/tools/xmlada/ XML/Ada] from AdaCore.

 

with DOM.Core.Documents;

with DOM.Core.Nodes;

N => My_Document,

Pretty_Print => True);

 

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

<element>Some text here</element>

</root></pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program createXml.s */

bx lr @ return

=={{header|AutoHotkey}}==

xmlheader := "<?xml version=" . version . "?>" . "<" . root . ">"

 

}

Return xml .= "</" . root%root0% . ">"

 

=={{header|Bracmat}}==

To produce the XML including all indentations, we can do this:

\n

(root.,"\n " (element.,"

: ?xml

& out$(toML$!xml)

If we do not care about indentation:

: ?xml

& out$(toML$!xml)

 

=={{header|C}}==

#include <libxml/tree.h>

int main()

{

xmlDoc *doc = xmlNewDoc("1.0");

xmlDocSetRootElement(doc, root);

 

xmlAddChild(root, node);

 

xmlFreeDoc(doc);

xmlCleanupParser();

 

=={{header|C sharp}}==

Serialization using the built-in System.Xml.Serialization library of .Net.

using System.Xml.Serialization;

[XmlRoot("root")]

}

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

 

=={{header|Caché ObjectScript}}==

{{libheader|clojure.data.xml}}

 

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

 

(java.io.FileOutputStream. "/tmp/output.xml") "UTF-8")]

(xml/emit xml-example out-file))

 

{{out}}

Assuming that matching the whitespace in the problem description isn't necessary and that character encodings are permitted (see the [[Talk:DOM XML Serialization|talk page]]):

 

(root (dom:create-element doc "root"))

(element (dom:create-element doc "element"))

(dom:append-child root element)

(dom:append-child doc root)

 

gives the following output:

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

 

(dom:append-child

(dom:append-child

(dom:create-element doc "element"))

(dom:create-text-node doc "Some text here"))

 

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

 

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

 

(dom:create-element doc "element")

(dom:create-text-node doc "Some text here"))

 

=={{header|D}}==

{{works with|D|2.011+}}

 

import std.stdio ;

writefln(doc) ;

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

 

=={{header|E}}==

This makes use of XML libraries provided with Java.

 

.newInstance() \

.newDocumentBuilder() \

element.appendChild(

document.createTextNode("Some text here"))

 

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

 

 

=={{header|F_Sharp|F#}}==

 

[<EntryPoint>]

xw.Formatting <- Formatting.Indented

xd.WriteContentTo(xw)

Output

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

<element>Some text here</element>

</root></pre>

 

=={{header|Fantom}}==

 

using xml

}

}

 

Output:

=={{header|Forth}}==

{{libheader|Forth Foundation Library}}

 

\ Create a dom variable 'doc' in the dictionary

doc dom-write-string [IF]

type cr

 

=={{header|Go}}==

 

import (

"fmt"

)

 

}

fmt.Println(string(d.ToXml()))

{{out}}

<element>

Some text here

</element>

 

=={{header|Groovy}}==

def writer = new StringWriter() << '<?xml version="1.0" ?>\n'

def xml = new MarkupBuilder(writer)

element('Some text here' )

}

 

=={{header|Haskell}}==

Using the XML.Light module from [http://hackage.haskell.org/package/xml-1.3.4 HackageDB]

 

import Text.XML.Light

 

Nothing

]

Output:

<pre>*Main> mapM_ (putStrLn.ppContent) $ parseXML (xmlDOM " Some text ")

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

 

serialize1=:4 :0

if.L.x do.

<y,x,LF

end.

 

And here is a document object that matches this task:

 

 

Example use:

 

<?xml version="1.0" ?>

<root>

some text here

</element>

 

=={{header|Java}}==

[[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.

import java.io.StringWriter;

 

}

}

 

'''Output:'''

 

<root>

<element>Some text here</element>

 

=={{header|JavaScript}}==

DOM

 

var root = doc.documentElement;

var element = doc.createElement( 'element' );

root.appendChild( element );

element.appendChild( document.createTextNode('Some text here') );

 

E4X

 

<element>Some text here</element>

</root>;

 

E4X — with processing instruction

 

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

<root>

<element>Some text here</element>

</root>;

 

=={{header|Julia}}==

 

# Modified from the documentation for LightXML.jl. The underlying library requires an encoding string be printed.

println(xdoc)

 

<?xml version="1.0" encoding="utf-8"?>

<root>

 

So I've decided to leave it as it is.

 

import javax.xml.parsers.DocumentBuilderFactory

}

println(sw)

 

{{out}}

 

=={{header|Lasso}}==

content_type( 'text/xml' );// set MIME type if serving

 

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

 

 

=={{header|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).

doc = newObject("XML", "<?xml version='1.0' ?>")

 

 

put doc.toString()

 

=={{header|Lua}}==

Using the widely available 'LuaXML' module

local dom = xml.new("root")

local element = xml.new("element")

table.insert(element, "Some text here")

dom:append(element)

Resulting contents of dom.xml:

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

</root></pre>

 

XMLElement["root", {}, {XMLElement["element", {}, {"Some text here"}]}], {}];

<pre><?xml version="1.0" encoding="utf-8"?>

<root>

 

=={{header|MATLAB}}==

docRootNode = docNode.getDocumentElement;

thisElement = docNode.createElement('element');

thisElement.appendChild(docNode.createTextNode('Some text here'));

docRootNode.appendChild(thisElement);

Output:

<pre> xmlwrite(docNode)

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols nobinary

 

 

return

 

'''Output:'''

 

<root>

<element>Some text here</element>

 

=={{header|Nim}}==

 

var

firstElement.appendChild textNode

 

Output:

<pre><?xml version="1.0" encoding="UTF-8" ?>

 

=={{header|Objeck}}==

 

bundle Default {

}

}

 

=={{header|OpenEdge/Progress}}==

The following example uses the X-DOCUMENT, for faster processing SAX can be used.

DEFINE VARIABLE hxdoc AS HANDLE NO-UNDO.

DEFINE VARIABLE hxroot AS HANDLE NO-UNDO.

hxdoc:SAVE( 'LONGCHAR', lcc ).

MESSAGE STRING( lcc ) VIEW-AS ALERT-BOX.

 

=={{header|Oz}}==

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

 

proc {Main}

DOM = root(element("Some text here"))

{System.showInfo {Serialize DOM}}

end

 

Output:

<root>

<element>Some text here</element>

 

=={{header|Pascal}}==

{{works with|Free_Pascal}} {{libheader|Classes}} {{libheader|XMLWrite}} {{libheader|DOM}}

 

{$mode objfpc}{$H+}

NodoRaiz.AppendChild(NodoPadre); // insertar el nodo hijo en el correspondiente nodo padre

writeXMLFile(xDoc,'prueba.xml'); // escribir el XML

Xdoc.free;

 

Output:<pre>

 

{{libheader|XML::Simple}}

 

'''Output''':

 

{{libheader|XML::DOM::BagOfTricks}}

 

my ($doc, $root) = createDocument('root');

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

);

 

'''Output''':

 

{{libheader|LibXML}}

 

$xml = XML::LibXML::Document->new('1.0');

$node->addChild($node2);

 

 

'''Output''':

<?xml version="1.0"?>

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

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|PHP}}==

{{works with|PHP|5}}

$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->appendChild($element);

$dom->appendChild($root);

 

=={{header|PicoLisp}}==

 

(xml? T)

Output:

<pre><?xml version="1.0" encoding="utf-8"?>

<element>Some text here</element>

</root></pre>

=={{header|Pike}}==

manually, one node at a time:

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->render_xml();

 

from an array, using a conversion function:

{

level++;

array input = ({ "root", ([]), ({ "element", ([]), "Some text here" }) });

make_xml_tree(input)->render_xml();

 

to render the output with indenting as specified in the task, this function adds the necessary text nodes:

{

int subnodes = false;

" Some text here\r\n"

" </element>\r\n"

 

=={{header|Python}}==

{{works with|Python|2.5}}

 

dom = getDOMImplementation()

firstElement.appendChild(textNode)

 

 

 

root = et.Element("root")

et.SubElement(root, "element").text = "Some text here"

 

=={{header|Racket}}==

#lang at-exp racket

(require xml)

(write-xml xml)

(newline)

 

=={{header|Rascal}}==

 

public void main(){

x = document(element(none(), "root", [element(none(), "element", [charData("Some text here")])]));

return println(xmlPretty(x));

Output example:

<?xml version="1.0" encoding="UTF-8"?>

<root>

<element>Some text here</element>

 

=={{header|Ruby}}==

{{libheader|REXML}}

include REXML

(doc = Document.new) << XMLDecl.new

serialized = String.new

doc.write(serialized, 4)

 

produces

 

=={{header|Scala}}==

 

=={{header|Sidef}}==

{{trans|Perl}}

print %S'XML::Simple'.XMLout(

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

NoAttr => 1, RootName => '',

{{out}}

<pre>

=={{header|Tcl}}==

{{libheader|tDOM}}

set d [dom createDocument root]

set root [$d documentElement]

$root appendChild [$d createElement element]

[$root firstChild] appendChild [$d createTextNode "Some text here"]

<pre><root>

<element>Some text here</element>

</root></pre>

Using [http://tclxml.sf.net TclDOM]

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"]

<pre><?xml version='1.0'?>

<!DOCTYPE root>

</element>

</root></pre>

 

=={{header|XProc}}==

<p:identity>

<p:input port="source">

</p:input>

</p:identity>

 

=={{header|XQuery}}==

In XQuery static element construction is like normal XML:

<element>

Some text here

</element>

 

Dynamic element construction looks quite different:

let $elementTagname := 'element'

let $elementContent := 'Some text here'

element{$elementTagname}

{$elementContent}

 

=={{header|XSLT}}==

<xsl:output method="xml" indent="yes" />

<xsl:template match="/"> <!-- replace the root of the incoming document with our own model -->

</xsl:element>

</xsl:template>

 

{{omit from|Batch File|No way of XML parsing or processing.}}