Struct logins::LoginStore

pub struct LoginStore<'a> {
    pub db: &'a LoginDb,
    pub scope: SqlInterruptScope,
}

Fields

db: &'a LoginDb

scope: SqlInterruptScope

Implementations

impl<'a> LoginStore<'a>

pub fn new(db: &'a LoginDb) -> Self

Trait Implementations

impl<'a> Store for LoginStore<'a>

fn collection_name(&self) -> Cow<'static, str>

fn apply_incoming(
    &self,
    inbound: Vec<IncomingChangeset>,
    telem: &mut Engine
) -> Result<OutgoingChangeset>

inbound is a vector to support the case where get_collection_requests returned multiple requests. The changesets are in the same order as the requests were -- e.g. if vec![req_a, req_b] was returned from get_collection_requests, inbound will have the results from req_a as its first index, and those from req_b as it's second.

fn sync_finished(
    &self,
    new_timestamp: ServerTimestamp,
    records_synced: Vec<Guid>
) -> Result<()>

fn get_collection_requests(
    &self,
    server_timestamp: ServerTimestamp
) -> Result<Vec<CollectionRequest>>

The store is responsible for building the collection request. Engines typically will store a lastModified timestamp and use that to build a request saying "give me full records since that date" - however, other engines might do something fancier. This could even later be extended to handle "backfills" etc

fn get_sync_assoc(&self) -> Result<StoreSyncAssociation>

Get persisted sync IDs. If they don't match the global state we'll be reset() with the new IDs.

fn reset(&self, assoc: &StoreSyncAssociation) -> Result<()>

Reset the store without wiping local data, ready for a "first sync". assoc defines how this store is to be associated with sync.

fn wipe(&self) -> Result<()>

fn prepare_for_sync(&self, _get_client_data: &dyn Fn()) -> Result<(), Error>

Prepares the store for syncing. The tabs store currently uses this to store the current list of clients, which it uses to look up device names and types.