Struct Draft 

pub struct Draft {
    pub timeline_event_type: TimelineEventType,
    pub content: Box<RawValue>,
    pub state_key: Option<String>,
    pub(crate) sender: OwnedUserId,
    pub(crate) redacts: Option<OwnedEventId>,
}

State representing a draft event containing only user intent.

A draft is the initial state of an event,

Fields

timeline_event_type: TimelineEventType

Matrix timeline event type.

content: Box<RawValue>

Raw JSON event content.

state_key: Option<String>

State key for state events (Some), or None for message-like events. State events may carry an empty-string state key (e.g. m.room.create).

sender: OwnedUserId

The user that sent the event

redacts: Option<OwnedEventId>

Redacted event id for redaction events

Implementations

impl Draft

pub fn new( event_type: TimelineEventType, content: Box<RawValue>, state_key: Option<String>, sender: OwnedUserId, redacts: Option<OwnedEventId>, ) -> Result<Self, Error>

Initializes a Draft from, validating content shape.

Errors

Returns a serde_json::Error if the content does not have the format expected of the event_type

“Re-fried deep fried beans!”

pub(crate) fn from_signed( event_type: TimelineEventType, content: Box<RawValue>, state_key: Option<String>, sender: OwnedUserId, redacts: Option<OwnedEventId>, ) -> Result<Self, Error>

Initializes a Draft from the content of a federation PDU, tolerating redacted content.

Unlike Draft::new, empty ({}) message-like content is accepted rather than rejected, since a redacted event may have had its content stripped to {}. This is only appropriate for already-signed events received over federation, never for client-originated content, which must go through Draft::new.

This constructor lives on Draft rather than on Signed because it runs while a PDU is being parsed into a Signed, before that value exists.

Errors

Returns a serde_json::Error if the content does not have the format expected of the event_type.

fn build( event_type: TimelineEventType, content: Box<RawValue>, state_key: Option<String>, sender: OwnedUserId, redacts: Option<OwnedEventId>, allow_redacted_content: bool, ) -> Result<Self, Error>

Shared constructor validating content shape.

When allow_redacted_content is set, empty ({}) message-like content is accepted instead of being validated, to allow loading redacted events.

pub fn redact(&mut self, redacted_content: Box<RawValue>) -> Result<(), Error>

Initialize a new Draft state, assuming it has been redacted.

This function assumes that the event content is correct event content, which has passed through the Draft::new, and subsequently the redaction module. Therefore, no explicit verification is made

Errors

Returns a serde_json::Error if, for a room-create event, the redacted content cannot be parsed as m.room.create content.

pub(crate) fn content_to_map(&self) -> Map<String, Value>

Get the event content as a JSON object map.

Panics

Panics if the content is not a valid JSON object. crate::states::Draft::new guarantees that the content is valid, so this is only reachable for events constructed bypassing that constructor.

Trait Implementations

impl Clone for Draft

fn clone(&self) -> Draft

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Draft

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Draft

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Draft

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.