c++ - スピリットqiでイテレータを関数に渡す方法

Question

template <typename Iterator>
struct parse_grammar
: qi::grammar<Iterator, std::string()>
{
    parse_grammar()
        : parse_grammar::base_type(start_p, "start_p"){
            a_p = ',' > qi::double_;
            b_p = *a_p;
            start_p = qi::double_ > b_p >> qi::eoi;
        }

    qi::rule<Iterator, std::string()> a_p;
    qi::rule<Iterator, std::string()> b_p;
    qi::rule<Iterator, std::string()> start_p;
};


// implementation

std::vector<double> parse(std::istream& input, const std::string& filename)

{

// iterate over stream input

    typedef std::istreambuf_iterator<char> base_iterator_type;
    base_iterator_type in_begin(input);

    // convert input iterator to forward iterator, usable by spirit parser
    typedef boost::spirit::multi_pass<base_iterator_type> forward_iterator_type;
    forward_iterator_type fwd_begin = boost::spirit::make_default_multi_pass(in_begin);
    forward_iterator_type fwd_end;

    // prepare output
    std::vector<double> output;
    // wrap forward iterator with position iterator, to record the position
    typedef classic::position_iterator2<forward_iterator_type> pos_iterator_type;
    pos_iterator_type position_begin(fwd_begin, fwd_end, filename);
    pos_iterator_type position_end;

    parse_grammar<pos_iterator_type> gram;

    // parse
    try
    {
        qi::phrase_parse(
                position_begin, position_end,                     // iterators over input
                gram,                                         // recognize list of doubles
                ascii::space);                                         // comment skipper
    }
    catch(const qi::expectation_failure<pos_iterator_type>& e)
    {
        const classic::file_position_base<std::string>& pos = e.first.get_position();
        std::stringstream msg;
        msg <<
            "parse error at file " << pos.file <<
            " line " << pos.line << " column " << pos.column << std::endl <<
            "'" << e.first.get_currentline() << "'" << std::endl <<
            " " << "^- here";
        throw std::runtime_error(msg.str());
    }

    // return result
    return output;
}

上記のサンプルコードがあります（たとえば、boost-spirit Webサイトから使用されたコードはこちら）。

ルール a_p の文法では、セマンティックアクションを使用してメソッドを呼び出し、イテレータを次のように渡したいと考えています。

a_p = ',' > qi::double_[boost::bind(&parse_grammar::doStuff(), this, 
    boost::ref(position_begin), boost::ref(position_end)];

メソッド doStuff のシグネチャが次のような場合:

void doStuff(pos_iterator_type const& first, pos_iterator_type const& last);

これを行う方法はありますか？メソッドにイテレータが現在の状態で渡される限り、私はどんな方法でも構いません(boost::phoenixまたは方法がわからないものを使用してそれを行うことができれば)。

score 3 · Accepted Answer

あなたが説明したものが「必要」だと思う理由が完全にはわかりません。あなたの実際のタスクの解決策は非常に簡単かもしれません：

start_p = qi::double_ % ',' > qi::eoi;

ただし、実際の質問は非常に興味深いものであり、istream_buf(通常の (slower) だけでなく)と組み合わせて位置インターレーターを使用するboost::spirit::istream_iteratorことにはメリットがあるため、セマンティックアクションでもそれを行う方法を示します。

単純な (しかしかなり完全な) テスト main の場合

int main()
{
    std::istringstream iss(
            "1, -3.4 ,3.1415926\n"
            ",+inF,-NaN  ,\n"
            "2,-.4,4.14e7\n");

    data_t parsed = parse(iss, "<inline-test>");

    std::cout << "Done, parsed " << parsed.size() << " values ("
        << "min: " << *std::min_element(parsed.begin(), parsed.end()) << ", "
        << "max: " << *std::max_element(parsed.begin(), parsed.end()) << ")\n";
}

セマンティックアクションの出力は次のようになります。

debug ('start_p') at <inline-test>:1:[1..2] '1'  = 1
debug ('start_p') at <inline-test>:1:[4..8] '-3.4'   = -3.4
debug ('start_p') at <inline-test>:1:[10..19]   '3.1415926'  = 3.14159
debug ('start_p') at <inline-test>:2:[2..6] '+inF'   = inf
debug ('start_p') at <inline-test>:2:[7..11]    '-NaN'   = -nan
debug ('start_p') at <inline-test>:3:[1..2] '2'  = 2
debug ('start_p') at <inline-test>:3:[3..6] '-.4'    = -0.4
debug ('start_p') at <inline-test>:3:[7..13]    '4.14e7'     = 4.14e+07
Done, parsed 8 values (min: -3.4, max: inf)

http: //liveworkspace.org/code/8a874ef3 ...で実際にご覧ください。

方法に注意してください

実際のパーサーインスタンスの名前 ('start_p') へのアクセスを示します。
完全なソースイテレータ範囲へのアクセスを示します
セマンティックアクション内で特殊な処理を行う方法を示します
qi::double_すべてのケースを簡単に処理できるのは私が知っている唯一のものだからです (テストデータとこの他の質問を参照してください: Is it possible to read infinity or NaN values using input streams ? )
解析された値の統計を表示することにより、実際のデータをベクトルに効率的に解析する方法を示します

完全なコード

将来の参照用の完全なコードは次のとおりです。

#define BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/support_multi_pass.hpp>
#include <boost/spirit/include/classic_position_iterator.hpp>
#include <boost/phoenix/function/adapt_function.hpp>

namespace qi      = boost::spirit::qi;
namespace phx     = boost::phoenix;
namespace classic = boost::spirit::classic;
namespace ascii   = boost::spirit::ascii;

typedef std::vector<double> data_t;

///////// USING A FREE FUNCTION
//
template <typename Grammar, typename Range>
    double doStuff_(Grammar &grammar, Range pos_range)
{
    // for efficiency, cache adhoc grammar:
    static const qi::rule   <typename Range::iterator, double()> r_double = qi::double_;
    static const qi::grammar<typename Range::iterator, double()> g_double(r_double); // caching just the rule may be enough, actually

    double value = 0;
    qi::parse(pos_range.begin(), pos_range.end(), g_double, value);

    std::cout << "debug ('" << grammar.name() << "') at "
       << pos_range.begin().get_position().file   << ":"
       << pos_range.begin().get_position().line   << ":["
       << pos_range.begin().get_position().column << ".." 
       << pos_range.end  ().get_position().column << "]\t" 
       << "'" << std::string(pos_range.begin(),pos_range.end()) << "'\t = "
       << value
       << '\n';

    return value;
}

BOOST_PHOENIX_ADAPT_FUNCTION(double, doStuff, doStuff_, 2)

template <typename Iterator, typename Skipper>
struct parse_grammar : qi::grammar<Iterator, data_t(), Skipper>
{
    parse_grammar()
        : parse_grammar::base_type(start_p, "start_p")
    {
        using qi::raw;
        using qi::double_;
        using qi::_1;
        using qi::_val;
        using qi::eoi;
        using phx::push_back;

        value_p = raw [ double_ ] [ _val = doStuff(phx::ref(*this), _1) ];
        start_p = value_p % ',' > eoi;

        // // To use without the semantic action (more efficient):
        // start_p = double_ % ',' >> eoi;
    }

    qi::rule<Iterator, data_t::value_type(), Skipper> value_p;
    qi::rule<Iterator, data_t(), Skipper> start_p;
};

// implementation
data_t parse(std::istream& input, const std::string& filename)
{
    // iterate over stream input
    typedef std::istreambuf_iterator<char> base_iterator_type;
    base_iterator_type in_begin(input);

    // convert input iterator to forward iterator, usable by spirit parser
    typedef boost::spirit::multi_pass<base_iterator_type> forward_iterator_type;
    forward_iterator_type fwd_begin = boost::spirit::make_default_multi_pass(in_begin);
    forward_iterator_type fwd_end;

    // wrap forward iterator with position iterator, to record the position
    typedef classic::position_iterator2<forward_iterator_type> pos_iterator_type;
    pos_iterator_type position_begin(fwd_begin, fwd_end, filename);
    pos_iterator_type position_end;

    parse_grammar<pos_iterator_type, ascii::space_type> gram;

    data_t output;
    // parse
    try
    {
        if (!qi::phrase_parse(
                position_begin, position_end,  // iterators over input
                gram,                          // recognize list of doubles
                ascii::space,                  // comment skipper
                output)                        // <-- attribute reference
           )
        {
            std::cerr << "Parse failed at " 
               << position_begin.get_position().file   << ":"
               << position_begin.get_position().line   << ":"
               << position_begin.get_position().column << "\n";
        }
    }
    catch(const qi::expectation_failure<pos_iterator_type>& e)
    {
        const classic::file_position_base<std::string>& pos = e.first.get_position();
        std::stringstream msg;
        msg << "parse error at file " << pos.file
            << " line "               << pos.line
            << " column "             << pos.column
            << "\n\t'"                << e.first.get_currentline()
            << "'\n\t "               << std::string(pos.column, ' ') << "^-- here";

        throw std::runtime_error(msg.str());
    }

    return output;
}

int main()
{
    std::istringstream iss(
            "1, -3.4 ,3.1415926\n"
            ",+inF,-NaN  ,\n"
            "2,-.4,4.14e7\n");

    data_t parsed = parse(iss, "<inline-test>");

    std::cout << "Done, parsed " << parsed.size() << " values ("
        << "min: " << *std::min_element(parsed.begin(), parsed.end()) << ", "
        << "max: " << *std::max_element(parsed.begin(), parsed.end()) << ")\n";
}

c++ - スピリットqiでイテレータを関数に渡す方法

1 に答える 1

http: //liveworkspace.org/code/8a874ef3 ...で実際にご覧ください。

完全なコード

Related

Reference