#include <boost/spirit/include/qi.hpp>
#include <iostream>
#include <string>
 
namespace qi = boost::spirit::qi;
namespace px = boost::phoenix;
namespace ascii = boost::spirit::ascii;
 
typedef qi::rule<std::string::const_iterator,std::string(),qi::ascii::space_type> RuleType;
 
template <typename Iterator>
struct dynamicParser
  : qi::grammar<Iterator,std::string(), boost::spirit::ascii::space_type>
{
 
    dynamicParser (std::vector<RuleType> rules)
      : dynamicParser::base_type(startRule)
    {
        startRule = rules[0];
	qi::debug (startRule);
    }
 
    RuleType startRule;
};
 
int
main (int argc, char** argv) {
 
  std::vector<RuleType> myRuleVector;
 
  myRuleVector.push_back (RuleType(qi::eps));//This rule is going to get replaced
  myRuleVector.push_back (RuleType(qi::string("Hello")));
  myRuleVector.back().name("Hello");
  myRuleVector.push_back (RuleType(-(qi::string("Hi"))));
  myRuleVector.back().name("Hi");
  myRuleVector.push_back (RuleType(-qi::string("Whats up")));
  myRuleVector.back().name("Whats up");
 
  //Now magically compose a rule *with arbitrary vectorsize*
  //I have no clue how to do this
  //But it should result in:

  myRuleVector[0] = myRuleVector[1] | myRuleVector[2] | myRuleVector[3];
  myRuleVector.at(0) = myRuleVector.at(1);
  for (int i=2; i < 3; i++)
    myRuleVector.at(0) = myRuleVector.at(0).copy() > myRuleVector.at(i);
 
  dynamicParser<std::string::const_iterator> myDynamicParser(myRuleVector);
 
  std::string const s ("Hello Hi");
  std::string attr;
 
  if (qi::phrase_parse (s.begin(), s.end(),myDynamicParser,ascii::space,attr))
    std::cout << "Parse success " << attr << std::endl;
  else
    std::cout << "Parse failed" << std::endl;
 
  return 0;
}