5

それ自体がFusionシーケンスであり、すべての「呼び出し」をラップされたシーケンスに転送するBoost.Fusionシーケンス ラッパーを作成する方法を探しています。の行の何か

template< typename Sequence >
struct sequence_wrapper
{
    explicit sequence_wrapper( Sequence const& s ) : seq( s ){}

    Sequence seq;
};

wheresequence_wrapper< Sequence >はFusionシーケンスでもあり、同じように機能しSequenceます。これが必要な理由は、Fusionシーケンス (すべての要素がいくつかの特別な要件を満たす) で動作するいくつかの関数があり、オーバーロードされた演算子を追加するカスタム型が必要な構文シュガーを追加したいからです。同様に、sequence_wrapper を返すために、sequence_wrapper に対する操作の結果は必要ありません。構文シュガー関連の呼び出しのみが、(手動で) ラップされたシーケンスを返します。たとえば、コンマ演算子を使用してシーケンスに要素を追加します ( FusionシーケンスのBoost.Assignのようなものです):

template< typename Sequence, typename T >
sequence_wrapper<
    typename boost::fusion::result_of::push_back<
        Sequence const&
      , T
    >::type
> operator ,( Sequence const& seq, T const& v )
{
    return
        sequence_wrapper<
            typename boost::fusion::result_of::push_back<
                Sequence const&
              , T
            >::type
        >( boost::fusion::push_back( seq, v ) )
        ;
}

これを達成するための最良の方法は何ですか(実際にライブラリでサポートされている場合)? 特に、 Fusion操作によって返されるシーケンスを使用したいので、 Fusionシーケンスをゼロから作成することは避けようとしています。ラップされたシーケンスのタグを返すための継承+特殊化は機能しますか? または、独自のタグを定義し、呼び出しを転送するために必要なすべての機能を実装する必要がありますか?tag_of

4

1 に答える 1

4

これは私がやったことです：

template<
    typename Derived
  , typename Sequence
  , typename TraversalTag = 
        typename boost::fusion::traits::category_of< Sequence >::type
  , typename IsView =
        typename boost::fusion::traits::is_view< Sequence >::type
>
class fusion_sequence_wrapper
  : public boost::fusion::sequence_facade< Derived, TraversalTag, IsView >
{
    typedef Sequence base_sequence_type;

public:
    explicit fusion_sequence_wrapper( base_sequence_type const& sequence )
      : _seq( sequence )
    {}

    base_sequence_type const& base() const
    {
        return _seq;
    }
    base_sequence_type& base()
    {
        return _seq;
    }

public:
    template< typename Seq >
    struct begin
    {
        typedef
            typename boost::fusion::result_of::begin<
                typename boost::mpl::if_<
                    boost::is_const< Seq >
                  , base_sequence_type const
                  , base_sequence_type
                >::type
            >::type type;

        static type call( Seq& s ){ return boost::fusion::begin( s._seq ); }
    };

    template< typename Seq >
    struct end
    {
        typedef
            typename boost::fusion::result_of::end<
                typename boost::mpl::if_<
                    boost::is_const< Seq >
                  , base_sequence_type const
                  , base_sequence_type
                >::type
            >::type type;

        static type call( Seq& s ){ return boost::fusion::end( s._seq ); }
    };

    template< typename Seq >
    struct size
    {
        typedef
            typename boost::fusion::result_of::size<
                typename boost::mpl::if_<
                    boost::is_const< Seq >
                  , base_sequence_type const
                  , base_sequence_type
                >::type
            >::type type;

        static type call( Seq& s ){ return boost::fusion::size( s._seq ); }
    };

    template< typename Seq >
    struct empty
    {
        typedef
            typename boost::fusion::result_of::empty<
                typename boost::mpl::if_<
                    boost::is_const< Seq >
                  , base_sequence_type const
                  , base_sequence_type
                >::type
            >::type type;

        static type call( Seq& s ){ return boost::fusion::empty( s._seq ); }
    };

    template< typename Seq, typename N >
    struct at
    {
        typedef
            typename boost::fusion::result_of::at<
                typename boost::mpl::if_<
                    boost::is_const< Seq >
                  , base_sequence_type const
                  , base_sequence_type
                >::type
              , N
            >::type type;

        static type call( Seq& s ){ return boost::fusion::at( s._seq ); }
    };

    template< typename Seq, typename N >
    struct value_at
    {
        typedef
            typename boost::fusion::result_of::value_at<
                typename boost::mpl::if_<
                    boost::is_const< Seq >
                  , base_sequence_type const
                  , base_sequence_type
                >::type
              , N
            >::type type;
    };

private:
    base_sequence_type _seq;
};
于 2012-09-02T23:13:39.137 に答える