XML/DOM serialization: Difference between revisions

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

=={{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}}==

{{libheader|LibXML}}

#include <libxml/tree.h>

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|C++}}==

{{libheader|LibXML}}

#include <cassert>

#include <cstdlib>

}

}

 

=={{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"?>

 

=={{header|Factor}}==

 

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

{{out}}

<pre>

 

Factor's XML syntax isn't just for parsing static XML. Since it supports interpolation (denoted by <code><-></code>) and plays nicely with sequences, it is easy to build up arbitrary trees:

 

3 [XML <element>Some text here</element> XML] <repetition>

[XML <element2><element3>1.0</element3></element2> XML] append

<XML <root><-></root> XML>

{{out}}

<pre style="height:60ex">

=={{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}}==

A very small, subset of the W3C DOM Core in Go. The work builds off the existing XML parser. A fork of the godom project (http://code.google.com/p/godom/), which appears to be unsupported at the moment.

 

 

import (

}

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

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

{{out}}

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

 

=={{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}}==

{{libheader|nim-xmldom}}

Note that the module “xmldom” is no longer part of the standard library as more convenient modules are now available. It can be installed using the package manager <code>nimble</code>.

 

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+}

NodoHijo.free;

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

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">/</span><span style="color: #000000;">xml</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #000000;">doc</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">xml_new_doc</span><span style="color: #0000FF;">(</span><span style="color: #000000;">root</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">`&lt;?xml version="1.0" ?&gt;`</span><span style="color: #0000FF;">})</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">xml_sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">doc</span><span style="color: #0000FF;">))</span>

{{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"?>

=={{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|Raku}}==

{{works with|Rakudo|2018.05}}

 

use XML::Writer;

 

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

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

{{out}}

 

=={{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>

=={{header|Wren}}==

Wren has no built-in or (AFAIK) third party support for XML so we code a minimal DOM sufficient for completing this task.

construct new(root) {

_root = root

root.addChild(child)

var doc = XmlDocument.new(root)

 

{{out}}

{{libheader|Wren-xsequence}}

Since the first version was written, the above XML parser has appeared and, consequently, the solution can now be rewritten as follows.

 

var doc = XDocument.new(

)

)

{{out}}

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

 

=={{header|Z80 Assembly}}==

Assembled and run using WinAPE's built-in assembler. Tags have to be manually opened and closed, but it works!

main:

ld hl,XML_Header

 

org &1300

 

{{out}}