MatchEventStack

La MatchEventStack funzione viene usata per associare uno stack di eventi a una gerarchia di eventi specifica. Le gerarchie corrispondenti vengono inoltrate a un gestore per un'ulteriore elaborazione. Per altre informazioni su eventi, stack di eventi e gerarchie, vedere la tabella degli eventi.

Sintassi

template <
    typename          TEvent,
    typename...       TEvents,
    typename          TCallable,
    typename...       TExtraArgs>
bool MatchEventStack(
    const EventStack& eventStack,
    TCallable&&       callable,
    TExtraArgs&&...   extraArgs);

Parametri

TEvent
Tipo dell'elemento padre più grande da trovare nello stack di eventi.

Eventi TEvent
I tipi rimanenti che si desidera trovare nello stack di eventi.

TCallable
Tipo che supporta operator(). Per altre informazioni sugli argomenti passati a questo operatore, vedere la descrizione del parametro chiamabile .

TExtraArgs
Tipi di argomenti aggiuntivi passati a MatchEventStack.

eventStack
Stack di eventi per la corrispondenza con la gerarchia dei tipi di evento descritta da TEvent e TEvents.

Callable
Dopo aver eseguito correttamente la corrispondenza dello stack di eventi con la gerarchia dei tipi di evento descritta da TEvent e TEvents, MatchEventStack richiama callable. Passa a un argomento r-value chiamabile per ogni tipo nella gerarchia di eventi. Il pacchetto di parametri extraArgs è perfettamente inoltrato nei parametri rimanenti di chiamabili.

extraArgs
Argomenti che vengono inoltrati perfettamente per chiamare insieme al tipo di evento corrispondente.

Valore restituito

Valore bool che si verifica true se la corrispondenza ha avuto esito positivo o false in caso contrario.

Osservazioni:

L'ultimo evento in eventStack viene sempre confrontato con l'ultima voce nell'elenco dei tipi [TEvent, TEvents...]. Tutte le altre voci TEvent e TEvents possono corrispondere a qualsiasi posizione in eventStack tranne l'ultima, purché siano nello stesso ordine.

I tipi di evento da usare per i parametri TEvent e TEvents vengono selezionati da un elenco di classi di acquisizione. Per un elenco di eventi e le classi di acquisizione che è possibile usare per trovare le corrispondenze, vedere la tabella degli eventi.

Esempio

void MyClass::OnStartActivity(const EventStack& eventStack)
{
    // Let's assume eventStack contains:
    // [Compiler, BackEndPass, C2DLL, CodeGeneration, Thread, Function]

    bool b1 = MatchEventStack<Compiler, BackEndPass, C2DLL,
                CodeGeneration, Thread, Function>(
        eventStack, [](Compiler cl, BackEndPass bep, C2DLL c2,
            CodeGeneration cg, Thread t, Function f){ /* Do something ... */ });

    bool b2 = MatchEventStack<Compiler, Function>(
        eventStack, [](Compiler cl, Function f){ /* Do something... */ });

    bool b3 = MatchEventStack<Thread, Compiler, Function>(
        eventStack, [](Thread t, Compiler cl Function f){ /* Do something... */ });

    bool b4 = MatchEventStack<Compiler>(
        eventStack, [](Compiler cl){ /* Do something... */ });


    // b1: true because the list of types matches the eventStack exactly.
    // b2: true because Function is the last entry in both the type list
    //     and 'eventStack', and also because Compiler comes before
    //     Function in 'eventStack' and in the type list.
    // b3: false because, even though both Thread and Compiler come
    //     before Function in 'eventStack', they aren't listed in the
    //     right order in the type list.
    // b4: false because the last entry in the type list is Compiler,
    //     which doesn't match the last entry in 'eventStack' (Function).
}