Did you miss writing out an XML element end tag in your Rust codes? Even when you have the best tools, this kind of mistake is not hard to make, and working with XML files is always ugly. We can improve the way we code, though. There is a convenient way to avoid this in Rust using Closure.
Coming From Java
In Java, a similar implementation can be achieved using Lambda. For more information, please see A More Convenient Way to Write Out Start and End XML Tags in Java using Lambda
Requirements
We will use the following.
- Rust 1.38.0
- Cargo
- xml-rs 0.8.0
- Used for writing XML files
- Intellij IDEA
- Rust plugin for Intellij IDEA
Writing Out XML Tags Is Ugly
Do we want to write XMLs using the following codes? Do we always need to specify the closing tags or codes?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | let mut event: XmlEvent = XmlEvent::start_element("HTML").into(); w.write(event); { let mut event: XmlEvent = XmlEvent::start_element("HEAD").into(); w.write(event); { // Other elements here } event = XmlEvent::end_element().into(); w.write(event); } { let mut event: XmlEvent = XmlEvent::start_element("BODY").into(); w.write(event); { // Other elements here } event = XmlEvent::end_element().into(); w.write(event); } event = XmlEvent::end_element().into(); w.write(event); } |
For example, line 1 matches line 26. Line 5 ends at line 12 and line 16 for line 23. How can we avoid that kind of coding? We can use Closure and design our codes in such a way we only work with the start elements.
Writing XML using Closure
Writing codes using Closures does not need any crates. However, we need to use crates designed for XML writing, at least. In this post, we will use the xml-rs crate to write out XML, but our closure codes wrap codes from xml-rs.
Update Cargo.toml – Include xml-rs only
We only need one crate for this post. It is enough for our purpose of creating codes that use Rust Closures.
1 2 3 4 5 6 7 8 | [package] name = "rust-xml-write" version = "0.1.0" authors = ["Karl San Gabriel"] edition = "2018" [dependencies] xml-rs = "0.8.0" |
The Application Codes – Main.rs
First, we specify the use of statements that we need.
1 2 3 4 5 6 | use std::fs::File; use std::io::{self, Write}; use xml::writer::{EventWriter, EmitterConfig, XmlEvent, Result}; use std::collections::HashMap; use xml::writer::events::StartElementBuilder; ... |
Then, we create a function that accepts a closure plus other things. If we take a closer look at the codes, we are using codes from xml-rs codes to write out the start and end XML tag elements.
1 2 3 4 5 6 7 | fn write_element_block <W: Write, F: Fn(&mut EventWriter<W>)>(element: &str, w: &mut EventWriter<W>, f: F) { let mut event: XmlEvent = XmlEvent::start_element(element).into(); w.write(event); f(w); event = XmlEvent::end_element().into(); w.write(event); } |
Next, create a function that makes calls to write_element_block function. The handle_event function writes out the whole XML and uses the write_element_block to write out the major parts of the document. The major components are HEAD, which has the TITLE element, and BODY, which has the DIV element. Cool, no?
We did not even write codes that close off those elements and only specified the start element tag name.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | fn handle_event<W: Write>(w: &mut EventWriter<W>) -> Result<()> { return write_element_block("HTML", w, |w| { write_element_block("HEAD", w, |w| { // Other elements here write_element_block("TITLE", w, |w| { let mut event: XmlEvent = XmlEvent::Characters("Page Title").into(); w.write(event); }); }); write_element_block("BODY", w, |w| { // Other elements here write_element_block("DIV", w, |w| { let mut event: XmlEvent = XmlEvent::Characters("DIV Content").into(); w.write(event); }); }); }); } |
Finally, we have the primary function where we call the handle_event function.
1 2 3 4 5 | fn main() { let mut file = File::create("output.xml").unwrap(); let mut writer = EmitterConfig::new().perform_indent(true).create_writer(&mut file); handle_event(&mut writer); } |
The codes write XML data to a file called output.xml with the following contents.
1 2 3 4 5 6 7 8 9 | <?xml version="1.0" encoding="utf-8"?> <HTML> <HEAD> <TITLE>Page Title</TITLE> </HEAD> <BODY> <DIV>DIV Content</DIV> </BODY> </HTML> |
That is how we can create codes that conveniently write XML tags using Closures in Rust.
This post is now part of Rust Programming Language For Beginners Tutorial.
