Struct ProviderSession 

pub struct ProviderSession<P> { /* private fields */ }

One explicitly selected backend session with stable nonzero-sized ownership.

This owns the adapter, not a global registry or cryptographic engine. A borrowed adapter may itself hold the caller’s existing engine/policy. Its address remains stable while finalized outputs or challenges borrow it. Distinct selections remain distinct even for zero-sized stateless adapters. There is no implicit Clone, allocation or synchronization requirement.

Implementations

impl<P> ProviderSession<P>

pub const fn new(backend: P) -> Self

Creates a distinct selection owner before resolving any document input.

pub const fn backend(&self) -> &P

The selected adapter; this accessor does not transfer session provenance.

pub fn same_session(&self, other: &Self) -> bool

Identity of the live selection owner, even when both adapters are ZSTs.

Trait Implementations

impl<P: Debug> Debug for ProviderSession<P>

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

Formats the value using the given formatter.

impl<P> Deref for ProviderSession<P>

type Target = P

The resulting type after dereferencing.

fn deref(&self) -> &P

Dereferences the value.

impl<'a, P: DigestProvider<'a>> DigestProvider<'a> for ProviderSession<P>

type Error = <P as DigestProvider<'a>>::Error

Original callback failure, including that provider’s resource refusal.

type Identity = <P as DigestProvider<'a>>::Identity

Fully resolved digest identity.

type State = <P as DigestProvider<'a>>::State

Digest state, independently movable from its identity object.

type Output = <P as DigestProvider<'a>>::Output

Final output, inline or retaining its own admitted allocation charge.

fn resolve_digest( &'a self, algorithm: DigestAlgorithm<'a>, encoding: Encoding, parent: &Reader<'a>, ) -> Result<Resolution<Self::Identity>, Self::Error>

Resolves original parameters under their producing encoding/work domain.

fn compare_digest<W: Work>( &self, left: &Self::Identity, right: &Self::Identity, work: &W, ) -> Result<Ordering, Self::Error>

Compares full resolved identities after admitting any parameter traversal.

fn digest_width(&self, identity: &Self::Identity) -> Option<usize>

Expected fixed output width, or None for an identity without a fixed width. This is O(1) metadata access on the already resolved identity, not parsing.

fn start_digest<W: Work>( &'a self, identity: &Self::Identity, work: &W, ) -> Result<Self::State, Self::Error>

Initializes a state without borrowing the address of identity.

fn update_digest<W: Work>( &self, state: &mut Self::State, bytes: &[u8], work: &W, ) -> Result<(), Self::Error>

Admits and processes each complete logical chunk exactly once.

fn finish_digest<W: Work>( &self, state: Self::State, work: &W, ) -> Result<Self::Output, Self::Error>

Consumes a completed state once; no opaque state cloning or repeated finish.

fn matches_digest<W: Work>( &self, digest: Prehash<'_, '_, Self, Self::Identity>, expected: &[u8], work: &W, ) -> Result<bool, Self::Error>

Compares completed bytes with a declared imprint, without hashing again.

impl<'a, P: SignatureProvider<'a>> SignatureProvider<'a> for ProviderSession<P>

type SignatureIdentity = <P as SignatureProvider<'a>>::SignatureIdentity

Fully resolved signature identity, including algorithm-specific defaults.

type RawState = <P as SignatureProvider<'a>>::RawState

Raw verification state, initialized with original signature/key first.

fn resolve_signature( &'a self, algorithm: AlgorithmIdentifier<'a>, digest: &Self::Identity, key: WorkingKey<'a>, encoding: Encoding, parent: &Reader<'a>, ) -> Result<Resolution<SignatureMode<Self::SignatureIdentity>>, Self::Error>

Chooses raw versus prehashed only after complete algorithm/key resolution.

fn compare_signature<W: Work>( &self, left: &Self::SignatureIdentity, right: &Self::SignatureIdentity, work: &W, ) -> Result<Ordering, Self::Error>

Semantic signature/default comparison for protected versus outer identifiers.

fn start_raw<W: Work>( &'a self, identity: &Self::SignatureIdentity, key: WorkingKey<'a>, signature: &'a Octets<'a>, work: &W, ) -> Result<Self::RawState, Self::Error>

Starts the raw challenge with the original signature and effective key.

fn update_raw<W: Work>( &self, state: &mut Self::RawState, bytes: &[u8], work: &W, ) -> Result<(), Self::Error>

Admits and processes original raw message chunks, never digest bytes.

fn finish_raw<W: Work>( &self, state: Self::RawState, work: &W, ) -> Result<SignatureAnswer, Self::Error>

Completes a raw signature only after successful complete source EOF.

fn verify_prehashed<W: Work>( &'a self, identity: &Self::SignatureIdentity, key: WorkingKey<'a>, signature: &Octets<'a>, digest: Prehash<'_, '_, Self, Self::Identity>, work: &W, ) -> Result<SignatureAnswer, Self::Error>

Verifies one borrowed finalized digest with its full identity; no rehash.