Struct email::sync::SyncBuilder

pub struct SyncBuilder<L: BackendContextBuilder + SyncHash, R: BackendContextBuilder + SyncHash> {
    left_builder: BackendBuilder<L>,
    left_hash: String,
    right_builder: BackendBuilder<R>,
    right_hash: String,
    cache_dir: Option<PathBuf>,
    pool_size: Option<usize>,
    handler: Option<Arc<SyncEventHandler>>,
    dry_run: Option<bool>,
    folder_filter: Option<FolderSyncStrategy>,
}

The synchronization builder.

Fields

left_builder: BackendBuilder<L>

left_hash: String

right_builder: BackendBuilder<R>

right_hash: String

cache_dir: Option<PathBuf>

pool_size: Option<usize>

handler: Option<Arc<SyncEventHandler>>

dry_run: Option<bool>

folder_filter: Option<FolderSyncStrategy>

Implementations

impl<L, R> SyncBuilder<L, R>

where L: BackendContextBuilder + SyncHash + 'static, R: BackendContextBuilder + SyncHash + 'static,

pub fn new( left_builder: BackendBuilder<L>, right_builder: BackendBuilder<R> ) -> Self

Create a new synchronization builder using the two given backend builders.

pub fn set_some_cache_dir(&mut self, dir: Option<impl Into<PathBuf>>)

pub fn set_cache_dir(&mut self, dir: impl Into<PathBuf>)

pub fn with_some_cache_dir(self, dir: Option<impl Into<PathBuf>>) -> Self

pub fn with_cache_dir(self, dir: impl Into<PathBuf>) -> Self

pub fn set_some_pool_size(&mut self, size: Option<usize>)

pub fn set_pool_size(&mut self, size: usize)

pub fn with_some_pool_size(self, size: Option<usize>) -> Self

pub fn with_pool_size(self, size: usize) -> Self

pub fn set_some_handler<F: Future<Output = Result<()>> + Send + 'static>( &mut self, handler: Option<impl Fn(SyncEvent) -> F + Send + Sync + 'static> )

pub fn set_handler<F: Future<Output = Result<()>> + Send + 'static>( &mut self, handler: impl Fn(SyncEvent) -> F + Send + Sync + 'static )

pub fn with_some_handler<F: Future<Output = Result<()>> + Send + 'static>( self, handler: Option<impl Fn(SyncEvent) -> F + Send + Sync + 'static> ) -> Self

pub fn with_handler<F: Future<Output = Result<()>> + Send + 'static>( self, handler: impl Fn(SyncEvent) -> F + Send + Sync + 'static ) -> Self

pub fn set_some_dry_run(&mut self, dry_run: Option<bool>)

pub fn set_dry_run(&mut self, dry_run: bool)

pub fn with_some_dry_run(self, dry_run: Option<bool>) -> Self

pub fn with_dry_run(self, dry_run: bool) -> Self

pub fn get_dry_run(&self) -> bool

pub fn set_some_folders_filter( &mut self, filter: Option<impl Into<FolderSyncStrategy>> )

pub fn set_folders_filter(&mut self, folders: impl Into<FolderSyncStrategy>)

pub fn with_some_folders_filter( self, folders: Option<impl Into<FolderSyncStrategy>> ) -> Self

pub fn with_folders_filter(self, folders: impl Into<FolderSyncStrategy>) -> Self

pub fn find_default_cache_dir(&self) -> Option<PathBuf>

pub fn find_cache_dir(&self) -> Option<PathBuf>

pub fn get_cache_dir(&self) -> Result<PathBuf>

pub fn get_left_cache_builder( &self ) -> Result<BackendBuilder<MaildirContextBuilder>>

pub fn get_right_cache_builder( &self ) -> Result<BackendBuilder<MaildirContextBuilder>>

pub async fn sync(self) -> Result<SyncReport>

Trait Implementations

impl<L: Clone + BackendContextBuilder + SyncHash, R: Clone + BackendContextBuilder + SyncHash> Clone for SyncBuilder<L, R>

fn clone(&self) -> SyncBuilder<L, R>

Returns a copy of the value.

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

Performs copy-assignment from source.