MatchEventStack

A função MatchEventStack é usada para corresponder a uma pilha de eventos com uma hierarquia de eventos específica. As hierarquias correspondentes são encaminhadas para um manipulador para processamento adicional. Para saber mais sobre eventos, pilhas de eventos e hierarquias, confira a tabela de eventos.

Sintaxe

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

Parâmetros

TEvent
O tipo do pai mais velho a ser correspondido na pilha de eventos.

TEvents
Os tipos restantes que você deseja corresponder na pilha de eventos.

TCallable
Um tipo que dá suporte a operator(). Para obter mais informações sobre quais argumentos são passados para esse operador, consulte a descrição do parâmetro callable.

TExtraArgs
Os tipos dos argumentos adicionais passados para MatchEventStack.

eventStack
A pilha de eventos a ser correspondida com a hierarquia de tipos de evento descrita por TEvent a TEvents.

callable
Após a correspondência com êxito da pilha de eventos com a hierarquia de tipo de evento descrita por TEvent e TEvents, MatchEventStack invoca callable. Ele passa para um argumento de r-value callable para cada tipo na hierarquia de eventos. O pacote de parâmetros extraArgs é encaminhado perfeitamente nos parâmetros restantes do callable.

extraArgs
Os argumentos que são encaminhados perfeitamente para callable juntamente com o tipo de evento correspondente.

Valor de retorno

Um valor bool que é true quando há correspondência ou false quando não há.

Comentários

O último evento em eventStack sempre é correspondente à última entrada na lista de tipos concatenados [TEvent, TEvents...]. Todas as outras entradas TEvent e TEvents podem corresponder a qualquer posição em eventStack, exceto a última, desde que estejam na mesma ordem.

Os tipos de evento a serem usados para os parâmetros TEvent e TEvents são selecionados em uma lista de classes de captura. Para obter uma lista de eventos e as classes de captura que você pode usar para combiná-los, consulte a tabela de eventos.

Exemplo

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).
}