Struct Builder 

pub struct Builder<A: Application> { /* private fields */ }

Implementations

impl<A: Application> Builder<A>

pub fn register<C: Registration<A> + 'static>(self, catalog: C) -> Self

pub fn operation<T>( self, owner: impl Into<String>, lane: impl Lane, resources: Arc<T::Resources>, ) -> Self

where T: for<'ctx> Operation<Context<'ctx> = Context<'ctx>>,

pub fn operations<C, R>( self, owner: impl Into<String>, lane: impl Lane, resources: Arc<R>, ) -> Self

where C: Catalog<AuthoredDeclarations> + Catalog<Implementations<R>>, R: Send + Sync + 'static,

pub fn wire_operations<C, R>( self, owner: impl Into<String>, lane: impl Lane, resources: Arc<R>, ) -> Self

where C: Catalog<AuthoredDeclarations> + Catalog<WireImplementations<R>>, R: Send + Sync + 'static,

pub fn operation_middleware(self, middleware: Arc<dyn Middleware>) -> Self

pub fn operation_settings(self, settings: Settings) -> Self

pub fn service<R>(self, name: impl Into<String>, resident: R) -> Self

where R: Resident<A>,

pub fn service_with<R>( self, name: impl Into<String>, policy: OperationPolicy, resident: R, ) -> Self

where R: Resident<A>,

pub fn evidence( self, vault: impl Vault, kinds: impl IntoIterator<Item = (DefinitionId, u32)>, ) -> Self

pub fn attach(self, consumer: impl JournalConsumer<A>) -> Self

pub fn attach_streams(self, consumer: impl StreamConsumer<A>) -> Self

pub fn series(self, series: impl Series<A>) -> Self

pub fn recover(self, source: impl Source<A>) -> Self

pub fn snapshot(self, snapshot: impl JournalConsumer<A>) -> Self

pub fn require_capture( self, limits: CaptureLimits, consumer: impl JournalCapture<A>, ) -> Result<Self, CaptureError>

pub fn retain(self, horizon: Horizon) -> Self

pub fn tail(self, entries: usize) -> Self

pub fn runtime(self) -> Startup<A>

pub fn managed_storage(self, settings: ManagedStorageSettings) -> Self

where A::State: Serialize + DeserializeOwned,

pub fn store_records(self, projection: impl RecordProjection) -> Self

pub fn reconcile<F, Fut>(self, reconcile: F) -> Self

where F: FnOnce(StateManager<A>, StorageManager<ErasedCatalog>) -> Fut + Send + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

pub fn initialize<F, Fut, E>(self, timeout: Duration, initialize: F) -> Self

where F: Fn(Handle<A>) -> Fut + Clone + Send + Sync + 'static, Fut: Future<Output = Result<(), E>> + Send + 'static, E: Error + Send + Sync + 'static,

pub fn runtime_with_storage<C>(self, storage: &StorageManager<C>) -> Startup<A>