Struct xml_schema_generator::Element

pub struct Element<T> {
    pub name: T,
    pub text: Option<T>,
    /* private fields */
}

represents the structure and characteristics of an XML element

Fields

name: T

text: Option<T>

Implementations

impl<T: PartialEq + Display + Debug> Element<T>

pub fn new(name: T, attributes: Vec<T>) -> Element<T>

pub fn formatted_name(&self) -> String

format the name of the element to be properly represented as a Rust struct

pub fn standalone(&self) -> bool

return true if this tag always appears only 0 or 1 times within it’s parent element return false if this tag appears at least once more than 1 times within it’s parent element

pub fn set_multiple(&mut self)

call this function if this element appears more than once inside a parent element

pub fn count(&self) -> u32

return how often the element is present inside the current parent element, only used during parsing an XML document

pub fn increment(&mut self)

increase the counter by one, only used during parsing an XML document

pub fn merge_attr(self, attributes: Vec<Necessity<T>>) -> Element<T>

merge the given list of attributes into the list if the element’s attributes attributes that not appear in both lists are marked as optional

Example

use xml_schema_generator::Element;
use xml_schema_generator::Necessity;

let mut root = Element::new("car", vec!["name", "colour"]);
root = root.merge_attr(vec![Necessity::Mandatory("name"), Necessity::Mandatory("type")]);

pub fn add_unique_child(&mut self, child: Element<T>)

add a new child element to this element, if it does not exist yet

pub fn set_child_optional(&mut self, name: &T)

find a child element with the given name, mark it as optional if found

pub fn get_child(&self, name: &T) -> Option<&Necessity<Element<T>>>

find a child element by name and return a reference to it if found

pub fn get_child_mut(&mut self, name: &T) -> Option<&mut Necessity<Element<T>>>

find a child element by name and return it as mutable reference if found

pub fn remove_child(&mut self, name: &T) -> Option<Necessity<Element<T>>>

find a child element by name, remove it from this element and return it

pub fn children(&self) -> &Vec<Necessity<Element<T>>>

return a reference to the list of all child elements

impl<T: PartialEq + Display + Debug + Clone> Element<T>

pub fn to_serde_struct(&self, options: &Options) -> String

generate a String representing this element and all children elements recursivly as series of Rust structs those struct can be used to (de)serialize an XML document

Trait Implementations

impl<T: Clone> Clone for Element<T>

fn clone(&self) -> Element<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Element<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Element<T>

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

return true if two elements share the same name should only be used to compare two elements that share the same parent element

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.