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<'a, P: AsnDigest<'a>> AsnDigest<'a> for ProviderSession<P>

fn identity(&self, algorithm: Algorithm) -> Option<Self::Identity>

This provider’s identity for algorithm, or None when it does not implement it or its policy refuses it. O(1); no work is spent.

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: Digest<'a>> Digest<'a> for ProviderSession<P>

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

Fully resolved digest identity.

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

Digest state, independently movable from its identity object.

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

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

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

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

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

Fixed output width, or None for an identity without one. This is O(1) metadata access on the resolved identity, not parsing.

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

Total semantic order: Equal means the outputs can be shared.

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

Starts one stream for this identity without retaining a reference to the identity object. A backend without incremental capability answers Unsupported; it never buffers into a one-shot fallback.

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

Admits and processes one complete chunk exactly once.

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

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

fn matches<W: Work>( &self, identity: &Self::Identity, output: &Self::Output, expected: &[u8], work: &W, ) -> Result<bool, Self::Error>

Compares this provider’s finished output with declared bytes, admitting the whole scan and applying the backend’s comparison strategy.

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.