Struct matrix_sdk_sql::StateStore

pub struct StateStore<DB: SupportedDatabase> { /* private fields */ }

SQL State Storage for matrix-sdk

Implementations

impl<DB: SupportedDatabase> StateStore<DB>

pub async fn new(db: &Arc<Pool<DB>>) -> Result<Self> where
    <DB as Database>::Connection: Migrate, 

Create a new State Store and automtaically performs migrations

Errors

This function will return an error if the migration cannot be applied

pub async fn unlock(&mut self) -> Result<()> where
    for<'a> <DB as HasArguments<'a>>::Arguments: IntoArguments<'a, DB>,
    for<'c> &'c mut <DB as Database>::Connection: Executor<'c, Database = DB>,
    for<'c, 'a> &'a mut Transaction<'c, DB>: Executor<'a, Database = DB>,
    for<'a> &'a [u8]: BorrowedSqlType<'a, DB>,
    for<'a> &'a str: BorrowedSqlType<'a, DB>,
    Vec<u8>: SqlType<DB>,
    String: SqlType<DB>,
    bool: SqlType<DB>,
    Vec<u8>: SqlType<DB>,
    Option<String>: SqlType<DB>,
    Json<Raw<AnyGlobalAccountDataEvent>>: SqlType<DB>,
    Json<Raw<PresenceEvent>>: SqlType<DB>,
    Json<SyncRoomMemberEvent>: SqlType<DB>,
    Json<MinimalRoomMemberEvent>: SqlType<DB>,
    Json<Raw<AnySyncStateEvent>>: SqlType<DB>,
    Json<Raw<AnyRoomAccountDataEvent>>: SqlType<DB>,
    Json<RoomInfo>: SqlType<DB>,
    Json<Receipt>: SqlType<DB>,
    Json<Raw<AnyStrippedStateEvent>>: SqlType<DB>,
    Json<StrippedRoomMemberEvent>: SqlType<DB>,
    Json<MemberEvent>: SqlType<DB>,
    for<'a> &'a str: ColumnIndex<<DB as Database>::Row>, 

Unlocks the e2e encryption database

Errors

This function will fail if the database could not be unlocked

pub async fn unlock_with_passphrase(&mut self, passphrase: &str) -> Result<()> where
    for<'a> <DB as HasArguments<'a>>::Arguments: IntoArguments<'a, DB>,
    for<'c> &'c mut <DB as Database>::Connection: Executor<'c, Database = DB>,
    for<'c, 'a> &'a mut Transaction<'c, DB>: Executor<'a, Database = DB>,
    for<'a> &'a [u8]: BorrowedSqlType<'a, DB>,
    for<'a> &'a str: BorrowedSqlType<'a, DB>,
    Vec<u8>: SqlType<DB>,
    String: SqlType<DB>,
    bool: SqlType<DB>,
    Vec<u8>: SqlType<DB>,
    Option<String>: SqlType<DB>,
    Json<Raw<AnyGlobalAccountDataEvent>>: SqlType<DB>,
    Json<Raw<PresenceEvent>>: SqlType<DB>,
    Json<SyncRoomMemberEvent>: SqlType<DB>,
    Json<MinimalRoomMemberEvent>: SqlType<DB>,
    Json<Raw<AnySyncStateEvent>>: SqlType<DB>,
    Json<Raw<AnyRoomAccountDataEvent>>: SqlType<DB>,
    Json<RoomInfo>: SqlType<DB>,
    Json<Receipt>: SqlType<DB>,
    Json<Raw<AnyStrippedStateEvent>>: SqlType<DB>,
    Json<StrippedRoomMemberEvent>: SqlType<DB>,
    Json<MemberEvent>: SqlType<DB>,
    for<'a> &'a str: ColumnIndex<<DB as Database>::Row>, 

Unlocks the e2e encryption database with password

Errors

This function will fail if the passphrase is wrong

Trait Implementations

impl<DB: SupportedDatabase> CryptoStore for StateStore<DB> where
    for<'a> <DB as HasArguments<'a>>::Arguments: IntoArguments<'a, DB>,
    for<'c> &'c mut <DB as Database>::Connection: Executor<'c, Database = DB>,
    for<'c, 'a> &'a mut Transaction<'c, DB>: Executor<'a, Database = DB>,
    for<'a> &'a [u8]: BorrowedSqlType<'a, DB>,
    for<'a> &'a str: BorrowedSqlType<'a, DB>,
    Vec<u8>: SqlType<DB>,
    String: SqlType<DB>,
    bool: SqlType<DB>,
    Vec<u8>: SqlType<DB>,
    Option<String>: SqlType<DB>,
    Json<Raw<AnyGlobalAccountDataEvent>>: SqlType<DB>,
    Json<Raw<PresenceEvent>>: SqlType<DB>,
    Json<SyncRoomMemberEvent>: SqlType<DB>,
    Json<MinimalRoomMemberEvent>: SqlType<DB>,
    Json<Raw<AnySyncStateEvent>>: SqlType<DB>,
    Json<Raw<AnyRoomAccountDataEvent>>: SqlType<DB>,
    Json<RoomInfo>: SqlType<DB>,
    Json<Receipt>: SqlType<DB>,
    Json<Raw<AnyStrippedStateEvent>>: SqlType<DB>,
    Json<StrippedRoomMemberEvent>: SqlType<DB>,
    Json<MemberEvent>: SqlType<DB>,
    for<'a> &'a str: ColumnIndex<<DB as Database>::Row>, 

fn load_account<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Option<ReadOnlyAccount>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Load an account that was previously stored.

fn save_account<'life0, 'async_trait>(
    &'life0 self,
    account: ReadOnlyAccount
) -> Pin<Box<dyn Future<Output = Result<(), CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Save the given account in the store.

fn load_identity<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Option<PrivateCrossSigningIdentity>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Try to load a private cross signing identity, if one is stored.

fn save_changes<'life0, 'async_trait>(
    &'life0 self,
    changes: Changes
) -> Pin<Box<dyn Future<Output = Result<(), CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Save the set of changes to the store.

fn get_sessions<'life0, 'life1, 'async_trait>(
    &'life0 self,
    sender_key: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Option<Arc<Mutex<Vec<Session>>>>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get all the sessions that belong to the given sender key.

fn get_inbound_group_session<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId,
    sender_key: &'life2 str,
    session_id: &'life3 str
) -> Pin<Box<dyn Future<Output = Result<Option<InboundGroupSession>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: 'async_trait, 

Get the inbound group session from our store.

fn get_inbound_group_sessions<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get all the inbound group sessions we have stored.

fn inbound_group_session_counts<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<RoomKeyCounts, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get the number inbound group sessions we have and how many of them are backed up.

fn inbound_group_sessions_for_backup<'life0, 'async_trait>(
    &'life0 self,
    limit: usize
) -> Pin<Box<dyn Future<Output = Result<Vec<InboundGroupSession>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get all the inbound group sessions we have not backed up yet.

fn reset_backup_state<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<(), CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Reset the backup state of all the stored inbound group sessions.

fn load_backup_keys<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<BackupKeys, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get the backup keys we have stored.

fn get_outbound_group_sessions<'life0, 'life1, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId
) -> Pin<Box<dyn Future<Output = Result<Option<OutboundGroupSession>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get the outbound group sessions we have stored that is used for the given room.

fn is_user_tracked(&self, user_id: &UserId) -> bool

Is the given user already tracked.

fn has_users_for_key_query(&self) -> bool

Are there any tracked users that are marked as dirty.

fn users_for_key_query(&self) -> HashSet<OwnedUserId>

Set of users that we need to query keys for. This is a subset of the tracked users.

fn tracked_users(&self) -> HashSet<OwnedUserId>

Get all tracked users we know about.

fn update_tracked_user<'life0, 'life1, 'async_trait>(
    &'life0 self,
    user: &'life1 UserId,
    dirty: bool
) -> Pin<Box<dyn Future<Output = Result<bool, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Add an user for tracking.

fn get_device<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    user_id: &'life1 UserId,
    device_id: &'life2 DeviceId
) -> Pin<Box<dyn Future<Output = Result<Option<ReadOnlyDevice>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Get the device for the given user with the given device ID.

fn get_user_devices<'life0, 'life1, 'async_trait>(
    &'life0 self,
    user_id: &'life1 UserId
) -> Pin<Box<dyn Future<Output = Result<HashMap<OwnedDeviceId, ReadOnlyDevice>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get all the devices of the given user.

fn get_user_identity<'life0, 'life1, 'async_trait>(
    &'life0 self,
    user_id: &'life1 UserId
) -> Pin<Box<dyn Future<Output = Result<Option<ReadOnlyUserIdentities>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get the user identity that is attached to the given user id.

fn is_message_known<'life0, 'life1, 'async_trait>(
    &'life0 self,
    message_hash: &'life1 OlmMessageHash
) -> Pin<Box<dyn Future<Output = Result<bool, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Check if a hash for an Olm message stored in the database.

fn get_outgoing_secret_requests<'life0, 'life1, 'async_trait>(
    &'life0 self,
    request_id: &'life1 TransactionId
) -> Pin<Box<dyn Future<Output = Result<Option<GossipRequest>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get an outgoing secret request that we created that matches the given request id.

fn get_secret_request_by_info<'life0, 'life1, 'async_trait>(
    &'life0 self,
    secret_info: &'life1 SecretInfo
) -> Pin<Box<dyn Future<Output = Result<Option<GossipRequest>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get an outgoing key request that we created that matches the given requested key info.

fn get_unsent_secret_requests<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<GossipRequest>, CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get all outgoing secret requests that we have in the store.

fn delete_outgoing_secret_requests<'life0, 'life1, 'async_trait>(
    &'life0 self,
    request_id: &'life1 TransactionId
) -> Pin<Box<dyn Future<Output = Result<(), CryptoStoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Delete an outgoing key request that we created that matches the given request id.

impl<DB: Debug + SupportedDatabase> Debug for StateStore<DB>

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

Formats the value using the given formatter.

impl<DB: SupportedDatabase> StateStore for StateStore<DB> where
    for<'a> <DB as HasArguments<'a>>::Arguments: IntoArguments<'a, DB>,
    for<'c> &'c mut <DB as Database>::Connection: Executor<'c, Database = DB>,
    for<'a, 'c> &'c mut Transaction<'a, DB>: Executor<'c, Database = DB>,
    for<'a> &'a [u8]: BorrowedSqlType<'a, DB>,
    for<'a> &'a str: BorrowedSqlType<'a, DB>,
    Vec<u8>: SqlType<DB>,
    Option<String>: SqlType<DB>,
    String: SqlType<DB>,
    Json<Raw<AnyGlobalAccountDataEvent>>: SqlType<DB>,
    Json<Raw<PresenceEvent>>: SqlType<DB>,
    Json<SyncRoomMemberEvent>: SqlType<DB>,
    Json<MinimalRoomMemberEvent>: SqlType<DB>,
    bool: SqlType<DB>,
    Json<Raw<AnySyncStateEvent>>: SqlType<DB>,
    Json<Raw<AnyRoomAccountDataEvent>>: SqlType<DB>,
    Json<RoomInfo>: SqlType<DB>,
    Json<Receipt>: SqlType<DB>,
    Json<Raw<AnyStrippedStateEvent>>: SqlType<DB>,
    Json<StrippedRoomMemberEvent>: SqlType<DB>,
    Json<MemberEvent>: SqlType<DB>,
    for<'a> &'a str: ColumnIndex<<DB as Database>::Row>, 

fn save_filter<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    filter_name: &'life1 str,
    filter_id: &'life2 str
) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Save the given filter id under the given name.

Arguments

• filter_name - The name that should be used to store the filter id.

• filter_id - The filter id that should be stored in the state store.

fn save_changes<'life0, 'life1, 'async_trait>(
    &'life0 self,
    changes: &'life1 StateChanges
) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Save the set of state changes in the store.

fn get_filter<'life0, 'life1, 'async_trait>(
    &'life0 self,
    filter_name: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Option<String>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get the filter id that was stored under the given filter name.

Arguments

• filter_name - The name that was used to store the filter id.

fn get_sync_token<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Option<String>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get the last stored sync token.

fn get_presence_event<'life0, 'life1, 'async_trait>(
    &'life0 self,
    user_id: &'life1 UserId
) -> Pin<Box<dyn Future<Output = Result<Option<Raw<PresenceEvent>>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get the stored presence event for the given user.

Arguments

• user_id - The id of the user for which we wish to fetch the presence event for.

fn get_state_event<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId,
    event_type: StateEventType,
    state_key: &'life2 str
) -> Pin<Box<dyn Future<Output = Result<Option<Raw<AnySyncStateEvent>>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Get a state event out of the state store.

Arguments

• room_id - The id of the room the state event was received for.

• event_type - The event type of the state event.

fn get_state_events<'life0, 'life1, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId,
    event_type: StateEventType
) -> Pin<Box<dyn Future<Output = Result<Vec<Raw<AnySyncStateEvent>>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get a list of state events for a given room and StateEventType.

Arguments

• room_id - The id of the room to find events for.

• event_type - The event type.

fn get_profile<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId,
    user_id: &'life2 UserId
) -> Pin<Box<dyn Future<Output = Result<Option<MinimalRoomMemberEvent>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Get the current profile for the given user in the given room.

Arguments

• room_id - The room id the profile is used in.

• user_id - The id of the user the profile belongs to.

fn get_member_event<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId,
    state_key: &'life2 UserId
) -> Pin<Box<dyn Future<Output = Result<Option<MemberEvent>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Get the MemberEvent for the given state key in the given room id.

Arguments

• room_id - The room id the member event belongs to.

• state_key - The user id that the member event defines the state for.

fn get_user_ids<'life0, 'life1, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId
) -> Pin<Box<dyn Future<Output = Result<Vec<OwnedUserId>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get all the user ids of members for a given room, for stripped and regular rooms alike.

fn get_invited_user_ids<'life0, 'life1, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId
) -> Pin<Box<dyn Future<Output = Result<Vec<OwnedUserId>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get all the user ids of members that are in the invited state for a given room, for stripped and regular rooms alike.

fn get_joined_user_ids<'life0, 'life1, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId
) -> Pin<Box<dyn Future<Output = Result<Vec<OwnedUserId>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get all the user ids of members that are in the joined state for a given room, for stripped and regular rooms alike.

fn get_room_infos<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<RoomInfo>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get all the pure RoomInfos the store knows about.

fn get_stripped_room_infos<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<RoomInfo>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get all the pure RoomInfos the store knows about.

fn get_users_with_display_name<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId,
    display_name: &'life2 str
) -> Pin<Box<dyn Future<Output = Result<BTreeSet<OwnedUserId>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Get all the users that use the given display name in the given room.

Arguments

• room_id - The id of the room for which the display name users should be fetched for.

• display_name - The display name that the users use.

fn get_account_data_event<'life0, 'async_trait>(
    &'life0 self,
    event_type: GlobalAccountDataEventType
) -> Pin<Box<dyn Future<Output = Result<Option<Raw<AnyGlobalAccountDataEvent>>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get an event out of the account data store.

Arguments

• event_type - The event type of the account data event.

fn get_room_account_data_event<'life0, 'life1, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId,
    event_type: RoomAccountDataEventType
) -> Pin<Box<dyn Future<Output = Result<Option<Raw<AnyRoomAccountDataEvent>>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get an event out of the room account data store.

Arguments

• room_id - The id of the room for which the room account data event should be fetched.

• event_type - The event type of the room account data event.

fn get_user_room_receipt_event<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId,
    receipt_type: ReceiptType,
    user_id: &'life2 UserId
) -> Pin<Box<dyn Future<Output = Result<Option<(OwnedEventId, Receipt)>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Get an event out of the user room receipt store.

Arguments

• room_id - The id of the room for which the receipt should be fetched.

• receipt_type - The type of the receipt.

• user_id - The id of the user for who the receipt should be fetched.

fn get_event_room_receipt_events<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId,
    receipt_type: ReceiptType,
    event_id: &'life2 EventId
) -> Pin<Box<dyn Future<Output = Result<Vec<(OwnedUserId, Receipt)>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Get events out of the event room receipt store.

Arguments

• room_id - The id of the room for which the receipts should be fetched.

• receipt_type - The type of the receipts.

• event_id - The id of the event for which the receipts should be fetched.

fn get_custom_value<'life0, 'life1, 'async_trait>(
    &'life0 self,
    key: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get arbitrary data from the custom store

Arguments

• key - The key to fetch data for

fn set_custom_value<'life0, 'life1, 'async_trait>(
    &'life0 self,
    key: &'life1 [u8],
    value: Vec<u8>
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Put arbitrary data into the custom store

Arguments

• key - The key to insert data into

• value - The value to insert

fn add_media_content<'life0, 'life1, 'async_trait>(
    &'life0 self,
    request: &'life1 MediaRequest,
    content: Vec<u8>
) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Add a media file’s content in the media store.

Arguments

• request - The MediaRequest of the file.

• content - The content of the file.

fn get_media_content<'life0, 'life1, 'async_trait>(
    &'life0 self,
    request: &'life1 MediaRequest
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get a media file’s content out of the media store.

Arguments

• request - The MediaRequest of the file.

fn remove_media_content<'life0, 'life1, 'async_trait>(
    &'life0 self,
    request: &'life1 MediaRequest
) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Removes a media file’s content from the media store.

Arguments

• request - The MediaRequest of the file.

fn remove_media_content_for_uri<'life0, 'life1, 'async_trait>(
    &'life0 self,
    uri: &'life1 MxcUri
) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Removes all the media files’ content associated to an MxcUri from the media store.

Arguments

• uri - The MxcUri of the media files.

fn remove_room<'life0, 'life1, 'async_trait>(
    &'life0 self,
    room_id: &'life1 RoomId
) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Removes a room and all elements associated from the state store.

Arguments

• room_id - The RoomId of the room to delete.