XML/DOM serialization: Difference between revisions
m
syntax highlighting fixup automation
Puppydrum64 (talk | contribs) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 12:
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program createXml64.s */
Line 115:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|ABAP}}==
<syntaxhighlight lang="abap">
DATA: xml_string TYPE string.
Line 138:
cl_demo_output=>display_text( xml_string ).
</syntaxhighlight>
Output:
Line 151:
Uses [http://libre.adacore.com/libre/tools/xmlada/ XML/Ada] from AdaCore.
<
with DOM.Core.Documents;
with DOM.Core.Nodes;
Line 174:
N => My_Document,
Pretty_Print => True);
end Serialization;</
It can be shortened a lot by adding "use" clauses and writing the creation functions into the declaration part.
Line 186:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program createXml.s */
Line 362:
bx lr @ return
</syntaxhighlight>
=={{header|AutoHotkey}}==
<
xmlheader := "<?xml version=" . version . "?>" . "<" . root . ">"
Line 400:
}
Return xml .= "</" . root%root0% . ">"
}</
=={{header|Bracmat}}==
To produce the XML including all indentations, we can do this:
<
\n
(root.,"\n " (element.,"
Line 411:
: ?xml
& out$(toML$!xml)
);</
If we do not care about indentation:
<
: ?xml
& out$(toML$!xml)
);</
=={{header|C}}==
{{libheader|LibXML}}
<
#include <libxml/tree.h>
Line 437:
xmlFreeDoc(doc);
xmlCleanupParser();
}</
=={{header|C sharp}}==
Serialization using the built-in System.Xml.Serialization library of .Net.
<
using System.Xml.Serialization;
[XmlRoot("root")]
Line 456:
}
//Output: <?xml version="1.0" encoding="utf-8"?><root><element>Some text here</element></root>
}</
=={{header|C++}}==
{{libheader|LibXML}}
<
#include <cassert>
#include <cstdlib>
Line 622:
}
}
</syntaxhighlight>
=={{header|Caché ObjectScript}}==
Line 648:
{{libheader|clojure.data.xml}}
<
(require '[clojure.data.xml :as xml])
Line 656:
(java.io.FileOutputStream. "/tmp/output.xml") "UTF-8")]
(xml/emit xml-example out-file))
</syntaxhighlight>
{{out}}
Line 667:
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"))
Line 674:
(dom:append-child root element)
(dom:append-child doc root)
(dom:map-document (cxml:make-rod-sink) doc))</
gives the following output:
Line 683:
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
Line 689:
(dom:create-element doc "element"))
(dom:create-text-node doc "Some text here"))
(write-string (dom:map-document (cxml:make-rod-sink) doc)))</
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))
Line 701:
(dom:create-element doc "element")
(dom:create-text-node doc "Some text here"))
(write-string (dom:map-document (cxml:make-rod-sink) doc)))</
=={{header|D}}==
{{works with|D|2.011+}}
<
import std.stdio ;
Line 716:
writefln(doc) ;
// output: <?xml version="1.0"?><root><element>Some text here</element></root>
}</
=={{header|E}}==
Line 722:
This makes use of XML libraries provided with Java.
<
.newInstance() \
.newDocumentBuilder() \
Line 732:
element.appendChild(
document.createTextNode("Some text here"))
println(document.saveXML(root))</
(On the use of <tt><unsafe></tt>: The class has not yet been reviewed for E safety, so <tt><import:...makeDocumentBuilderFactory></tt> is not yet allowed. The review would probably be straightforward.)
=={{header|F_Sharp|F#}}==
<
[<EntryPoint>]
Line 753:
xw.Formatting <- Formatting.Indented
xd.WriteContentTo(xw)
0</
Output
<pre><?xml version="1.0"?>
Line 761:
=={{header|Factor}}==
<
<XML <root><element>Some text here</element></root> XML>
pprint-xml</
{{out}}
<pre>
Line 776:
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>
pprint-xml</
{{out}}
<pre style="height:60ex">
Line 805:
=={{header|Fantom}}==
<
using xml
Line 823:
}
}
</syntaxhighlight>
Output:
Line 835:
=={{header|Forth}}==
{{libheader|Forth Foundation Library}}
<
\ Create a dom variable 'doc' in the dictionary
Line 863:
doc dom-write-string [IF]
type cr
[THEN]</
=={{header|Go}}==
Line 869:
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 (
Line 889:
}
fmt.Println(string(d.ToXml()))
}</
{{out}}
<
<element>
Some text here
</element>
</root></
=={{header|Groovy}}==
<
def writer = new StringWriter() << '<?xml version="1.0" ?>\n'
def xml = new MarkupBuilder(writer)
Line 904:
element('Some text here' )
}
println writer</
=={{header|Haskell}}==
Line 910:
Using the XML.Light module from [http://hackage.haskell.org/package/xml-1.3.4 HackageDB]
<
import Text.XML.Light
Line 923:
Nothing
]
Nothing</
Output:
<pre>*Main> mapM_ (putStrLn.ppContent) $ parseXML (xmlDOM " Some text ")
Line 934:
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.
Line 944:
<y,x,LF
end.
)</
And here is a document object that matches this task:
<
Example use:
<
<?xml version="1.0" ?>
<root>
Line 958:
some text here
</element>
</root></
=={{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;
Line 1,068:
}
}
</syntaxhighlight>
'''Output:'''
<
<root>
<element>Some text here</element>
</root></
=={{header|JavaScript}}==
Line 1,081:
DOM
<
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 );</
E4X
<
<element>Some text here</element>
</root>;
var xmlString = xml.toXMLString();</
E4X — with processing instruction
<
var xml = <?xml version="1.0"?>
<root>
<element>Some text here</element>
</root>;
var xmlString = xml.toXMLString();</
=={{header|Julia}}==
<
# Modified from the documentation for LightXML.jl. The underlying library requires an encoding string be printed.
Line 1,123:
println(xdoc)
</
<?xml version="1.0" encoding="utf-8"?>
<root>
Line 1,136:
So I've decided to leave it as it is.
<
import javax.xml.parsers.DocumentBuilderFactory
Line 1,166:
}
println(sw)
}</
{{out}}
Line 1,177:
=={{header|Lasso}}==
<
content_type( 'text/xml' );// set MIME type if serving
xml( '<?xml version="1.0" ?><root><element>Some text here</element></root>' );
</syntaxhighlight>
=={{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' ?>")
Line 1,199:
put doc.toString()
-- "<?xml version='1.0' ?><root><element>Some text here</element></root>"</
=={{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)
dom:save("dom.xml")</
Resulting contents of dom.xml:
<pre><?xml version="1.0"?>
Line 1,218:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
XMLElement["root", {}, {XMLElement["element", {}, {"Some text here"}]}], {}];
ExportString[DOM, "XML", "AttributeQuoting" -> "\""]</
{{out}}
<pre><?xml version="1.0" encoding="utf-8"?>
Line 1,228:
=={{header|MATLAB}}==
<
docRootNode = docNode.getDocumentElement;
thisElement = docNode.createElement('element');
thisElement.appendChild(docNode.createTextNode('Some text here'));
docRootNode.appendChild(thisElement);
</syntaxhighlight>
Output:
<pre> xmlwrite(docNode)
Line 1,247:
=={{header|NetRexx}}==
{{trans|Java}}
<
options replace format comments java crossref symbols nobinary
Line 1,315:
return
</syntaxhighlight>
'''Output:'''
<
<root>
<element>Some text here</element>
</root></
=={{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
Line 1,339:
firstElement.appendChild textNode
echo document</
Output:
<pre><?xml version="1.0" encoding="UTF-8" ?>
Line 1,349:
=={{header|Objeck}}==
<
bundle Default {
Line 1,361:
}
}
}</
=={{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.
Line 1,389:
hxdoc:SAVE( 'LONGCHAR', lcc ).
MESSAGE STRING( lcc ) VIEW-AS ALERT-BOX.
</syntaxhighlight>
=={{header|Oz}}==
With the code from [[XML Creation#Oz]], we can write:
<
proc {Main}
DOM = root(element("Some text here"))
Line 1,400:
{System.showInfo {Serialize DOM}}
end
...</
Output:
<
<root>
<element>Some text here</element>
</root></
=={{header|Pascal}}==
{{works with|Free_Pascal}} {{libheader|Classes}} {{libheader|XMLWrite}} {{libheader|DOM}}
<
{$mode objfpc}{$H+}
Line 1,435:
NodoHijo.free;
Xdoc.free;
end.</
Output:<pre>
Line 1,447:
{{libheader|XML::Simple}}
<
print XMLout( { root => { element => "Some text here" } }, NoAttr => 1, RootName => "" );</
'''Output''':
Line 1,456:
{{libheader|XML::DOM::BagOfTricks}}
<
my ($doc, $root) = createDocument('root');
Line 1,462:
createTextElement($doc, 'element', 'Some text here')
);
print $doc->toString;</
'''Output''':
Line 1,468:
{{libheader|LibXML}}
<
$xml = XML::LibXML::Document->new('1.0');
Line 1,479:
$node->addChild($node2);
print $xml->toString;</
'''Output''':
Line 1,486:
=={{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>
Line 1,493:
<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;">`<?xml version="1.0" ?>`</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>
Line 1,505:
=={{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
Line 1,513:
$root->appendChild($element);
$dom->appendChild($root);
$xmlstring = $dom->saveXML();</
=={{header|PicoLisp}}==
<
(xml? T)
(xml '(root NIL (element NIL "Some text here")))</
Output:
<pre><?xml version="1.0" encoding="utf-8"?>
Line 1,528:
=={{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", ([]), "");
Line 1,541:
dom->render_xml();
Result: "<?xml version='1.0' encoding='utf-8'?><root><element>Some text here</element></root>"</
from an array, using a conversion function:
<
{
level++;
Line 1,570:
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>"</
to render the output with indenting as specified in the task, this function adds the necessary text nodes:
<
{
int subnodes = false;
Line 1,604:
" Some text here\r\n"
" </element>\r\n"
"</root>"</
=={{header|Python}}==
{{works with|Python|2.5}}
<
dom = getDOMImplementation()
Line 1,619:
firstElement.appendChild(textNode)
xmlString = document.toprettyxml(" " * 4)</
<
root = et.Element("root")
et.SubElement(root, "element").text = "Some text here"
xmlString = et.tostring(root)</
=={{header|Racket}}==
<
#lang at-exp racket
(require xml)
Line 1,645:
(write-xml xml)
(newline)
</syntaxhighlight>
=={{header|Raku}}==
Line 1,651:
{{works with|Rakudo|2018.05}}
<syntaxhighlight lang="raku"
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>
</root></
=={{header|Ruby}}==
{{libheader|REXML}}
<
include REXML
(doc = Document.new) << XMLDecl.new
Line 1,687:
serialized = String.new
doc.write(serialized, 4)
puts serialized</
produces
Line 1,698:
=={{header|Scala}}==
<
scala.xml.XML.save(filename="output.xml", node=xml, enc="UTF-8", xmlDecl=true, doctype=null)</
=={{header|Sidef}}==
{{trans|Perl}}
<
print %S'XML::Simple'.XMLout(
:(root => :( element => 'Some text here' )),
NoAttr => 1, RootName => '',
);</
{{out}}
<pre>
Line 1,717:
=={{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"]
$d asXML</
<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"]
dom::DOMImplementation serialize $doc -newline {element}</
<pre><?xml version='1.0'?>
<!DOCTYPE root>
Line 1,743:
=={{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
Line 1,779:
root.addChild(child)
var doc = XmlDocument.new(root)
System.print(doc)</
{{out}}
Line 1,793:
{{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(
Line 1,800:
)
)
System.print(doc)</
{{out}}
<pre>
Line 1,810:
=={{header|XProc}}==
<
<p:identity>
<p:input port="source">
Line 1,822:
</p:input>
</p:identity>
</p:pipeline></
=={{header|XQuery}}==
In XQuery static element construction is like normal XML:
<
<element>
Some text here
</element>
</root></
Dynamic element construction looks quite different:
<
let $elementTagname := 'element'
let $elementContent := 'Some text here'
Line 1,842:
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 -->
Line 1,854:
</xsl:element>
</xsl:template>
</xsl:stylesheet></
=={{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
Line 1,953:
org &1300
XMLRam: ;this is where the output is stored.</
{{out}}
|