Enum Name

Source

pub enum Name {
    Named(Cow<'static, str>),
    Unnamed {
        id: usize,
        ext: Option<Cow<'static, str>>,
    },
}

Expand description

Type that represents a name of a XSD element

Variants§

§

Named(Cow<'static, str>)

The name was explicitly set to the given value.

§

Unnamed

The name is unknown and should be generated out of the provided information.

Fields

§id: usize

Unique id for this name.

§ext: Option<Cow<'static, str>>

Extension that may be added to the name.

Implementations§

Source §

impl Name

Source

pub const fn named(name: &'static str) -> Self

Create a new Name::Named using the passed name.

Source

pub fn new<S: Into<String>>(name: S) -> Self

Create a new Name::Named using the passed name.

Source

pub fn remove_suffix(&self, suffix: &str) -> Self

Remove the provided suffix from the Name::Named or the Name::Unnamed::ext

§Examples

let name = Name::new("test-fuu");
let expected = Name::new("test");
assert_eq!(name.remove_suffix("-fuu"), expected);

let name = Name::Unnamed { id: 123, ext: Some(Cow::Borrowed("test-fuu")) };
let expected = Name::Unnamed { id: 123, ext: Some(Cow::Owned("test".into())) };;
assert_eq!(name.remove_suffix("-fuu"), expected);

Source

pub fn to_type_named(&self, with_id: bool, name: Option<&str>) -> Self

Create a type name from this Name object.

This method can be used to generate a rust type name from this name object. The resulting name is written in pascal case and may or may not contain additional information depending on the passed arguments.

§Arguments

with_id Wether to add the unique id of the name to the resulting name or not
name Optional name that should be added to the resulting name

§Examples


let name = Name::new("test");
assert_eq!(Name::new("Test"), name.to_type_named(false, None));
assert_eq!(Name::new("Test"), name.to_type_named(true, None));
assert_eq!(Name::new("Test"), name.to_type_named(false, Some("extra")));
assert_eq!(Name::new("Test"), name.to_type_named(true, Some("extra")));

let name = Name::Unnamed { id: 123, ext: None };
assert_eq!(Name::new("Unnamed123"), name.to_type_named(false, None));
assert_eq!(Name::new("Extra"), name.to_type_named(false, Some("extra")));
assert_eq!(Name::new("Unnamed123"), name.to_type_named(true, None));
assert_eq!(Name::new("Extra123"), name.to_type_named(true, Some("extra")));

let name = Name::Unnamed { id: 123, ext: Some(Cow::Borrowed("ext")) };
assert_eq!(Name::new("ExtUnnamed123"), name.to_type_named(false, None));
assert_eq!(Name::new("ExtExtra"), name.to_type_named(false, Some("extra")));
assert_eq!(Name::new("ExtUnnamed123"), name.to_type_named(true, None));
assert_eq!(Name::new("ExtExtra123"), name.to_type_named(true, Some("extra")));

Source

pub fn is_named(&self) -> bool

Returns true if this is a Name::Named, false otherwise.

Source

pub fn is_unnamed(&self) -> bool

Returns true if this is a Name::Unnamed, false otherwise.

Source

pub fn has_extension(&self) -> bool

Returns true if this is a Name::Unnamed with extensions, false otherwise.

Source

pub fn as_str(&self) -> Option<&str>

Returns the value of Name::Named as Some(&str), or None if it’s an Name::Unnamed.

Source

pub fn extend(self, replace: bool, iter: I) -> Self
where I: IntoIterator, I::Item: Display,

Adds extensions to this name.

§Arguments

replace replace any existing extension with the new one
iter iterator of extensions to apply

§Examples


let name = Name::new("test");
assert_eq!(Name::new("extTest"), name.extend(false, Some("ext")));

let name = Name::Unnamed { id: 123, ext: Some(Cow::Borrowed("ext")) };
assert_eq!(Name::Unnamed { id: 123, ext: Some(Cow::Owned("fuu".into())) }, name.clone().extend(true, Some("fuu")));
assert_eq!(Name::Unnamed { id: 123, ext: Some(Cow::Owned("fuuExt".into())) }, name.extend(false, Some("fuu")));