Struct xmpp::BareJid

pub struct BareJid { /* private fields */ }

Expand description

A struct representing a bare Jabber ID, without a resource part.

A bare JID is composed of 2 components, of which only the node is optional:

the (optional) node part is the part before the (optional) @.
the domain part is the mandatory part between the (optional) @ and before the /.

Unlike a FullJid, it can’t contain a resource, and should only be used when you are certain there is no case where a resource can be set. Otherwise, use a Jid or FullJid.

Implementations§

§

impl BareJid

pub fn new(unnormalized: &str) -> Result<BareJid, Error>

Constructs a bare Jabber ID, containing two components. This is of the form node@domain, where node part is optional. If you want a non-fallible version, use BareJid::from_parts instead.

§Examples

use jid::BareJid;

let jid = BareJid::new("node@domain")?;

assert_eq!(jid.node().map(|x| x.as_str()), Some("node"));
assert_eq!(jid.domain().as_str(), "domain");

pub fn from_parts(node: Option<&NodeRef>, domain: &DomainRef) -> BareJid

Build a BareJid from typed parts. This method cannot fail because it uses parts that have already been parsed and stringprepped into [NodePart] and [DomainPart].

This method allocates and does not consume the typed parts. To avoid allocation if node is known to be None and domain is owned, you can use domain.into().

pub fn with_resource(&self, resource: &ResourceRef) -> FullJid

Constructs a BareJid from the bare JID, by specifying a [ResourcePart]. If you’d like to specify a stringy resource, use BareJid::with_resource_str instead.

§Examples

use jid::{BareJid, ResourcePart};

let resource = ResourcePart::new("resource").unwrap();
let bare = BareJid::new("node@domain").unwrap();
let full = bare.with_resource(&resource);

assert_eq!(full.node().map(|x| x.as_str()), Some("node"));
assert_eq!(full.domain().as_str(), "domain");
assert_eq!(full.resource().as_str(), "resource");

pub fn with_resource_str(&self, resource: &str) -> Result<FullJid, Error>

Constructs a FullJid from the bare JID, by specifying a stringy resource. If your resource has already been parsed into a [ResourcePart], use BareJid::with_resource.

§Examples

use jid::BareJid;

let bare = BareJid::new("node@domain").unwrap();
let full = bare.with_resource_str("resource").unwrap();

assert_eq!(full.node().map(|x| x.as_str()), Some("node"));
assert_eq!(full.domain().as_str(), "domain");
assert_eq!(full.resource().as_str(), "resource");

pub fn into_inner(self) -> String

Return the inner String of this bare JID.

Methods from Deref<Target = Jid>§

pub fn node(&self) -> Option<&NodeRef>

The optional node part of the JID as reference.

pub fn domain(&self) -> &DomainRef

The domain part of the JID as reference

pub fn resource(&self) -> Option<&ResourceRef>

The optional resource of the Jabber ID. It is guaranteed to be present when the JID is a Full variant, which you can check with Jid::is_full.

pub fn to_bare(&self) -> BareJid

Allocate a new BareJid from this JID, discarding the resource.

pub fn is_full(&self) -> bool

Checks if the JID is a full JID.

pub fn is_bare(&self) -> bool

Checks if the JID is a bare JID.

pub fn as_str(&self) -> &str

Return a reference to the canonical string representation of the JID.

pub fn try_as_full(&self) -> Result<&FullJid, &BareJid>

Try to convert this Jid reference to a &FullJid if it contains a resource and return a &BareJid otherwise.

This is useful for match blocks:

let jid: Jid = "foo@bar".parse().unwrap();
match jid.try_as_full() {
    Ok(full) => println!("it is full: {:?}", full),
    Err(bare) => println!("it is bare: {:?}", bare),
}