[−][src]Struct xml_string::names::UriQualifiedName

#[repr(transparent)]pub struct UriQualifiedName(_);

String slice for URIQualifiedName.

Implementations

`impl UriQualifiedName`[src]

`pub fn from_str(s: &str) -> Result<&Self, NameError>`[src]

Creates a new &UriQualifiedName.

URIQualifiedName has Q{uri}ncname format. UriQualifiedName type validates NCName part, but does not validate URI part.

In most contexts, processors are not required to raise errors if a URI is not lexically valid according to RFC3986 and RFC3987. See 2.4.5 URI Literals for details.

--- XML Path Language (XPath) 3.1, 2 Basics

XPath 3.1 requires a statically known, valid URI in a BracedURILiteral. An implementation may raise a static error err:XQST0046 if the value of a Braced URI Literal is of nonzero length and is neither an absolute URI nor a relative URI.

--- XML Path Language (XPath) 3.1, 2.4.5 URI Literals

It is user's responsibility to validate URI part if necessary.

Failures

Fails if the given string is not a valid UriQualifiedName.

Examples

let name = UriQualifiedName::from_str("Q{http://example.com/}name")?;
assert_eq!(name, "Q{http://example.com/}name");

assert_eq!(
    UriQualifiedName::from_str("Q{}name")?,
    "Q{}name",
    "Empty URI is OK"
);
assert_eq!(
    UriQualifiedName::from_str("Q{foo}bar")?,
    "Q{foo}bar",
    "URI is not validated"
);

assert!(
    UriQualifiedName::from_str("foo").is_err(),
    "URIQualifiedName has `Q{{uri}}ncname` format"
);
assert!(
    UriQualifiedName::from_str("Q{http://example.com}foo:bar").is_err(),
    "Colon is not allowed"
);
assert!(
    UriQualifiedName::from_str("Q{foo{bar}qux").is_err(),
    "URI part cannot have `{{` and `}}`"
);

`#[must_use]pub unsafe fn new_unchecked(s: &str) -> &Self`[src]

Creates a new &UriQualifiedName without validation.

Safety

The given string should be a valid UriQualifiedName.

Examples

let name = unsafe {
    UriQualifiedName::new_unchecked("Q{foo}bar")
};
assert_eq!(name, "Q{foo}bar");

`#[must_use]pub fn as_str(&self) -> &str`[src]

Returns the string as &str.

Examples

let name = UriQualifiedName::from_str("Q{foo}bar")?;
assert_eq!(name, "Q{foo}bar");

let s: &str = name.as_str();
assert_eq!(s, "Q{foo}bar");

`pub fn parse_next(s: &str) -> Result<(&Self, &str), NameError>`[src]

Parses the leading UriQualifiedName and returns the value and the rest input.

Exmaples

let input = "Q{foo}bar:012";
let expected = UriQualifiedName::from_str("Q{foo}bar")
    .expect("valid UriQualifiedName");
assert_eq!(
    UriQualifiedName::parse_next(input),
    Ok((expected, ":012"))
);

let input = "012";
assert!(UriQualifiedName::parse_next(input).is_err());

`#[must_use]pub fn uri(&self) -> &str`[src]

Returns the URI.

Note that this is O(length) operation. Consider using ParsedUriQualifiedName::uri method if possible.

Examples

let name = UriQualifiedName::from_str("Q{foo}bar")?;
assert_eq!(name.uri(), "foo");

let empty_uri = UriQualifiedName::from_str("Q{}foo")?;
assert_eq!(empty_uri.uri(), "");

`#[must_use]pub fn local_name(&self) -> &Ncname`[src]

Returns the local name.

Note that this is O(length) operation. Consider using ParsedUriQualifiedName::local_name method if possible.

Examples

let name = UriQualifiedName::from_str("Q{foo}bar")?;
assert_eq!(name.local_name(), "bar");

`#[must_use]pub fn uri_and_local(&self) -> (&str, &Ncname)`[src]

Returns a pair of the uri and the local name.

Note that this is O(length) operation. Consider using ParsedUriQualifiedName::uri_and_local method if possible.

Examples

use std::convert::TryFrom;

let name = UriQualifiedName::from_str("Q{foo}bar")?;
assert_eq!(name.uri_and_local(), (name.uri(), name.local_name()));

`pub fn into_boxed_str(self: Box<Self>) -> Box<str>`[src]

Converts a Box<UriQualifiedName> into a Box<str> without copying or allocating.

Examples

let name = UriQualifiedName::from_str("Q{foo}bar")?;
let boxed_name: Box<UriQualifiedName> = name.into();
assert_eq!(&*boxed_name, name);
let boxed_str: Box<str> = boxed_name.into_boxed_str();
assert_eq!(&*boxed_str, name.as_str());