Question

I have a small parser in spirit. The problem is with the attribute rules. The rule should be able to parse both

@ATTRIBUTE num NUMERIC

@ATTRIBUTE test {hello, world}

typedef std::string::iterator string_iter_t;
qi::rule<string_iter_t, string()> ident_r= lexeme['"' >> +(char_("a-zA-Z0-9- ")) >> '"'] | lexeme[+char_("a-zA-Z0-9-")];
qi::rule<string_iter_t, string(), space_type> relation_rule = 
    no_case["@RELATION"] >> ident_r;
qi::rule<string_iter_t, optional<vector<string>>(), space_type> attr_val_rule = 
    no_case["NUMERIC"] |
    ('{' >> ident_r % ',' >> '}');

qi::rule<string_iter_t, tuple<string, optional<vector<string>>>(), space_type> attr_rule =
    no_case["@ATTRIBUTE"] >> ident_r >> attr_val_rule;

When I try to compile using the above code, I am getting a big compile error about a type mismatch with the last rule.

The error goes away when I change the last rule to read

qi::rule<string_iter_t, vector<string>(), space_type> attr_rule =
    no_case["@ATTRIBUTE"] >> ident_r >> attr_val_rule;

But there is a run time error when I try to parse

@ATTRIBUTE test NUMERIC

An assert in boost::optional is triggered because the parameter was not set. I get the following

Assertion failed: this->is_initialized(), file c:\Libs\boost_1_52_0\boost/option
al/optional.hpp, line 630

Can anyone help me understand what I am missing?

The error I get when I compile

c:\Libs\boost_1_52_0\boost/spirit/home/qi/detail/assign_to.hpp(152) : error C244
0: 'static_cast' : cannot convert from 'const std::basic_string<_Elem,_Traits,_A
lloc>' to 'std::tuple<<unnamed-symbol>,_V0_t>'
    with
    [
        _Elem=char,
        _Traits=std::char_traits<char>,
        _Alloc=std::allocator<char>
    ]
    and
    [
        <unnamed-symbol>=std::string,
        _V0_t=boost::optional<std::vector<std::string>>
    ]
    No constructor could take the source type, or constructor overload resol
ution was ambiguous
    c:\Libs\boost_1_52_0\boost/spirit/home/qi/detail/assign_to.hpp(170) : se
e reference to function template instantiation 'void boost::spirit::traits::assi
gn_to_attribute_from_value<Attribute,T>::call<T>(const T_ &,Attribute &,boost::m
pl::false_)' being compiled
    with
    [
        Attribute=std::tuple<std::string,boost::optional<std::vector<std::st
ring>>>,
        T=std::basic_string<char,std::char_traits<char>,std::allocator<char>
>,
        T_=std::basic_string<char,std::char_traits<char>,std::allocator<char
>>
    ] ..... and goes on and on

A copy of the program I am using

    int main(void)
    {
using boost::trim_left;
using boost::istarts_with;
using boost::optional;
namespace qi = boost::spirit::qi;
using qi::no_case;
using qi::ascii::space;
using qi::char_;
using qi::lexeme;
using qi::ascii::space_type;

typedef std::string::iterator string_iter_t;
qi::rule<string_iter_t, string()> ident_r= lexeme['"' >> +(char_("a-zA-Z0-9- ")) >> '"'] | lexeme[+char_("a-zA-Z0-9-")];
qi::rule<string_iter_t, string(), space_type> relation_rule = 
    no_case["@RELATION"] >> ident_r;
qi::rule<string_iter_t, optional<vector<string>>(), space_type> attr_val_rule = 
    no_case["NUMERIC"] |
    ('{' >> ident_r % ',' >> '}');
qi::rule<string_iter_t, vector<string>(), space_type> attr_rule =
    no_case["@ATTRIBUTE"] >> ident_r >> attr_val_rule;
string ss1 = "@ATTRIBUTE test NUMERIC";

vector<string> ans1;
bool ret1 = qi::phrase_parse(ss1.begin(), ss1.end(), attr_rule, space, ans1);
cout << boolalpha << ret1 << endl;

optional<vector<string>> ss;
string ss2 = "{hello, world}";
bool ret2 = qi::phrase_parse(ss2.begin(), ss2.end(), attr_val_rule, space, ss);
cout << ret2 << endl;

return 0;
    }

Answer 1

The workaround posted by Anand works, in a way. However, a much more convenient answer is at hand.

#include <boost/fusion/adapted.hpp>
// or specificly for std::tuple:
#include <boost/fusion/adapted/std_tuple.hpp>

Consider, for example, when you don’t want to, or cannot, change the attribute data types.

Here is a demonstration with a few style issues removed live on http://liveworkspace.org/code/Mwpah.

Output:

=======================================
Trying to parse '@attribute ident1 numeric'
parse success
data: ident1 
=======================================
Trying to parse '@attribute ident2 { field1, field2, field3 }'
parse success
data: ident2 field1 field2 field3 
=======================================
Trying to parse '@attribute ident3 { }'
parse failed: '@attribute ident3 { }'
trailing unparsed: '@attribute ident3 { }'

Full code:

#include <boost/fusion/adapted.hpp>
#include <boost/optional.hpp>
#include <boost/variant.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/karma.hpp>

namespace qi    = boost::spirit::qi;
namespace karma = boost::spirit::karma;

typedef std::string rel_t;
typedef boost::optional<std::vector<std::string>> fields_t;
typedef std::tuple<std::string, fields_t> attr_t;
typedef boost::variant<attr_t, rel_t> parsed_t;

template <typename It, typename Skipper = qi::space_type>
    struct parser : qi::grammar<It, attr_t(), Skipper>
{
    parser() : parser::base_type(attr_rule)
    {
        using namespace qi;

        ident_r       = lexeme // technically redundant since the rule is skipperless
            [
                  ('"' >> +char_("a-zA-Z0-9- ") >> '"') 
                | +char_("a-zA-Z0-9-") 
            ];

        relation_rule = no_case["@RELATION"]      >> ident_r;
        attr_val_rule = no_case["NUMERIC"] | ('{' >> ident_r % ',' >> '}');
        attr_rule     = no_case["@ATTRIBUTE"]     >> ident_r >> attr_val_rule;
        start         = attr_rule | relation_rule;

        BOOST_SPIRIT_DEBUG_NODE(start);
        BOOST_SPIRIT_DEBUG_NODE(attr_rule);
        BOOST_SPIRIT_DEBUG_NODE(attr_val_rule);
        BOOST_SPIRIT_DEBUG_NODE(relation_rule);
        BOOST_SPIRIT_DEBUG_NODE(ident_r);
    }

  private:
    qi::rule<It, std::string()> ident_r;
    qi::rule<It, fields_t(), Skipper> attr_val_rule;
    qi::rule<It, rel_t()   , Skipper> relation_rule;
    qi::rule<It, attr_t()  , Skipper> attr_rule;

    qi::rule<It, parsed_t(), Skipper> start;
};

bool doParse(std::string const& input)
{
    auto f(std::begin(input)), l(std::end(input));

    parser<decltype(f), qi::space_type> p;

    std::cout << "=======================================\n";
    std::cout << "Trying to parse '" << input << "'\n";

    try
    {
        attr_t data;
        bool ok = qi::phrase_parse(f,l,p,qi::space,data);
        if (ok)   
        {
            std::cout << "parse success\n";
            std::cout << "data: " << karma::format_delimited(karma::auto_, ' ', data) << "\n";
        }
        else      std::cerr << "parse failed: '" << std::string(f,l) << "'\n";

        if (f!=l) std::cerr << "trailing unparsed: '" << std::string(f,l) << "'\n";
        return ok;
    } catch(const qi::expectation_failure<decltype(f)>& e)
    {
        std::string frag(e.first, e.last);
        std::cerr << e.what() << "'" << frag << "'\n";
    }

    return false;
}

int main()
{
    assert(true == doParse("@attribute ident1 numeric"));
    assert(true == doParse("@attribute ident2 { field1, field2, field3 }"));
    assert(false== doParse("@attribute ident3 { }"));
    //// enable relation_rule (requires tuple IO streaming for test output)
    // assert(true == doParse("@relation rel1"));
}