XML/DOM serialization: Difference between revisions
m Added the Sidef language |
|||
Line 1,040:
<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>
=={{header|Sidef}}==
{{trans|Perl}}
<lang ruby>require 'XML::Simple';
print %S'XML::Simple'.XMLout(
:{root => :{ element => 'Some text here' }},
NoAttr => 1, RootName => '',
);</lang>
{{out}}
<pre>
<root>
<element>Some text here</element>
</root>
</pre>
=={{header|Tcl}}==
|
Revision as of 18:06, 16 September 2015
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
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>
C
<lang c>#include <stdio.h>
- include <stdlib.h>
- include <string.h>
- include <libxml/parser.h>
- 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
<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
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
<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
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
<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
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
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>
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>
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>
NetRexx
<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
<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
<lang perl>use XML::Simple; print XMLout( { root => { element => "Some text here" } }, NoAttr => 1, RootName => "" );</lang>
Output:
<root> <element>Some text here</element> </root>
<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>
<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
<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
<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>
- 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
<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')
- save to a string
- (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
<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
<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>
- Programming Tasks
- XML
- ABAP
- Ada
- AutoHotkey
- C
- Libxml
- C sharp
- Caché ObjectScript
- Clojure
- Clojure.data.xml
- Common Lisp
- Closure XML
- D
- E
- F Sharp
- Fantom
- Forth
- Forth Foundation Library
- Go
- Bitbucket.org/rj/xmldom-go
- Groovy
- Haskell
- J
- Java
- JavaScript
- Lasso
- Mathematica
- NetRexx
- Nim
- Objeck
- OpenEdge/Progress
- Oz
- Pascal
- Classes
- XMLWrite
- DOM
- Perl
- LibXML
- PHP
- PicoLisp
- Pike
- Python
- Racket
- Rascal
- Ruby
- REXML
- Scala
- Sidef
- Tcl
- TDOM
- XProc
- XQuery
- XSLT
- Batch File/Omit
- GUISS/Omit
- ML/I/Omit
- M4/Omit
- PARI/GP/Omit