Enum matrix_sdk_base::ruma::events::room::encrypted::Relation

#[non_exhaustive]
pub enum Relation {
    Reply {
        in_reply_to: InReplyTo,
    },
    Replacement(Replacement),
    Reference(Reference),
    Annotation(Annotation),
    Thread(Thread),
}

Relationship information about an encrypted event.

Outside of the encrypted payload to support server aggregation.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Reply

Fields

in_reply_to: InReplyTo

Information about another message being replied to.

An m.in_reply_to relation indicating that the event is a reply to another event.

Replacement(Replacement)

An event that replaces another event.

Reference(Reference)

A reference to another event.

Annotation(Annotation)

An annotation to an event.

Thread(Thread)

An event that belongs to a thread.

Implementations

impl Relation

pub fn rel_type(&self) -> Option<RelationType>

The type of this Relation.

Returns an Option because the Reply relation does not have arel_type field.

pub fn event_id(&self) -> &EventId

👎Deprecated: Please open an issue if you use this

The ID of the event this relates to.

This is the event_id field at the root of an m.relates_to object, except in the case of a reply relation where it’s the event_id field in the m.in_reply_to object.

pub fn data(&self) -> Cow<'_, Map<String, Value>>

The associated data.

The returned JSON object won’t contain the rel_type field, use .rel_type() to access it. It also won’t contain data outside of m.relates_to (e.g. m.new_content for m.replace relations).

Prefer to use the public variants of Relation where possible; this method is meant to be used for custom relations only.

Trait Implementations

impl Clone for Relation

fn clone(&self) -> Relation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Relation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Relation

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> From<Relation<C>> for Relation

fn from(rel: Relation<C>) -> Relation

Converts to this type from the input type.

impl Serialize for Relation

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.