Struct xml::name::Name [] [src]

pub struct Name<'a> {
    pub local_name: &'a str,
    pub namespace: Option<&'a str>,
    pub prefix: Option<&'a str>,
}
[]

Represents a qualified XML name.

A qualified name always consists at least of a local name. It can optionally contain a prefix; when reading an XML document, if it contains a prefix, it must also contain a namespace URI, but this is not enforced statically; see below. The name can contain a namespace without a prefix; in that case a default, empty prefix is assumed.

When writing XML documents, it is possible to omit the namespace URI, leaving only the prefix. In this case the writer will check that the specifed prefix is bound to some URI in the current namespace context. If both prefix and namespace URI are specified, it is checked that the current namespace context contains this exact correspondence between prefix and namespace URI.

Prefixes and URIs

A qualified name with a prefix must always contain a proper namespace URI --- names with a prefix but without a namespace associated with that prefix are meaningless. However, it is impossible to obtain proper namespace URI by a prefix without a context, and such context is only available when parsing a document (or it can be constructed manually when writing a document). Tying a name to a context statically seems impractical. This may change in future, though.

Conversions

Name implements some From instances for conversion from strings and tuples. For example:

let n1: Name = "p:some-name".into();
let n2: Name = ("p", "some-name").into();

assert_eq!(n1, n2);
assert_eq!(n1.local_name, "some-name");
assert_eq!(n1.prefix, Some("p"));
assert!(n1.namespace.is_none());

This is added to support easy specification of XML elements when writing XML documents.

Fields

local_name

A local name, e.g. string in xsi:string.

namespace

A namespace URI, e.g. http://www.w3.org/2000/xmlns/.

prefix

A name prefix, e.g. xsi in xsi:string.

Methods

impl<'a> Name<'a>

fn to_owned(&self) -> OwnedName[]

Returns an owned variant of the qualified name.

fn local(local_name: &str) -> Name[]

Returns a new Name instance representing plain local name.

fn prefixed(local_name: &'a str, prefix: &'a str) -> Name<'a>[]

Returns a new Name instance with the given local name and prefix.

fn qualified(local_name: &'a str, namespace: &'a str, prefix: Option<&'a str>) -> Name<'a>[]

Returns a new Name instance representing a qualified name with or without a prefix and with a namespace URI.

fn to_repr(&self) -> String[]

Returns a correct XML representation of this local name and prefix.

This method is different from the autoimplemented to_string() because it does not include namespace URI in the result.

fn repr_display(&self) -> ReprDisplay[]

Returns a structure which can be displayed with std::fmt machinery to obtain this local name and prefix.

This method is needed for efficiency purposes in order not to create unnecessary allocations.

fn prefix_repr(&self) -> &str[]

Returns either a prefix of this name or namespace::NS_NO_PREFIX constant.

Trait Implementations

impl<'a> From<&'a str> for Name<'a>

fn from(s: &'a str) -> Name<'a>

impl<'a> From<(&'a str, &'a str)> for Name<'a>

fn from((prefix, name): (&'a str, &'a str)) -> Name<'a>

impl<'a> Display for Name<'a>

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

Derived Implementations

impl<'a> Debug for Name<'a>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

impl<'a> Hash for Name<'a>

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

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

impl<'a> Eq for Name<'a>

impl<'a> PartialEq for Name<'a>

fn eq(&self, __arg_0: &Name<'a>) -> bool

fn ne(&self, __arg_0: &Name<'a>) -> bool

impl<'a> Clone for Name<'a>

fn clone(&self) -> Name<'a>

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

impl<'a> Copy for Name<'a>