Struct SyncV4Handler 

pub struct SyncV4Handler<T: TransactedSyncV4Queries, S> {
    transaction: T,
    stage: S,
}

This is the state machine handling sync v4 requests.

It contains a database transaction to be used throughout the whole request handling, as well as the per-stage data.

Fields

transaction: T

The database transaction to be used throughout the whole request handling.

stage: S

The data associated to the stage the handler is currently in.

Implementations

impl<'a> SyncV4Handler<TransactedDb<'a>, ResolvedConnection>

pub async fn connect( database: &'a mut DefaultDb, key: ConnectionKey, pos: Option<String>, ) -> Result<SyncV4Handler<TransactedDb<'a>, ResolvedConnection>, SyncV4Error>

Connects a SyncV4Handler to the database (by starting a transaction) and to the user’s connection.

This is the start of handling a sync v4 request.

impl<T: TransactedSyncV4Queries> SyncV4Handler<T, ResolvedConnection>

pub async fn gather(self) -> Result<SyncV4Handler<T, SyncV4Inputs>, SyncV4Error>

Gather everything we’ll need to handle the current request.

This is the second step of handling a sync v4 request.

impl<T: TransactedSyncV4Queries> SyncV4Handler<T, SyncV4Inputs>

pub fn plan( self, request: &Request, ) -> Result<SyncV4Handler<T, SyncV4Plan>, SyncV4Error>

Plan the current sync v4 request handling.

This is the core of sync v4 where we compute which data will be part of the current sync (if any) by applying the request to the user’s rooms, as well as the per-connection state.

This is the third step of handling a sync v4 request, in which all the core logic occurs.

impl<T: TransactedSyncV4Queries> SyncV4Handler<T, SyncV4Plan>

pub fn has_data_to_sync(&self) -> bool

Tells whether the computed plan actually contains data to sync or not.

impl SyncV4Handler<TransactedDb<'_>, SyncV4Plan>

pub(crate) async fn execute(self) -> Result<Persisted, SyncV4Error>

Execute the computed plan::SyncV4Plan.

This will compute the actual content of the sync response, as well as create a new position in the per-connection state which will store what the current request produced.

NOTE: This is to be ran when plan::SyncV4Plan::has_data_to_sync returns true.

This is the final step of handling a sync v4 request.

pub(crate) async fn persist_without_position( self, ) -> Result<Persisted, SyncV4Error>

Execute the computed plan::SyncV4Plan to produce an empty response.

This will simply update the previous position’s state if needs be.

NOTE: This is to be ran when plan::SyncV4Plan::has_data_to_sync returns false.

This is the final step of handling a sync v4 request.

Trait Implementations

impl<T: Debug + TransactedSyncV4Queries, S: Debug> Debug for SyncV4Handler<T, S>

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

Formats the value using the given formatter.