MatchEventStack

A MatchEventStack função é usada para fazer a correspondência entre uma pilha de eventos e uma hierarquia de eventos específica. As hierarquias correspondentes são encaminhadas para um manipulador para processamento posterior. Para saber mais sobre eventos, pilhas de eventos e hierarquias, consulte 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 parente mais velho para corresponder na pilha de eventos.

TEvents
Os tipos restantes que desejas corresponder na pilha de eventos.

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

TExtraArgs
Tipos de argumentos extras passados para MatchEventStack.

eventStack
A pilha de eventos para corresponder à hierarquia de tipos de eventos descrita por TEvent e TEvents.

exigível
Após a correspondência bem-sucedida da pilha de eventos com a hierarquia de tipos de evento descrita por TEvent e TEvents, MatchEventStack invoca chamável. Ele passa para um argumento de valor r chamável para cada tipo na hierarquia de eventos. O pacote de parâmetros extraArgs é passado de forma ideal nos restantes parâmetros de callable.

extraArgs
Os argumentos que são encaminhados perfeitamente para chamável junto com o tipo de evento correspondente.

Valor de retorno

Um bool valor que é true caso a correspondência tenha sido bem-sucedida ou false caso contrário.

Observações

O último evento em eventStack é sempre comparado com a última entrada na lista de tipos [TEvent, TEvents...] concatenada. Todas as outras entradas TEvent e TEvents podem corresponder a qualquer posição no 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 correspondê-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).
}