Struct Name 

pub struct Name { /* private fields */ }

An owned name stores the name, namespace and prefix as owned strings.

An owned name is handy when you don’t want to depend on Xot, or for debugging.

It cannot be used to create elements directly, but you can turn this into a CreateName using OwnedName::to_create and a RefName using OwnedName::to_ref.

You can access name string information using the NameStrInfo trait.

If you enable the serde feature it can be serialized and deserialized.

Implementations

impl OwnedName

pub fn new(local_name: String, namespace: String, prefix: String) -> OwnedName

Create a new owned name.

pub fn name(local_name: &str) -> OwnedName

Create a name without a namespace

pub fn namespaced( local_name: String, namespace: String, prefix_lookup: impl Fn(&str) -> Option<String>, ) -> Result<OwnedName, Error>

Create a new name in a namespace, look up prefix information.

pub fn prefixed( prefix: &str, local_name: &str, lookup_namespace: impl Fn(&str) -> Option<String>, ) -> Result<OwnedName, Error>

Create a new owned name from a prefix and a name.

pub fn parse_full_name( full_name: &str, lookup_namespace: impl Fn(&str) -> Option<String>, ) -> Result<OwnedName, Error>

Given a fullname (with potentially a prefix), construct an XmlNameOwned

This requires a function that can look up the namespace for a prefix.

pub fn with_suffix(self) -> OwnedName

Convert this name into a name adding a * suffix.

This can be useful to help generate unique names.

pub fn with_default_namespace(self, namespace: &str) -> OwnedName

Convert this name into a name that’s in a particular namespace.

This only changes the namespace if there is an empty prefix and the namespace is not set (the empty string).

pub fn in_default_namespace(&self) -> bool

Name is in a namespace but without a prefix, so it’s in a default namespace.

pub fn to_ref<'a>(&self, xot: &'a mut Xot) -> RefName<'a>

Create a new RefName from this owned name.

pub fn maybe_to_ref<'a>(&self, xot: &'a Xot) -> Option<RefName<'a>>

Create a new RefName only if names already exists in Xot.

If the local name and namespace don’t exist in Xot, returns None.

This lets you pass in an immutable reference to Xot, unlike Owned::to_ref.

Ignores prefix information - even if the prefix doesn’t exist, we still get a ref name, just without a prefix. This is because the prefix information is irrelevant for comparison.

Otherwise, returns None.

pub fn to_create(&self, xot: &mut Xot) -> CreateName

Create a new CreateName name from this owned name.

This disregards the prefix information.

Trait Implementations

impl Clone for OwnedName

fn clone(&self) -> OwnedName

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OwnedName

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

Formats the value using the given formatter.

impl From<OwnedName> for Atomic

fn from(n: OwnedName) -> Atomic

Converts to this type from the input type.

impl Hash for OwnedName

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl NameStrInfo for OwnedName

fn local_name(&self) -> &str

Access the local name as a string reference

fn namespace(&self) -> &str

Get the namespace uri as a str reference.

fn prefix(&self) -> &str

Access the prefix as a string

fn full_name(&self) -> Cow<'_, str>

Access the full name as a string

impl PartialEq for OwnedName

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl TryFrom<Atomic> for OwnedName

type Error = Error

The type returned in the event of a conversion error.

fn try_from( a: Atomic, ) -> Result<OwnedName, <OwnedName as TryFrom<Atomic>>::Error>

Performs the conversion.

impl WithSpan for OwnedName

fn with_span(self, span: SimpleSpan) -> Spanned<Self>

fn with_empty_span(self) -> Spanned<Self>

impl Eq for OwnedName