MatchEventStackInMemberFunction

La función MatchEventStackInMemberFunction se usa para comparar una pila de eventos con una jerarquía de eventos concreta, que se describe en la lista de parámetros de una función miembro. Las jerarquías coincidentes se reenvían a la función miembro para su posterior procesamiento. Para obtener más información sobre eventos, pilas de eventos y jerarquías, vea la tabla de eventos.

Sintaxis

template <
    typename     TInterface,
    typename     TReturn,
    typename     T1,
    typename...  TExtraParams,
    typename...  TExtraArgs>
bool MatchEventStackInMemberFunction(
    const EventStack&         eventStack,
    TInterface*               objectPtr,
    TReturn (TInterface::*    memberFunc)(T1, TExtraParams...),
    TExtraArgs&&...           extraArgs);

template <
    typename     TInterface,
    typename     TReturn,
    typename     T1,
    typename     T2,
    typename...  TExtraParams,
    typename...  TExtraArgs>
bool MatchEventStackInMemberFunction(
    const EventStack&         eventStack,
    TInterface*               objectPtr,
    TReturn (TInterface::*    memberFunc)(T1, T2, TExtraParams...),
    TExtraArgs&&...           extraArgs);

// Etc...

template <
    typename     TInterface,
    typename     TReturn,
    typename     T1,
    typename     T2,
    typename     T3,
    typename     T4,
    typename     T5,
    typename     T6,
    typename     T7,
    typename     T8,
    typename     T9,
    typename     T10,
    typename...  TExtraParams,
    typename...  TExtraArgs>
bool MatchEventStackInMemberFunction(
    const EventStack&         eventStack,
    TInterface*               objectPtr,
    TReturn (TInterface::*    memberFunc)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TExtraParams...),
    TExtraArgs&&...           extraArgs);

Parámetros

TInterface
Tipo que contiene la función miembro.

TReturn
Tipo de valor devuelto de la función miembro.

T1, ..., T10
Tipos que describen la jerarquía de eventos que se va a comparar.

TExtraParams
Tipos de los parámetros adicionales aceptados por la función miembro y tipos de jerarquía de eventos.

TExtraArgs
Tipos de los argumentos adicionales que se pasaron a MatchEventStackInMemberFunction.

eventStack
Pila de eventos para comparar con la jerarquía de tipos de evento descrita desde T1 hasta T10.

objectPtr
Puntero a un objeto en el que se llama a memberFunc.

memberFunc
Función miembro que describe la jerarquía de tipos de eventos que se va a comparar.

extraArgs
Argumentos que se reenvían directamente a memberFunc junto con los parámetros de la jerarquía de tipo de eventos.

Valor devuelto

Valor bool que es true si la coincidencia se produjo correctamente, o false de lo contrario.

Comentarios

El último evento de eventStack siempre se compara con la última entrada de la jerarquía de tipos de evento con la que se hace coincidir. Todos los demás tipos de la jerarquía de tipos de evento pueden coincidir con cualquier posición de eventStack excepto la última, siempre que estén en el mismo orden.

Los tipos de evento que se van a usar para los parámetros de T1 a T10 se seleccionan de una lista de clases de captura. Para obtener una lista de eventos y las clases de captura que puede usar para la comparación, consulte la tabla de eventos.

Ejemplo

void MyClass::Foo1(Compiler cl, BackEndPass bep, C2DLL c2,
    CodeGeneration cg, Thread t, Function f) { }

void MyClass::Foo2(Compiler cl, Function f) { }

void MyClass::Foo3(Thread t, Compiler cl, Function f) { }

void MyClass::Foo4(Compiler cl) { }

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

    bool b1 = MatchEventStackInMemberFunction(
        eventStack, this, &MyClass::Foo1);

    bool b2 = MatchEventStackInMemberFunction(
        eventStack, this, &MyClass::Foo2);

    bool b3 = MatchEventStackInMemberFunction(
        eventStack, this, &MyClass::Foo3);

    bool b4 = MatchEventStackInMemberFunction(
        eventStack, this, &MyClass::Foo4);

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