Struct ruma::RoomId

pub struct RoomId(/* private fields */);

A Matrix room ID.

A RoomId is generated randomly or converted from a string slice, and can be converted back into a string as needed.

assert_eq!(<&RoomId>::try_from("!n8f893n9:example.com").unwrap(), "!n8f893n9:example.com");

Implementations

impl RoomId

pub fn as_str(&self) -> &str

Creates a string slice from this RoomId.

pub fn as_bytes(&self) -> &[u8]

Creates a byte slice from this RoomId.

impl RoomId

pub fn parse(s: impl AsRef<str>) -> Result<OwnedRoomId, Error>

Try parsing a &str into an OwnedRoomId.

The same can also be done using FromStr, TryFrom or TryInto. This function is simply more constrained and thus useful in generic contexts.

pub fn parse_box( s: impl AsRef<str> + Into<Box<str>>, ) -> Result<Box<RoomId>, Error>

Try parsing a &str into a Box<RoomId>.

The same can also be done using FromStr, TryFrom or TryInto. This function is simply more constrained and thus useful in generic contexts.

pub fn parse_rc(s: impl AsRef<str> + Into<Rc<str>>) -> Result<Rc<RoomId>, Error>

Try parsing a &str into an Rc<RoomId>.

pub fn parse_arc( s: impl AsRef<str> + Into<Arc<str>>, ) -> Result<Arc<RoomId>, Error>

Try parsing a &str into an Arc<RoomId>.

impl RoomId

pub fn new(server_name: &ServerName) -> OwnedRoomId

Attempts to generate a RoomId for the given origin server with a localpart consisting of 18 random ASCII characters.

Fails if the given homeserver cannot be parsed as a valid host.

pub fn server_name(&self) -> Option<&ServerName>

Returns the server name of the room ID.

pub fn matrix_to_uri(&self) -> MatrixToUri

Create a matrix.to URI for this room ID.

Note that it is recommended to provide servers that should know the room to be able to find it with its room ID. For that use RoomId::matrix_to_uri_via().

Example

use ruma_common::{room_id, server_name};

assert_eq!(
    room_id!("!somewhere:example.org").matrix_to_uri().to_string(),
    "https://matrix.to/#/!somewhere:example.org"
);

pub fn matrix_to_uri_via<T>(&self, via: T) -> MatrixToUri

where T: IntoIterator, <T as IntoIterator>::Item: Into<OwnedServerName>,

Create a matrix.to URI for this room ID with a list of servers that should know it.

To get the list of servers, it is recommended to use the routing algorithm from the spec.

If you don’t have a list of servers, you can use RoomId::matrix_to_uri() instead.

Example

use ruma_common::{room_id, server_name};

assert_eq!(
    room_id!("!somewhere:example.org")
        .matrix_to_uri_via([&*server_name!("example.org"), &*server_name!("alt.example.org")])
        .to_string(),
    "https://matrix.to/#/!somewhere:example.org?via=example.org&via=alt.example.org"
);

pub fn matrix_to_event_uri(&self, ev_id: impl Into<OwnedEventId>) -> MatrixToUri

Create a matrix.to URI for an event scoped under this room ID.

Note that it is recommended to provide servers that should know the room to be able to find it with its room ID. For that use RoomId::matrix_to_event_uri_via().

pub fn matrix_to_event_uri_via<T>( &self, ev_id: impl Into<OwnedEventId>, via: T, ) -> MatrixToUri

where T: IntoIterator, <T as IntoIterator>::Item: Into<OwnedServerName>,

Create a matrix.to URI for an event scoped under this room ID with a list of servers that should know it.

To get the list of servers, it is recommended to use the routing algorithm from the spec.

If you don’t have a list of servers, you can use RoomId::matrix_to_event_uri() instead.

pub fn matrix_uri(&self, join: bool) -> MatrixUri

Create a matrix: URI for this room ID.

If join is true, a click on the URI should join the room.

Note that it is recommended to provide servers that should know the room to be able to find it with its room ID. For that use RoomId::matrix_uri_via().

Example

use ruma_common::{room_id, server_name};

assert_eq!(
    room_id!("!somewhere:example.org").matrix_uri(false).to_string(),
    "matrix:roomid/somewhere:example.org"
);

pub fn matrix_uri_via<T>(&self, via: T, join: bool) -> MatrixUri

where T: IntoIterator, <T as IntoIterator>::Item: Into<OwnedServerName>,

Create a matrix: URI for this room ID with a list of servers that should know it.

To get the list of servers, it is recommended to use the routing algorithm from the spec.

If you don’t have a list of servers, you can use RoomId::matrix_uri() instead.

If join is true, a click on the URI should join the room.

Example

use ruma_common::{room_id, server_name};

assert_eq!(
    room_id!("!somewhere:example.org")
        .matrix_uri_via(
            [&*server_name!("example.org"), &*server_name!("alt.example.org")],
            true
        )
        .to_string(),
    "matrix:roomid/somewhere:example.org?via=example.org&via=alt.example.org&action=join"
);

pub fn matrix_event_uri(&self, ev_id: impl Into<OwnedEventId>) -> MatrixUri

Create a matrix: URI for an event scoped under this room ID.

Note that it is recommended to provide servers that should know the room to be able to find it with its room ID. For that use RoomId::matrix_event_uri_via().

pub fn matrix_event_uri_via<T>( &self, ev_id: impl Into<OwnedEventId>, via: T, ) -> MatrixUri

where T: IntoIterator, <T as IntoIterator>::Item: Into<OwnedServerName>,

Create a matrix: URI for an event scoped under this room ID with a list of servers that should know it.

To get the list of servers, it is recommended to use the routing algorithm from the spec.

If you don’t have a list of servers, you can use RoomId::matrix_event_uri() instead.

Trait Implementations

impl AsRef<[u8]> for RoomId

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<RoomId> for OwnedRoomId

fn as_ref(&self) -> &RoomId

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<RoomId> for RoomId

fn as_ref(&self) -> &RoomId

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<str> for RoomId

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<RoomId> for OwnedRoomId

fn borrow(&self) -> &RoomId

Immutably borrows from an owned value.

impl Clone for Box<RoomId>

fn clone(&self) -> Box<RoomId>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RoomId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Box<RoomId>

fn deserialize<D>( deserializer: D, ) -> Result<Box<RoomId>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for RoomId

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

Formats the value using the given formatter.

impl<'a> From<&'a RoomId> for &'a RoomOrAliasId

fn from(room_id: &'a RoomId) -> &'a RoomOrAliasId

Converts to this type from the input type.

impl From<&RoomId> for Arc<RoomId>

fn from(s: &RoomId) -> Arc<RoomId>

Converts to this type from the input type.

impl From<&RoomId> for Box<RoomId>

fn from(id: &RoomId) -> Box<RoomId>

Converts to this type from the input type.

impl From<&RoomId> for MatrixId

fn from(room_id: &RoomId) -> MatrixId

Converts to this type from the input type.

impl From<&RoomId> for OwnedRoomId

fn from(id: &RoomId) -> OwnedRoomId

Converts to this type from the input type.

impl From<&RoomId> for Rc<RoomId>

fn from(s: &RoomId) -> Rc<RoomId>

Converts to this type from the input type.

impl From<&RoomId> for String

fn from(id: &RoomId) -> String

Converts to this type from the input type.

impl From<OwnedRoomId> for Box<RoomId>

fn from(a: OwnedRoomId) -> Box<RoomId>

Converts to this type from the input type.

impl Hash for RoomId

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

where __H: Hasher,

Feeds this value into the given Hasher.

impl Ord for RoomId

fn cmp(&self, other: &RoomId) -> Ordering

This method returns an Ordering between self and other.

impl PartialEq<&RoomId> for OwnedRoomId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<&str> for RoomId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Box<RoomId>> for &RoomId

fn eq(&self, other: &Box<RoomId>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Box<RoomId>> for RoomId

fn eq(&self, other: &Box<RoomId>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<OwnedRoomId> for &RoomId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<OwnedRoomId> for RoomId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<RoomId> for &str

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<RoomId> for OwnedRoomId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<RoomId> for str

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<String> for RoomId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<str> for RoomId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for RoomId

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for RoomId

fn partial_cmp(&self, other: &RoomId) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for RoomId

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl ToOwned for RoomId

type Owned = OwnedRoomId

The resulting type after obtaining ownership.

fn to_owned(&self) -> <RoomId as ToOwned>::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

Uses borrowed data to replace owned data, usually by cloning.

impl<'a> TryFrom<&'a RoomOrAliasId> for &'a RoomId

type Error = &'a RoomAliasId

The type returned in the event of a conversion error.

fn try_from(id: &'a RoomOrAliasId) -> Result<&'a RoomId, &'a RoomAliasId>

Performs the conversion.

impl<'a> TryFrom<&'a str> for &'a RoomId

type Error = Error

The type returned in the event of a conversion error.

fn try_from( s: &'a str, ) -> Result<&'a RoomId, <&'a RoomId as TryFrom<&'a str>>::Error>

Performs the conversion.

impl TryFrom<&str> for Box<RoomId>

type Error = Error

The type returned in the event of a conversion error.

fn try_from( s: &str, ) -> Result<Box<RoomId>, <Box<RoomId> as TryFrom<&str>>::Error>

Performs the conversion.

impl TryFrom<String> for Box<RoomId>

type Error = Error

The type returned in the event of a conversion error.

fn try_from( s: String, ) -> Result<Box<RoomId>, <Box<RoomId> as TryFrom<String>>::Error>

Performs the conversion.

impl Eq for RoomId

impl StructuralPartialEq for RoomId