Using Boost Spirit Qi qi::iter_pos but can't capture value

Question

I need to track the position of some items in text I'm parsing with Boost Spirit Qi. I found this example and adapted to like so:

#include <iostream>
#include <string>
#include <boost/spirit/home/qi.hpp>
#include <boost/spirit/repository/include/qi_iter_pos.hpp>
#include <boost/spirit/include/phoenix.hpp>

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

template<typename Iterator>
struct CurrentPos 
{
    CurrentPos() 
    {
        save_start_pos = qi::omit[boost::spirit::repository::qi::iter_pos[
                phx::bind(&CurrentPos::setStartPos, this, qi::_1)]];

        current_pos = boost::spirit::repository::qi::iter_pos[
                qi::_val = phx::bind(&CurrentPos::getCurrentPos, this, qi::_1)];
    }

    qi::rule<Iterator> save_start_pos;
    qi::rule<Iterator, std::size_t()> current_pos;

private:
    void setStartPos(const Iterator &iterator) 
    {
        start_pos_ = iterator;
    }

    std::size_t getCurrentPos(const Iterator &iterator) 
    {
        return std::distance(start_pos_, iterator);
    }

    Iterator start_pos_;
};

using InfoTuple = std::tuple<std::size_t, std::uint32_t>;

struct Header
{
    std::uint32_t x;
    InfoTuple y;
};

BOOST_FUSION_ADAPT_STRUCT(
    Header,
    (std::uint32_t, x)
    (InfoTuple, y)
)

template<typename Iterator>
struct HeaderParse
    : boost::spirit::qi::grammar<Iterator, Header()>
{
    HeaderParse()
        : HeaderParse::base_type(_start)
    {
        using boost::spirit::qi::uint_parser;

        _thing = (current_pos.current_pos >> uint_parser<std::uint32_t, 10, 1, 3>());
        _start = current_pos.save_start_pos 
            >> '<' 
            >> uint_parser<std::uint32_t, 10, 1, 3>() 
            >> '>'
            >> _thing;
    }   

    qi::rule<Iterator, InfoTuple()> _thing; 
    qi::rule<Iterator, Header()> _start;

    CurrentPos<Iterator> current_pos;
};

int main()
{
    const std::string d1 = "<13>937";

    const HeaderParse<std::string::const_iterator> parser;
    Header header;

    std::string::const_iterator begin = d1.begin();
    std::string::const_iterator end = d1.end();

    assert(boost::spirit::qi::parse(begin, end, parser, header));
    assert(begin == end);

    std::cout << "x    : " << header.x << std::endl;
    std::cout << "y    : " << std::get<1>(header.y) << std::endl;
    std::cout << "y pos: " << std::get<0>(header.y) << std::endl;
}

When I run it, I see the following output:

$> ./testme
x    : 13
y    : 0
y pos: 4

For some reason it will not capture the value 937.

I tried this on Coliru and at first it didn't compile and now I keep getting "execution expired". See here: https://coliru.stacked-crooked.com/a/724c7fcd296c8803 But that makes me wonder if it's valid. I'm using clang and Coliru is using gcc.

Can someone offer any insight into why this won't work?

Answer 1

You example does not compile for me due to missing Fusion std::tuple integration header (boost/fusion/include/std_tuple.hpp). After adding it the example compiles and outputs the expected results. https://wandbox.org/permlink/wOf8JxnKKeBGCihk

P.S: I would suggest not to bother with calculating offset in your parser, it does not save you anything, storing the iterator itself has the same memory footprint, but less complexity and pain.