Struct SendRawMessageLikeEvent 

pub struct SendRawMessageLikeEvent<'a> { /* private fields */ }

Future returned by Room::send_raw.

Implementations

impl<'a> SendRawMessageLikeEvent<'a>

pub fn with_sticky_duration(self, duration: Duration) -> Self

Available on crate feature unstable-msc4354 only.

Make this event sticky for duration, clamped to one hour.

Note that if the homeserver doesn’t support sticky events, it will ignore the duration and send the event unsticky. Server support can be checked with Client::supports_sticky_events.

pub fn with_transaction_id(self, txn_id: &TransactionId) -> Self

Set a transaction ID for this event.

Since sending message-like events always requires a transaction ID, one is generated if this method is not called.

• On the sending side, this field is used for re-trying earlier failed transactions. Subsequent messages must never re-use an earlier transaction ID.
• On the receiving side, the field is used for recognizing our own messages when they arrive down the sync: the server includes the ID in the [MessageLikeUnsigned] field transaction_id of the corresponding [SyncMessageLikeEvent], but only for the sending device. Other devices will not see it. This is then used to ignore events sent by our own device and/or to implement local echo.

pub fn with_request_config(self, request_config: RequestConfig) -> Self

Assign a given RequestConfig to configure how this request should behave with respect to the network.

pub fn into_delayed(self, delay: Duration) -> SendDelayedRawMessageLikeEvent<'a>

Send the event as a delayed event (MSC4140) instead of sending it right away.

The homeserver holds on to the event and only distributes it to the room once delay elapses. Until then the event can be cancelled, restarted or sent immediately with Client::update_delayed_event, using the delay_id from the response.

The event is prepared exactly like an immediate one: in particular it is encrypted if the room is encrypted. Note that this happens when the event is scheduled: the room key is shared with the members of the room at that point, so a member joining before the delay elapses won’t be able to decrypt the event, and restarting the delay does not re-encrypt it.

A sticky duration set beforehand with with_sticky_duration (MSC4354) is kept: the event becomes sticky once the homeserver sends it.

Trait Implementations

impl<'a> IntoFuture for SendRawMessageLikeEvent<'a>

type Output = Result<SendMessageLikeEventResult, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <SendRawMessageLikeEvent<'a> as IntoFuture>::Output> + Send + 'a>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.