Actors revisited

Boost , ,

Actors revisited

Этот класс является классом протокола для всех участников. Этот класс по сути является интерфейсным контрактом. Актерский класс на самом деле не знает, как действовать на что-либо, но вместо этого полагается на шаблонный параметр BaseT (от которого актер будет исходить) для выполнения фактического действия. Актер класса шаблон объявляется как:

    template <typename BaseT>
    struct actor : public BaseT {
        actor();
        actor(BaseT const& base);
        /*...member functions...*/
    };

Curiously Recurring Template Pattern Inverse Notice that actor derives from its template argument BaseT. This is the inverse of the curiously recurring template pattern (CRTP). With the CRTP, the actor is an abstract class with a DerivedT template parameter that is assumed to be its parametric subclass. This pattern however, "parametric base class pattern" (PBCP) for lack of a name, inverses the inheritance and makes actor a concrete class. Anyway, be it CRTP or PBCP, actor is a protocol class and either BaseT or DerivedT will have to conform to its protocol. Both CRTP and PBCP techniques has its pros and cons, of which is outside the scope of this document. CRTP should really be renamed "parametric subclass pattern (PSCP), but again, that's another story.

Актер — это функтор, способный принимать аргументы до заданного максимума. Это до базового класса, чтобы сделать фактическую обработку или, возможно, ограничить проходимость (нет. аргументов). При вызове функтора через поставляемого оператора (), актер направляет аргументы, переданные клиентом, в кортеж и вызывает функцию члена Eval базового класса.

Схематически:

    arg0 ---------|
    arg1 ---------|
    arg2 ---------|---> tupled_args ---> base.eval
    ...           |
    argN ---------|
    actor::operator()(arg0, arg1... argN)
      ---> BaseT::eval(tupled_args);

Ожидается, что базовые классы актеров, от которых этот класс наследует, будут иметь соответствующую функцию члена, совместимую с концептуальным интерфейсом:

    template <typename TupleT>
    actor_return_type
    eval(TupleT const& args) const;

где args - фактические аргументы, переданные клиентом, направляемые в кортеж (см. кортеж для деталей).

Актер может быть любым. Базовые классы могут свободно возвращать любые типы, даже зависимые от аргументов типы (типы, которые выводятся из типов аргументов). После оценки параметров и выполнения некоторых вычислений или действий функция члена Eval завершается возвращением чего-либо клиенту. Для этого передающая функция (оператор() актера) должна знать тип возврата функции члена эваля, которую она вызывает. Для этой цели актерские базовые классы должны предоставлять класс вложенных шаблонов:

    template <typename TupleT>
    struct result;

Этот вспомогательный класс предоставляет информацию о типе результата, возвращаемую функцией члена эвала базового класса актеров. Результат класса вложенного шаблона должен иметь тип DEF, который отражает тип возврата его функции члена eval. По сути, это компьютер типа, который отвечает на вопрос "приведенные аргументы, упакованные в тип TupleT, каким будет тип результата функции члена Eval ActorT?".

Существует глобальный шаблон класса actor_result, объявленный в области пространства имён phoenix, который запрашивает тип результата актера, данный кортеж. Вот заявление классного актера_результат:

    template <typename ActorT, typename TupleT>
    struct actor_result {
        typedef typename ActorT::template result<TupleT>::type type;
        typedef typename remove_reference<type>::type plain_type;
    };

• тип — это фактический тип возврата.
• plain_type - это тип возврата, лишенный ссылок.

Учитывая актерский тип ActorT и TupleT, мы можем получить актерский тип возвращения таким образом:

    typedef typename actor_result<ActorT, TupleT>::type
        actor_return_type;

где Actor_return_type - фактический тип, возвращаемый функцией члена Eval ActorT, учитывая некоторые аргументы, упакованные в TupleT.

Для справки, вот типичный актер::оператор(), который принимает два (2) аргумента:

    template <typename BaseT>
    template <typename T0, typename T1>
    inline typename actor_result<BaseT, tuple<T0&, T1&> >::type
    actor<BaseT>::operator()(T0& _0, T1& _1) const
    {
        return BaseT::eval(tuple<T0&, T1&>(_0, _1));
    }

Forwarding Function Problem _0 and _1 are references. Hence the arguments cannot accept non-const temporaries and literal constants. This is a current C++ language issue known as the "forwarding function problem" that is currently being discussed. The problem is that given an arbitrary function f, using current C++ language rules, one cannot create a forwarding function f' that transparently assumes the arguments of f.

Copyright © 2001-2002 Joel de Guzman

Use, modification and distribution is subject to the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

Статья Actors revisited раздела может быть полезна для разработчиков на c++ и boost.

:: Главная :: ::