Enum nom_xml::Document

pub enum Document {
    Prolog {
        xml_decl: Option<XmlDecl>,
        misc: Option<Vec<Misc>>,
        doc_type: Option<DocType>,
    },
    Element(Tag, Box<Document>, Tag),
    Content(Option<String>),
    Nested(Vec<Document>),
    Empty,
    EmptyTag(Tag),
    ProcessingInstruction(ProcessingInstruction),
    Comment(String),
    CDATA(String),
}

Main entry point for parsing XML documents

This enum encapsulates all of the top level types that comprise an XML document. The core variant is the Element(Tag,Box<Document>,Tag) type which allows recursive parsing of nested tags and their content.

Variants

Prolog

Fields

xml_decl: Option<XmlDecl>

misc: Option<Vec<Misc>>

doc_type: Option<DocType>

Element(Tag, Box<Document>, Tag)

Content(Option<String>)

Nested(Vec<Document>)

Empty

EmptyTag(Tag)

ProcessingInstruction(ProcessingInstruction)

Comment(String)

CDATA(String)

Implementations

impl Document

pub fn parse_prolog( input: &str, entity_references: Rc<RefCell<HashMap<(Name, EntitySource), EntityValue>>>, config: Config ) -> IResult<&'_ str, (Option<Document>, Rc<RefCell<HashMap<(Name, EntitySource), EntityValue>>>)>

pub fn iter_with_depth(&self, max_level: usize) -> DocumentIterator<'_>

The main interface for exracting content from the Document tree See the extract_information example for more information

Examples found in repository

examples/extract_information.rs (line 128)

    fn update_field(&mut self, tag: &Tag, doc: &Document) {
        let field_name = &tag.name.local_part;
        if let Some(attributes_vec) = &tag.attributes {
            if let Attribute::Instance {
                name,
                value: AttributeValue::Value(attr_val),
            } = attributes_vec.get(0).unwrap()
            {
                if name.local_part == "isbn" {
                    self.isbn = attr_val.to_string();
                }
            }
        }
        if let Document::Nested(_) = &doc {
            doc.iter_with_depth(1).for_each(|record| {
                if let Document::Element(tag, inner_doc, _) = record {
                    self.update_field(tag, inner_doc);
                } else {
                    eprintln!("Unknown field: {record:#?}");
                }
            });
        } else if let Document::Content(Some(value)) = &doc {
            match field_name.as_str() {
                "author" => {
                    self.author = value.to_string();
                }
                "title" => {
                    self.title = value.to_string();
                }
                "genre" => {
                    self.genre = value.to_string();
                }
                "description" => {
                    self.description = value.to_string();
                }
                e => {
                    eprintln!("Unknown field: {}", e);
                }
            }
        } else {
            eprintln!("Content is missing");
        }
    }
}

fn main() -> Result<()> {
    let mut file = File::open("examples/TheExpanseSeries.xml")?;
    let data = read_file(&mut file)?;
    let (_, doc) = Document::parse_element_by_tag_name(&data, "book", &None)?;
    let mut book = Book::default();
    doc.iter_with_depth(0)
        .filter_map(|record| {
            if let Document::Element(tag, inner_doc, _) = record {
                Some((tag, inner_doc))
            } else {
                None
            }
        })
        .for_each(|(tag, inner_doc)| book.update_field(tag, &inner_doc));
    println!("{book:#?}");
    Ok(())
}

pub fn parse_element_by_tag_name<'a>( input: &'a str, tag_name: &'a str, attributes: &Option<Vec<Attribute>> ) -> IResult<&'a str, Document>

The main interface for parsing the first element that matches criteria

See the parse_first_matching_element example for more information

Run with cargo run --example parse_first_matching_element

Also see the parse_element_with_specific_attribute_value example

Run with cargo run --example parse_element_with_specific_attribute_value

Examples found in repository

examples/parse_first_matching_element.rs (line 30)

fn main() -> Result<()> {
    let mut file = File::open("examples/TheExpanseSeries.xml")?;
    let data = read_file(&mut file)?;
    let (_, doc) = Document::parse_element_by_tag_name(&data, "book", &None)?;
    println!("{doc:?}");
    Ok(())
}

examples/parse_element_with_specific_attribute_value.rs (lines 29-33)

fn main() -> Result<()> {
    let mut file = File::open("examples/TheExpanseSeries.xml")?;
    let data = read_file(&mut file)?;
    let (_, doc) = Document::parse_element_by_tag_name(
        &data,
        "book",
        &Some(vec![Attribute::new("isbn", "978-0316332910")]),
    )?;
    println!("{doc:?}");
    Ok(())
}

examples/extract_information.rs (line 162)

fn main() -> Result<()> {
    let mut file = File::open("examples/TheExpanseSeries.xml")?;
    let data = read_file(&mut file)?;
    let (_, doc) = Document::parse_element_by_tag_name(&data, "book", &None)?;
    let mut book = Book::default();
    doc.iter_with_depth(0)
        .filter_map(|record| {
            if let Document::Element(tag, inner_doc, _) = record {
                Some((tag, inner_doc))
            } else {
                None
            }
        })
        .for_each(|(tag, inner_doc)| book.update_field(tag, &inner_doc));
    println!("{book:#?}");
    Ok(())
}

pub fn parse_elements_by_tag_name<'a>( input: &'a str, tag_name: &'a str, attributes: &Option<Vec<Attribute>> ) -> IResult<&'a str, Vec<Document>>

The main interface for parsing many elements with the same tag name

See the parse_all_of_specific_tag example for more information

Run with cargo run --example parse_all_of_specific_tag

Examples found in repository

examples/parse_all_of_specific_tag.rs (line 31)

fn main() -> Result<()> {
    let mut file = File::open("examples/TheExpanseSeries.xml")?;
    let data = read_file(&mut file)?;

    let (_, doc) = Document::parse_elements_by_tag_name(&data, "book", &None)?;
    println!("{doc:?}");
    Ok(())
}

Trait Implementations

impl Clone for Document

fn clone(&self) -> Document

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Document

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DynamicEquality for Document

fn equals(&self, pattern: Pattern<'_>, method: ComparisonMethod) -> bool

impl<'a> Parse<'a> for Document

fn parse(input: &'a str, args: Self::Args) -> Self::Output

use nom_xml::{parse::Parse, config::Config, Document};

let xml = "<root><child>Content</child></root>";
let (_, doc) = Document::parse(xml, Config::default()).unwrap();
println!("{doc:?}");

type Args = Config

type Output = Result<(&'a str, Document), Err<Error>>

fn is_char(c: char) -> bool

fn parse_char(input: &str) -> IResult<&str, char>

fn is_whitespace(c: char) -> bool

fn parse_multispace1(input: &str) -> IResult<&str, ()>

fn parse_multispace0(input: &str) -> IResult<&str, ()>

fn is_name_start_char(c: char) -> bool

fn is_name_char(c: char) -> bool

fn parse_name_char(input: &str) -> IResult<&str, char>

fn parse_name_start_char(input: &str) -> IResult<&str, char>

fn parse_nmtoken(input: &str) -> IResult<&str, String>

fn parse_nmtokens(input: &str) -> IResult<&str, Vec<String>>

fn parse_name(input: &str) -> IResult<&str, Name>

fn parse_names(input: &str) -> IResult<&str, Vec<Name>>

fn parse_eq(input: &str) -> IResult<&str, ()>

fn capture_span<O, F>( f: F ) -> Box<dyn FnMut(&'a str) -> IResult<&'a str, (&'a str, O)> + 'a>

where F: FnMut(&'a str) -> IResult<&'a str, O> + 'a,

impl<'a> ParseNamespace<'a> for Document

fn parse_namespace_attribute_name(input: &str) -> IResult<&str, Name>

fn parse_prefixed_attribute_name(input: &str) -> IResult<&str, Name>

fn parse_non_colonized_name(input: &str) -> IResult<&str, String>

fn parse_non_colonized_name_char(input: &str) -> IResult<&str, char>

fn parse_non_colonized_name_start_char(input: &str) -> IResult<&str, char>

fn parse_qualified_name(input: &str) -> IResult<&str, Name>

fn parse_prefixed_name(input: &str) -> IResult<&str, Name>

impl PartialEq for Document

fn eq(&self, other: &Document) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Document

impl StructuralPartialEq for Document