Struct Verifier

pub struct Verifier {
    batch: Verifier,
    tx: Sender<Option<Result<(), Error>>>,
}

Ed25519 signature verifier service

Fields

batch: Verifier

A batch verifier for ed25519 signatures.

tx: Sender<Option<Result<(), Error>>>

A channel for broadcasting the result of a batch to the futures for each batch item.

Each batch gets a newly created channel, so there is only ever one result sent per channel. Tokio doesn’t have a oneshot multi-consumer channel, so we use a watch channel.

Implementations

impl Verifier

fn take(&mut self) -> (Verifier, Sender<Option<Result<(), Error>>>)

Returns the batch verifier and channel sender from self, replacing them with a new empty batch.

fn verify(batch: Verifier, tx: Sender<Option<Result<(), Error>>>)

Synchronously process the batch, and send the result using the channel sender. This function blocks until the batch is completed.

fn flush_blocking(&mut self)

Flush the batch using a thread pool, and return the result via the channel. This returns immediately, usually before the batch is completed.

async fn flush_spawning(batch: Verifier, tx: Sender<Option<Result<(), Error>>>)

Flush the batch using a thread pool, and return the result via the channel. This function returns a future that becomes ready when the batch is completed.

async fn verify_single_spawning(item: Item) -> Result<(), BoxError>

Verify a single item using a thread pool, and return the result.

Trait Implementations

impl Default for Verifier

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Verifier

fn drop(&mut self)

Executes the destructor for this type.

impl Service<BatchControl<Item>> for Verifier

type Response = ()

Responses given by the service.

type Error = Box<dyn Error + Sync + Send>

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<(), Box<dyn Error + Sync + Send>>> + Send>>

The future response value.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: BatchControl<Item>) -> Self::Future

Process the request and return the response asynchronously.