Trait FromRequest 

pub trait FromRequest<Req, State, Res>: Sized
where
    Req: Send,
    State: Send,
    Res: Send,
{
    // Required method
    fn from_request(bundle: &mut Bundle<Req, State, Res>) -> Option<Self>;
}

Define how A value be extracted from a Bundle.

Required Methods

fn from_request(bundle: &mut Bundle<Req, State, Res>) -> Option<Self>

Extract this value from the bundle.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AIName

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AIName

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AddCounter

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AddCounter

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AnnounceAttribute

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AnnounceAttribute

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AnnounceCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AnnounceCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AnnounceNumber

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AnnounceNumber

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AnnounceRace

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AnnounceRace

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Attack

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Attack

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AttackDisabled

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &AttackDisabled

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Battle

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Battle

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &BeChainTarget

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &BeChainTarget

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &BecomeTarget

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &BecomeTarget

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CancelTarget

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CancelTarget

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CardHint

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CardHint

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CardSelected

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CardSelected

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CardTarget

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CardTarget

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ChainDisabled

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ChainDisabled

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ChainEnd

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ChainEnd

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ChainNegated

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ChainNegated

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ChainSolved

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ChainSolved

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ChainSolving

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ChainSolving

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Chained

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Chained

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Chaining

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Chaining

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ChangeSide

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Chat

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Chat

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ConfirmCards

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ConfirmCards

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ConfirmDecktop

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ConfirmDecktop

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ConfirmExtraTop

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ConfirmExtraTop

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CreateGame

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CreateGame

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CreateRelation

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CreateRelation

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CustomMsg

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &CustomMsg

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Damage

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Damage

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &DamageStepEnd

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &DamageStepEnd

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &DamageStepStart

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &DamageStepStart

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &DeckCount

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &DeckTop

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &DeckTop

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Draw

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Draw

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &DuelEnd

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &DuelStart

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Equip

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Equip

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ErrorMessage

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &FieldDisabled

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &FieldDisabled

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &FieldFinish

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &FlipSummoned

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &FlipSummoned

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &FlipSummoning

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &FlipSummoning

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &GameMessage

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HandResult

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HandResult

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HandResult

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HandResult

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Hint

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Hint

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HsKick

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HsNotReady

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HsPlayerChange

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HsPlayerEnter

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HsReady

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HsStart

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HsToDuelist

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HsToObserver

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &HsWatchChange

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &JoinGame

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &JoinGame

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &LPUpdate

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &LPUpdate

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &LeaveGame

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &LeaveGame

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &MatchKill

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &MatchKill

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &MissedEffect

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &MissedEffect

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Move

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Move

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &NewPhase

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &NewPhase

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &NewTurn

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &NewTurn

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &PayLPCost

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &PayLPCost

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &PlayerHint

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &PlayerHint

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &PlayerInfo

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &PositionChange

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &PositionChange

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &RandomSelected

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &RandomSelected

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Recover

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Recover

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &RefreshDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &RefreshDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ReleaseRelation

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ReleaseRelation

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ReloadField

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ReloadField

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &RemoveCounter

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &RemoveCounter

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Replay

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &RequestDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &RequestDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &RequestField

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Response

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Retry

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Retry

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ReverseDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ReverseDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &RockPaperScissors

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &RockPaperScissors

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectBattleCommand

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectBattleCommand

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectChain

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectChain

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectCounter

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectCounter

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectDisableField

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectDisableField

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectEffectYesNo

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectEffectYesNo

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectHand

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectIdleCommand

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectIdleCommand

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectOption

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectOption

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectPlace

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectPlace

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectPosition

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectPosition

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectSum

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectSum

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectTp

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectTribute

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectTribute

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectUnselectCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectUnselectCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectYesNo

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SelectYesNo

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Set

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Set

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ShowHint

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ShowHint

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ShuffleDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ShuffleDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ShuffleExtra

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ShuffleExtra

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ShuffleHand

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ShuffleHand

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ShuffleSetCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &ShuffleSetCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SortCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SortCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SortChain

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SortChain

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SpecialSummoned

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SpecialSummoned

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SpecialSummoning

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SpecialSummoning

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Start

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Start

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Summoned

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Summoned

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Summoning

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Summoning

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Surrender

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Swap

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Swap

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SwapGraveDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &SwapGraveDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &TagSwap

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &TagSwap

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &TeammateSurrender

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &TimeConfirm

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &TimeLimit

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &TossCoin

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &TossCoin

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &TossDice

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &TossDice

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &TpResult

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &TpResult

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &TypeChange

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Unequip

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Unequip

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &UpdateCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &UpdateCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &UpdateData

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &UpdateData

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &UpdateDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Waiting

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Waiting

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &WaitingSide

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Win

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Complex<Message>, Extra>, State, Res> for &Win

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Complex<Message>, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &AIName

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &AddCounter

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &AnnounceAttribute

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &AnnounceCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &AnnounceNumber

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &AnnounceRace

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Attack

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &AttackDisabled

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Battle

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &BeChainTarget

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &BecomeTarget

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &CancelTarget

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &CardHint

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &CardSelected

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &CardTarget

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ChainDisabled

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ChainEnd

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ChainNegated

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ChainSolved

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ChainSolving

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Chained

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Chaining

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ChangeSide

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Chat

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Chat

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ConfirmCards

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ConfirmDecktop

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ConfirmExtraTop

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &CreateGame

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &CreateGame

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &CreateRelation

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &CustomMsg

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Damage

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &DamageStepEnd

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &DamageStepStart

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &DeckCount

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &DeckTop

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Draw

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &DuelEnd

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &DuelStart

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Equip

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ErrorMessage

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &FieldDisabled

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &FieldFinish

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &FlipSummoned

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &FlipSummoning

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &GameMessage

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &HandResult

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &HandResult

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &HandResult

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Hint

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &HsKick

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &HsNotReady

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &HsPlayerChange

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &HsPlayerEnter

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &HsReady

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &HsStart

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &HsToDuelist

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &HsToObserver

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &HsWatchChange

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &JoinGame

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &JoinGame

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &LPUpdate

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &LeaveGame

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &LeaveGame

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &MatchKill

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &MissedEffect

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Move

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &NewPhase

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &NewTurn

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &PayLPCost

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &PlayerHint

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &PlayerInfo

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &PositionChange

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &RandomSelected

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Recover

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &RefreshDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ReleaseRelation

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ReloadField

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &RemoveCounter

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Replay

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &RequestDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &RequestField

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Response

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Retry

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ReverseDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &RockPaperScissors

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectBattleCommand

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectChain

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectCounter

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectDisableField

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectEffectYesNo

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectHand

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectIdleCommand

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectOption

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectPlace

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectPosition

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectSum

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectTp

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectTribute

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectUnselectCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SelectYesNo

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Set

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ShowHint

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ShuffleDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ShuffleExtra

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ShuffleHand

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &ShuffleSetCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SortCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SortChain

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SpecialSummoned

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SpecialSummoning

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Start

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Summoned

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Summoning

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Surrender

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Swap

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &SwapGraveDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &TagSwap

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &TeammateSurrender

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &TimeConfirm

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &TimeLimit

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &TossCoin

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &TossDice

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &TpResult

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &TpResult

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &TypeChange

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Unequip

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &UpdateCard

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &UpdateData

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &UpdateDeck

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Waiting

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &WaitingSide

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Win

where Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Message, Extra, State, Res> FromRequest<Request<Message, Extra>, State, Res> for &Message

where Message: Send, Extra: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Extra>, State, Res>, ) -> Option<Self>

impl<Message, State, Res> FromRequest<Request<Message, CorePlayer>, State, Res> for CorePlayer

where Message: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, CorePlayer>, State, Res>, ) -> Option<Self>

impl<Message, State, Res> FromRequest<Request<Message, Netplayer>, State, Res> for Netplayer

where Message: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, Netplayer>, State, Res>, ) -> Option<Self>

impl<Message, State, Res> FromRequest<Request<Message, SocketAddr>, State, Res> for SocketAddr

where Message: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, SocketAddr>, State, Res>, ) -> Option<Self>

impl<Message, State, Res> FromRequest<Request<Message, u8>, State, Res> for u8

where Message: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, u8>, State, Res>, ) -> Option<Self>

impl<Message, State, Res> FromRequest<Request<Message, u32>, State, Res> for u32

where Message: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, u32>, State, Res>, ) -> Option<Self>

impl<Message, State, Res> FromRequest<Request<Message, usize>, State, Res> for usize

where Message: Send, State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Request<Message, usize>, State, Res>, ) -> Option<Self>

impl<Req, State, Res> FromRequest<Req, State, Res> for &mut Map<dyn Any + Send>

where State: ContainsMapMut + Send, Req: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Req, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Box<dyn Any + Send>, State, Res> for &mut Box<dyn Any + Send>

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Box<dyn Any + Send>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AIName

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AIName

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AddCounter

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AddCounter

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AnnounceAttribute

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AnnounceAttribute

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AnnounceCard

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AnnounceCard

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AnnounceNumber

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AnnounceNumber

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AnnounceRace

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AnnounceRace

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Attack

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Attack

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AttackDisabled

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &AttackDisabled

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Battle

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Battle

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &BeChainTarget

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &BeChainTarget

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &BecomeTarget

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &BecomeTarget

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CancelTarget

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CancelTarget

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CardHint

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CardHint

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CardSelected

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CardSelected

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CardTarget

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CardTarget

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ChainDisabled

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ChainDisabled

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ChainEnd

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ChainEnd

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ChainNegated

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ChainNegated

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ChainSolved

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ChainSolved

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ChainSolving

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ChainSolving

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Chained

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Chained

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Chaining

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Chaining

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ChangeSide

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Chat

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Chat

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ConfirmCards

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ConfirmCards

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ConfirmDecktop

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ConfirmDecktop

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ConfirmExtraTop

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ConfirmExtraTop

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CreateGame

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CreateGame

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CreateRelation

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CreateRelation

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CustomMsg

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &CustomMsg

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Damage

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Damage

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &DamageStepEnd

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &DamageStepEnd

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &DamageStepStart

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &DamageStepStart

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &DeckCount

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &DeckTop

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &DeckTop

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Draw

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Draw

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &DuelEnd

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &DuelStart

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Equip

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Equip

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ErrorMessage

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &FieldDisabled

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &FieldDisabled

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &FieldFinish

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &FlipSummoned

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &FlipSummoned

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &FlipSummoning

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &FlipSummoning

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &GameMessage

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HandResult

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HandResult

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HandResult

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HandResult

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Hint

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Hint

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HsKick

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HsNotReady

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HsPlayerChange

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HsPlayerEnter

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HsReady

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HsStart

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HsToDuelist

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HsToObserver

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &HsWatchChange

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &JoinGame

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &JoinGame

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &LPUpdate

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &LPUpdate

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &LeaveGame

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &LeaveGame

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &MatchKill

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &MatchKill

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &MissedEffect

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &MissedEffect

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Move

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Move

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &NewPhase

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &NewPhase

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &NewTurn

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &NewTurn

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &PayLPCost

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &PayLPCost

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &PlayerHint

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &PlayerHint

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &PlayerInfo

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &PositionChange

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &PositionChange

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &RandomSelected

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &RandomSelected

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Recover

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Recover

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &RefreshDeck

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &RefreshDeck

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ReleaseRelation

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ReleaseRelation

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ReloadField

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ReloadField

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &RemoveCounter

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &RemoveCounter

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Replay

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &RequestDeck

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &RequestDeck

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &RequestField

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Response

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Retry

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Retry

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ReverseDeck

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ReverseDeck

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &RockPaperScissors

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &RockPaperScissors

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectBattleCommand

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectBattleCommand

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectCard

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectCard

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectChain

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectChain

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectCounter

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectCounter

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectDisableField

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectDisableField

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectEffectYesNo

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectEffectYesNo

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectHand

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectIdleCommand

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectIdleCommand

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectOption

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectOption

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectPlace

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectPlace

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectPosition

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectPosition

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectSum

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectSum

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectTp

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectTribute

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectTribute

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectUnselectCard

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectUnselectCard

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectYesNo

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SelectYesNo

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Set

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Set

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ShowHint

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ShowHint

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ShuffleDeck

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ShuffleDeck

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ShuffleExtra

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ShuffleExtra

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ShuffleHand

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ShuffleHand

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ShuffleSetCard

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &ShuffleSetCard

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SortCard

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SortCard

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SortChain

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SortChain

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SpecialSummoned

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SpecialSummoned

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SpecialSummoning

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SpecialSummoning

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Start

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Start

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Summoned

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Summoned

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Summoning

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Summoning

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Surrender

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Swap

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Swap

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SwapGraveDeck

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &SwapGraveDeck

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &TagSwap

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &TagSwap

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &TeammateSurrender

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &TimeConfirm

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &TimeLimit

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &TossCoin

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &TossCoin

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &TossDice

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &TossDice

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &TpResult

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &TpResult

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &TypeChange

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Unequip

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Unequip

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &UpdateCard

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &UpdateCard

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &UpdateData

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &UpdateData

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &UpdateDeck

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Waiting

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Waiting

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &WaitingSide

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Win

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Complex<Message>, State, Res> for &Win

where State: Send, Res: Send,

fn from_request( bundle: &mut Bundle<Complex<Message>, State, Res>, ) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &AIName

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &AddCounter

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &AnnounceAttribute

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &AnnounceCard

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &AnnounceNumber

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &AnnounceRace

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Attack

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &AttackDisabled

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Battle

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &BeChainTarget

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &BecomeTarget

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &CancelTarget

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &CardHint

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &CardSelected

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &CardTarget

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ChainDisabled

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ChainEnd

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ChainNegated

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ChainSolved

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ChainSolving

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Chained

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Chaining

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ChangeSide

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Chat

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Chat

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ConfirmCards

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ConfirmDecktop

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ConfirmExtraTop

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &CreateGame

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &CreateGame

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &CreateRelation

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &CustomMsg

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Damage

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &DamageStepEnd

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &DamageStepStart

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &DeckCount

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &DeckTop

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Draw

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &DuelEnd

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &DuelStart

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Equip

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ErrorMessage

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &FieldDisabled

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &FieldFinish

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &FlipSummoned

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &FlipSummoning

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &GameMessage

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &HandResult

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &HandResult

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &HandResult

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Hint

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &HsKick

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &HsNotReady

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &HsPlayerChange

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &HsPlayerEnter

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &HsReady

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &HsStart

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &HsToDuelist

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &HsToObserver

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &HsWatchChange

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &JoinGame

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &JoinGame

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &LPUpdate

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &LeaveGame

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &LeaveGame

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &MatchKill

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &MissedEffect

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Move

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &NewPhase

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &NewTurn

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &PayLPCost

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &PlayerHint

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &PlayerInfo

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &PositionChange

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &RandomSelected

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Recover

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &RefreshDeck

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ReleaseRelation

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ReloadField

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &RemoveCounter

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Replay

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &RequestDeck

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &RequestField

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Response

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Retry

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ReverseDeck

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &RockPaperScissors

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectBattleCommand

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectCard

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectChain

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectCounter

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectDisableField

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectEffectYesNo

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectHand

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectIdleCommand

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectOption

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectPlace

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectPosition

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectSum

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectTp

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectTribute

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectUnselectCard

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SelectYesNo

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Set

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ShowHint

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ShuffleDeck

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ShuffleExtra

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ShuffleHand

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &ShuffleSetCard

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SortCard

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SortChain

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SpecialSummoned

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SpecialSummoning

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Start

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Summoned

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Summoning

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Surrender

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Swap

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &SwapGraveDeck

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &TagSwap

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &TeammateSurrender

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &TimeConfirm

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &TimeLimit

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &TossCoin

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &TossDice

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &TpResult

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &TpResult

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &TypeChange

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Unequip

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &UpdateCard

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &UpdateData

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &UpdateDeck

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Waiting

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &WaitingSide

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

impl<State, Res> FromRequest<Message, State, Res> for &Win

where State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Message, State, Res>) -> Option<Self>

Implementors

impl<Req, State, Message> FromRequest<Req, State, Response<Message>> for &mut ygopro_handler::extract::Response<Message>

where Req: Send, State: Send, Message: Send + Sync,

impl<Req, State, Res> FromRequest<Req, State, Res> for &mut Bundle<Req, State, Res>

where Req: Send, State: Send, Res: Send,

impl<Req, State, Res> FromRequest<Req, State, Res> for &mut StopFlag

where Req: Send, State: Send, Res: Send,