Introduction

Реализация зависит от тщательного изучения существующего кода FC++. FC++ List Implementation - это тщательно разработанный код, который позволяет эффективно обрабатывать ряд различных случаев. В частности, он использует FC++ Reuser Implementation для обработки повторяющихся оценок.

FC++ использует сочетание полиморфных и однотипных функций, которые могут передаваться в качестве аргументов другим функциям.

Реализация списка потребовала новых реализаций стратегии с использованием объектов Boost Phoenix, а также Boost Function. Получается, что сочетание обоих может быть использовано для удовлетворения потребностей list.

Тот факт, что функции определяются бульваром::phoenix::функция, означает, что они работают с аргументами Феникса, такими как «arg1». Это тот факт, что обеспечивает гибкость, необходимую пользователю для создания новых функций по мере необходимости.

FC++ legacy

FC++ List Implementation и FC++ Reuser Implementation очень внимательно следили за созданием этого кода. Версия, используемая в качестве отправной точки, была версией Boost FC++.

Polymorphic Function Types

Функции реализуются как структура внутри пространства имен. Например, фанкион 'x' тип определяется следующим образом:

typedef boost::phoenix::function<impl::X> X;
X x

Эта альтернатива будет работать, чтобы обеспечить функцию 'x', но тогда невозможно передать ее в качестве аргумента.

BOOST_PHOENIX_ADAPT_CALLABLE(x, impl::X, 1)

Implementation Example

Этот пример реализует id(), который просто возвращает свой аргумент:

namespace impl {
  struct Id
  {
    template <typename Sig>
    struct result;
    template <typename This, typename A0>
    struct result<This(A0)>
       : boost::remove_reference<A0>
    {};
    template <typename A0>
    A0 operator()(A0 const & a0) const
    {
        return a0;
    }
  };
}
typedef boost::phoenix::function<impl::Id> Id;
Id id;

Functions with defined return type

Иногда необходимо определить функцию с помощью шаблонного структурирования, где тип параметра шаблона определяет тип возврата.

Example with one argument

namespace impl {
  template <typename Result>
  struct what {
    typedef Result result_type;
    Result operator()(Result const & r) const
    {
      return r;
    }
  };
}
boost::function1<int, int > what_int = impl::what<int>();
typedef boost::function1<int,int> fun1_int_int;
typedef boost::phoenix::function<fun1_int_int> What_arg;
What_arg what_arg(what_int);

Example with zero arguments

namespace impl {
  template <typename Result>
  struct what0 {
    typedef Result result_type;
    Result operator()() const
    {
      return Result(100);
    }
  };
}
typedef boost::function0<int> fun0_int;
boost::function0<int> what0_int = impl::what0<int>();
typedef boost::phoenix::function<fun0_int> What0_arg;
What0_arg what0_arg(what0_int);

List Generation Implementation

Осуществление функции

enum_from(1)

требует фанктора, который будет оценивать последовательные числа по требованию. Код FC++ был повторно реализован с использованием внутренних фанкторов следующим образом.

Этот код должен тщательно манипулировать типом ввода T для построения типа результата, который является списком.

Код в EFH используется для создания серии объектов, каждый из которых добавляет один элемент в список и возвращает функцию, которая будет добавлять следующий элемент. Это вызывается только тогда, когда это необходимо.

      template <class T>
      struct EFH
      {
          mutable T x;
          EFH( const T& xx) : x(xx) {}
          template <typename Sig> struct result;
          template <typename This, class TT>
          struct result<This(TT)>
          {
            typedef typename boost::phoenix::UseList::template
                    List<TT>::type LType;
            typedef typename boost::phoenix::result_of::
                    ListType<LType>::delay_result_type type;
          };
          typename result<EFH(T)>::type operator()() const {
            typedef typename UseList::template List<T>::type LType;
            typedef typename result_of::ListType<LType>::
                    delay_result_type result_type;
            typedef boost::function0<result_type> fun1_R_TTT;
            ++x;
            fun1_R_TTT efh_R_TTT = EFH<T>(x);
            typedef boost::phoenix::function<fun1_R_TTT> EFH_R_T;
            EFH_R_T efh_R_T(efh_R_TTT);
#ifndef BOOST_PHOENIX_NO_LAZY_EXCEPTIONS
            if (x > BOOST_PHOENIX_FUNCTION_MAX_LAZY_LIST_LENGTH)
                 throw lazy_exception("Running away in EFH!!");
#endif
            return cons( x-1, efh_R_T() );
          }
      };
      struct Enum_from {
         template <typename Sig> struct result;
         template <typename This, typename T>
         struct result<This(T)>
         {
           typedef typename boost::remove_reference<T>::type TT;
           typedef typename boost::remove_const<TT>::type TTT;
           typedef typename UseList::template List<TTT>::type LType;
           typedef typename result_of::ListType<LType>::
                   delay_result_type type;
         };
         template <class T>
         typename result<Enum_from(T)>::type operator()
            (const T & x) const
          {
            typedef typename boost::remove_reference<T>::type TT;
            typedef typename boost::remove_const<TT>::type TTT;
            typedef typename UseList::template List<T>::type LType;
            typedef typename result_of::ListType<LType>::
                    delay_result_type result_type;
            typedef boost::function0<result_type> fun1_R_TTT;
            fun1_R_TTT efh_R_TTT = EFH<TTT>(x);
            typedef boost::phoenix::function<fun1_R_TTT> EFH_R_T;
            EFH_R_T efh_R_T(efh_R_TTT);
            //std::cout << "enum_from (" << x << ")" << std::endl;
            return efh_R_T();
          }
      };

Подобный код используется в соответствующих функторах

enum_from_to
filter

Conclusion

Эти механизмы осуществления последовательно используются в процессе осуществления.