Struct ruma::events::RedactedUnsigned

#[non_exhaustive]
pub struct RedactedUnsigned {
    pub redacted_because: Option<Box<SyncRoomRedactionEvent, Global>>,
}

Extra information about a redacted event that is not incorporated into the event’s hash.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

redacted_because: Option<Box<SyncRoomRedactionEvent, Global>>

The event that redacted this event, if any.

Implementations

impl RedactedUnsigned

pub fn new() -> RedactedUnsigned

Create a new RedactedUnsigned with field set to None.

pub fn new_because(
    redacted_because: Box<SyncRoomRedactionEvent, Global>
) -> RedactedUnsigned

Create a new RedactedUnsigned with the given redacted because.

pub fn is_empty(&self) -> bool

Whether this unsigned data is empty (redacted_because is None).

This method is used to determine whether to skip serializing the unsigned field in redacted room events. Do not use it to determine whether an incoming unsigned field was present - it could still have been present but contained none of the known fields.

Trait Implementations

impl Clone for RedactedUnsigned

fn clone(&self) -> RedactedUnsigned

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RedactedUnsigned

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

Formats the value using the given formatter.

impl Default for RedactedUnsigned

fn default() -> RedactedUnsigned

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RedactedUnsigned

fn deserialize<__D>(
    __deserializer: __D
) -> Result<RedactedUnsigned, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for RedactedUnsigned

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.