Enum QueuedRequestKind 

pub enum QueuedRequestKind {
    Event {
        content: SerializableEventContent,
    },
    MediaUpload {
        content_type: String,
        cache_key: MediaRequestParameters,
        thumbnail_source: Option<MediaSource>,
        related_to: OwnedTransactionId,
        accumulated: Vec<AccumulatedSentMediaInfo>,
    },
    Redaction {
        redacts: OwnedEventId,
        reason: Option<String>,
    },
}

The kind of a send queue request.

Variants

Event

An event to be sent via the send queue.

Fields

content: SerializableEventContent

The content of the message-like event we’d like to send.

MediaUpload

Content to upload on the media server.

The bytes must be stored in the media cache, and are identified by the cache key.

Fields

content_type: String

Content type of the media to be uploaded.

Stored as a String because Mime which we’d really want to use here, is not serializable. Oh well.

cache_key: MediaRequestParameters

The cache key used to retrieve the media’s bytes in the event cache store.

thumbnail_source: Option<MediaSource>

An optional media source for a thumbnail already uploaded.

related_to: OwnedTransactionId

To which media event transaction does this upload relate?

accumulated: Vec<AccumulatedSentMediaInfo>

Available on crate feature unstable-msc4274 only.

Accumulated list of infos for previously uploaded files and thumbnails if used during a gallery transaction. Otherwise empty.

Redaction

A redaction of another event to send.

Fields

redacts: OwnedEventId

The ID of the event to redact.

reason: Option<String>

The reason for the event being redacted.

Trait Implementations

impl Clone for QueuedRequestKind

fn clone(&self) -> QueuedRequestKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueuedRequestKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for QueuedRequestKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<SerializableEventContent> for QueuedRequestKind

fn from(content: SerializableEventContent) -> QueuedRequestKind

Converts to this type from the input type.

impl Serialize for QueuedRequestKind

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.