Struct Pair 

pub struct Pair<'d, A: Root<'d>, B: Root<'d>> { /* private fields */ }

Owns two providers and issues their clients in the same lending scope. Both pinned roots remain owned until their dependent application is released.

Implementations

impl<'d, A: Root<'d>, B: Root<'d>> Pair<'d, A, B>

pub const fn new(first: A, second: B) -> Self

Trait Implementations

impl<'d, A, B> App<'d> for Pair<'d, A, B>

where A: App<'d> + Root<'d>, B: App<'d> + Root<'d>,

SAFETY: each lifecycle operation visits all declared owners once, in declaration order, through the same pinned projections and presence. The root stays pinned through finish and retains each operation’s authority.

unsafe fn park<'__app, '__driver, '__turn, '__root>( __app: Pin<&'__app mut Self>, __plan: &mut Self::ParkPlan, __park: Park<'__driver, '__turn, '__root, 'd>, )

where 'd: '__driver + '__turn + '__root,

Safety

The authority and prepared plan belong to this exact installed pinned root.

unsafe fn activate<'__app, '__driver, '__turn, '__root>( __app: Pin<&'__app mut Self>, __activate: Activate<'__driver, '__turn, '__root, 'd>, ) -> bool

where 'd: '__driver + '__turn + '__root,

Safety

The operation and selected route belong to this exact installed pinned root.

const ROUTES: Routes

const WAKE_ROUTES: Routes

Routes whose installed owners may receive activation.

const COORDS: usize

Upper bound on idle coordinator probes, including delegated probes.

fn admit(__app: Pin<&Self>, __needs: &mut Needs) -> Result<(), Claim>

Accumulates the routes of the owners actually present in this pinned root.

fn released<'__app>(__call: Released<'__app, Self>) -> Released<'__app, Self>

fn install<'__app, '__owner>( __install: Install<'__app, '__owner, 'd, Self>, ) -> Install<'__app, '__owner, 'd, Self>

fn dispatch<'__app, '__driver, '__turn, '__root>( __dispatch: Dispatch<'__app, '__driver, '__turn, '__root, 'd, Self>, ) -> ControlFlow<Event<'d>>

where Self: '__root, 'd: '__root,

fn progress(__app: Pin<&Self>, __progress: Progress<'_, '_, 'd>) -> Progress<'d>

fn stopping(__app: Pin<&Self>, __progress: Progress<'_, '_, 'd>) -> Progress<'d>

fn select_park() -> Option<Self::ParkPlan>

fn prepare_park(__app: Pin<&Self>, __plan: &mut Self::ParkPlan) -> Option<Count>

Prepares the selected coordinator shares once after installation. The count does not exceed COORDS; field presence and shares remain stable through finish. None reports count overflow.

fn shutdown<'__app, '__turn, '__driver, '__owner>( __shutdown: Shutdown<'__app, '__turn, '__driver, '__owner, 'd, Self>, ) -> Shutdown<'__app, '__turn, '__driver, '__owner, 'd, Self>

where 'd: '__owner,

fn finish<'__app, '__finish, '__owner, '__epoch>( __finish: Finish<'__app, '__finish, '__owner, '__epoch, 'd, Self>, ) -> Finish<'__app, '__finish, '__owner, '__epoch, 'd, Self>

impl<'d, A, B> Layout<'d> for Pair<'d, A, B>

where A: Layout<'d> + Root<'d>, B: Layout<'d> + Root<'d>,

type ParkPlan = (Cursor<2>, Cursor<2>, Cursor<2>, Option<<A as Layout<'d>>::ParkPlan>, Option<<B as Layout<'d>>::ParkPlan>, Weights<2>)

Pre-park state selected once and retained with this pinned application.

impl<'d, A: Root<'d>, B: Root<'d>> Provider<'d> for Pair<'d, A, B>

type Client<'app> = (<<A as Root<'d>>::Provider as Provider<'d>>::Client<'app>, <<B as Root<'d>>::Provider as Provider<'d>>::Client<'app>)

where Self: 'app, 'd: 'app,

fn provide<'app>(context: Context<'_, 'app, 'd, Self>) -> Self::Client<'app>

where Self: 'app, 'd: 'app,

impl<'d, A, B> Resume<'d> for Pair<'d, A, B>

where A: Root<'d> + Resume<'d>, B: Root<'d> + Resume<'d>,

impl<'pin, 'd, A: Root<'d>, B: Root<'d>> Unpin for Pair<'d, A, B>

where PinnedFieldsOf<__Pair<'pin, 'd, A, B>>: Unpin,