Struct Attachment 

pub struct Attachment {
    pub name: String,
    pub content_type: Option<String>,
    /* private fields */
}

Represents a file/image/document sent or received as part of a message.

Examples

• An attachment sent by the user.
• An image generated by the AI.

Equality

When comparing, two Attachments are considered equal if they have the same metadata (name, content type, etc), and they point to the same data.

This means:

• For in-memory attachments, the content is compared by reference (pointer equality).
• For attachments picked from a native file system, the path is compared.
• For attachments picked on the web, the (wrapped) file handle must be the same.
• For persisted attachments, the storage key is compared (independent of the reader).

The content itself is never compared, because not all attachments can be read synchronously, and it would be expensive to do so.

Serialization

Unless a persistence key is configured, when serializing this type, the “pointer” to data is skipped and the attachment will become “unavailable” when deserialized back.

Two unavailable attachments are considered equal if they have the same metadata.

If a persistence key is configured, the attachment will be serialized with the key. That key will be restored when deserializing, however, you will need to manually restore its reader implementation.

Abstraction details

Different than other abstraction in [crate::protocol], this one not only acts as “data model”, but also as system and I/O interface. This coupling was originally intended to give “pragmatic” access to methods like read() and pick_multiple(), but as everything mixing concerns, this now causes some issues like making the persistence feature uglier to integrate. So this abstraction is likely to change in the future.

Fields

name: String

Normally the original filename.

content_type: Option<String>

Mime type of the content, if known.

Implementations

impl Attachment

pub fn pick_multiple(cb: impl FnOnce(Result<Vec<Attachment>, ()>) + 'static)

Pick files from the file system using a system dialog.

• On web, async API is required to pick files.
• On macos, sync API is required and must be called from the main UI thread.
  • This is the reason why it takes a closure instead of returning a Future. Because on native spawn may run in a separate thread. So we can’t generalize.
• We follow macos requirements on all native platforms just in case.

pub fn from_bytes( name: String, content_type: Option<String>, content: &[u8], ) -> Attachment

Creates a new in-memory attachment from the given bytes.

pub fn from_base64( name: String, content_type: Option<String>, base64_content: &str, ) -> Result<Attachment, Error>

Creates a new in-memory attachment from a base64 encoded string.

pub fn is_available(&self) -> bool

pub fn is_image(&self) -> bool

pub fn is_pdf(&self) -> bool

pub async fn read(&self) -> Result<Arc<[u8]>, Error>

pub async fn read_base64(&self) -> Result<String, Error>

pub fn save(&self)

Crate private utility to save/download the attachment to the file system.

• On web, this triggers a download.
• On native platforms, this opens a “Save As” dialog.

pub fn content_type_or_octet_stream(&self) -> &str

Get the content type or “application/octet-stream” if not set.

pub fn get_persistence_key(&self) -> Option<&str>

Get the persistence key if set.

pub fn has_persistence_key(&self) -> bool

Check if the attachment has a persistence key set, indicating it was persisted.

pub fn has_persistence_reader(&self) -> bool

Check if this attachment has a reader implementation set.

pub fn set_persistence_key(&mut self, key: String)

Give this attachment a custom persistence key.

This means you persisted this attachment somewhere and you will take care of how it’s read.

You should set this key only after you really persisted (wrote) the attachment.

If you call this, you should also call Self::set_persistence_reader to configure how this attachment will be read using this key.

pub fn set_persistence_reader( &mut self, reader: impl Fn(&str) -> Pin<Box<dyn PlatformSendFuture<Output = Result<Arc<[u8]>, Error>>>> + Send + Sync + 'static, )

Gives this attachment a custom implementation to read the persisted content.

Can only be used after setting a persistence key with Self::set_persistence_key.

Trait Implementations

impl Clone for Attachment

fn clone(&self) -> Attachment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Attachment

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

Formats the value using the given formatter.

impl Default for Attachment

fn default() -> Attachment

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Attachment

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Attachment

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Attachment

fn eq(&self, other: &Attachment) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Attachment

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.

impl Eq for Attachment

impl StructuralPartialEq for Attachment