Boost Spirit QI recursive - c++

Question

I must have missed something with the boost::recursive_wrapper thing, I always get an error:
error: no matching function for call to 'boost::tuples::tuple, std::allocator >, client::compare_attr_op_t, std::basic_string, std::allocator >, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>::tuple(client::expression_value&)'
for the line defining the "expression" in the grammar: expression %= attribute_test | boolean_expression;
Any idea?
namespace client {
enum compare_attr_op_t {
cao_eq,
cao_neq
};
enum boolean_op_t {
bo_and,
bo_or,
bo_not
};
struct expression_value;
typedef boost::tuple<std::string, compare_attr_op_t, std::string> attribute_test_value;
typedef boost::tuple< expression_value, boolean_op_t, expression_value > boolean_expression_value;
typedef boost::variant< attribute_test_value, boost::recursive_wrapper<boolean_expression_value> > sub_expression_value;
struct expression_value {
sub_expression_value value;
};
}
BOOST_FUSION_ADAPT_STRUCT(
client::expression_value,
(client::sub_expression_value, value)
)
namespace client {
struct compare_attr_ : qi::symbols<char, compare_attr_op_t>
{
compare_attr_()
{
add
("=" , cao_eq)
("!=" , cao_neq)
;
}
} compare_attr;
struct boolean_op_ : qi::symbols<char, boolean_op_t>
{
boolean_op_()
{
add
("&" , bo_and)
("|" , bo_or)
;
}
} boolean_op;
template <typename Iterator>
struct attribute_conditions : qi::grammar<Iterator, expression_value(), ascii::space_type>
{
attribute_conditions() : attribute_conditions::base_type(expression)
{
using qi::eps;
using qi::lit;
using qi::_val;
using qi::lexeme;
using qi::_1;
using qi::_2;
using qi::_3;
using ascii::char_;
using ascii::alnum;
using ascii::alpha;
expression %= attribute_test | boolean_expression;
boolean_expression %= expression >> boolean_op >> expression;
attribute_test %= (attribute_name >> compare_attr >> attribute_value)[std::cout << _1 << ' ' << _2 << ' ' << _3];
attribute_name %= alpha >> *alnum;
attribute_value %= lexeme['"' > +(char_ - '"') > '"'];
}
qi::rule<Iterator, expression_value(), ascii::space_type> expression;
qi::rule<Iterator, boolean_expression_value(), ascii::space_type> boolean_expression;
qi::rule<Iterator, attribute_test_value(), ascii::space_type> attribute_test;
qi::rule<Iterator, std::string(), ascii::space_type> attribute_name;
qi::rule<Iterator, std::string(), ascii::space_type> attribute_value;
};
}

Answer 1

I threw it all and started from scratch, giving me this nice and working implementation:
namespace client {
enum compare_attr_op_t {
cao_eq,
cao_neq
};
enum boolean_op_t {
bo_and,
bo_or,
bo_not
};
struct expression_value;
struct or_op_value;
struct and_expression_value;
struct and_op_value;
struct not_op_value;
typedef boost::tuple<std::string, compare_attr_op_t, std::string> attribute_test_value;
typedef boost::variant<attribute_test_value, boost::recursive_wrapper<expression_value>, boost::recursive_wrapper<not_op_value> > node_value;
struct not_op_value {
boolean_op_t operation;
node_value rnode;
};
struct and_op_value {
boolean_op_t operation;
node_value rnode;
};
struct and_expression_value {
node_value lnode;
std::vector<and_op_value> ops;
};
struct or_op_value {
boolean_op_t operation;
and_expression_value rnode;
};
struct expression_value {
and_expression_value lnode;
std::vector<or_op_value> ops;
};
}
BOOST_FUSION_ADAPT_STRUCT(
client::not_op_value,
(client::boolean_op_t, operation)
(client::node_value, rnode)
)
BOOST_FUSION_ADAPT_STRUCT(
client::and_expression_value,
(client::node_value, lnode)
(std::vector<client::and_op_value>, ops)
)
BOOST_FUSION_ADAPT_STRUCT(
client::and_op_value,
(client::boolean_op_t, operation)
(client::node_value, rnode)
)
BOOST_FUSION_ADAPT_STRUCT(
client::expression_value,
(client::and_expression_value, lnode)
(std::vector<client::or_op_value>, ops)
)
BOOST_FUSION_ADAPT_STRUCT(
client::or_op_value,
(client::boolean_op_t, operation)
(client::and_expression_value, rnode)
)
namespace client {
struct compare_attr_ : qi::symbols<char, compare_attr_op_t>
{
compare_attr_()
{
add
("=" , cao_eq)
("!=" , cao_neq)
;
}
} compare_attr;
struct boolean_op_and_t : qi::symbols<char, boolean_op_t>
{
boolean_op_and_t()
{
add
("&" , bo_and)
("and" , bo_and)
;
}
} boolean_op_and;
struct boolean_op_or_t : qi::symbols<char, boolean_op_t>
{
boolean_op_or_t()
{
add
("|" , bo_or)
("or" , bo_or)
;
}
} boolean_op_or;
struct boolean_op_not_t : qi::symbols<char, boolean_op_t>
{
boolean_op_not_t()
{
add
("!" , bo_not)
("not" , bo_not)
;
}
} boolean_op_not;
template <typename Iterator>
struct attribute_conditions : qi::grammar<Iterator, expression_value(), ascii::space_type>
{
attribute_conditions() : attribute_conditions::base_type(expression)
{
using qi::eps;
using qi::lit;
using qi::_val;
using qi::lexeme;
using qi::_1;
using qi::_2;
using qi::_3;
using ascii::char_;
using ascii::alnum;
using ascii::alpha;
using ascii::no_case;
expression %= and_expression >> *(no_case[boolean_op_or] >> and_expression);
and_expression %= node >> *(no_case[boolean_op_and] >> node);
node %= attribute_test | ('(' >> expression >> ')') | not_operation;
not_operation %= no_case[boolean_op_not] >> node;
attribute_test %= (attribute_name >> no_case[compare_attr] >> attribute_value);
attribute_name %= alpha >> *char_("A-Za-z0-9_");
attribute_value %= lexeme['"' > +(char_ - '"') > '"'];
}
qi::rule<Iterator, expression_value(), ascii::space_type> expression;
qi::rule<Iterator, and_expression_value(), ascii::space_type> and_expression;
qi::rule<Iterator, not_op_value(), ascii::space_type> not_operation;
qi::rule<Iterator, node_value(), ascii::space_type> node;
qi::rule<Iterator, attribute_test_value(), ascii::space_type> attribute_test;
qi::rule<Iterator, std::string(), ascii::space_type> attribute_name;
qi::rule<Iterator, std::string(), ascii::space_type> attribute_value;
};
}

Answer 2

This compiles OK for me using the following includes in Visual Studio C++ 2010/Boost 1.36.0. Possibly your compiler cannot handle the templates here.
#include <boost/tuple/tuple.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/adapted.hpp>
using namespace boost::spirit;