Spirit Grammar To break Up a String by Number of Characters

Question

I am working on learning to write spirit grammars and I am trying to create a basic base 16 to base 64 converter that takes in a string representing hex, for example:

49276d206b696c

parse out 6 or less characters (less if the string isn't a perfect multiple of 6) and generate a base 64 encoded string from the input. One grammar I figured would probably work is something like this:

// 6 characters 
`(qi::char_("0-9a-fA-F") >> qi::char_("0-9a-fA-F") >> 
 qi::char_("0-9a-fA-F") >> qi::char_("0-9a-fA-F") >>
 qi::char_("0-9a-fA-F") >> qi::char_("0-9a-fA-F")[/*action*/]) | 


// or 5 characters
(qi::char_("0-9a-fA-F") >> qi::char_("0-9a-fA-F") >> 
qi::char_("0-9a-fA-F") >> qi::char_("0-9a-fA-F") >> 
qi::char_("0-9a-fA-F")[/*action*/]) | ...`

etc.... all the way down to one character, Or having a different rule defined for each number of characters, but I think there must be a better way to specify the grammar. I read about spirit repeat and was thinking maybe I could do something like +(boost::spirit::repeat(1, 6)[qi::char_("0-9a-fA-F")][/*action on characters*/]) however the compiler throws an error on this, because of the sematic action portion of the grammar. Is there a simpler way to specify a grammar to operate on exactly 6 or less characters at a time?

Edit Here is what I have done so far... base16convertergrammar.hpp

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>    

#include <string>
#include <iostream>

namespace grammar {
    namespace qi = boost::spirit::qi;

    void toBase64(const std::string& p_input, std::string& p_output)
    {   
        if (p_input.length() < 6)
        {   
            // pad length
        }   

        // use back inserter and generator to append to end of p_output.
    }   

    template <typename Iterator>
    struct Base16Grammar : qi::grammar<Iterator, std::string()>
    {
        Base16Grammar() : Base16Grammar::base_type(start, "base16grammar"),
            m_base64String()
        {
            // get six characters at a time and send them off to be encoded
            // if there is less than six characters just parse what we have
            start = +(boost::spirit::repeat(1, 6)[qi::char_("0-9a-fA-F")][boost::phoenix::bind(toBase64, qi::_1,
                boost::phoenix::ref(m_base64String))]);
        }

        qi::rule<Iterator, std::string()> start;

        std::string m_base64String;
    };
}

And here is the usage... base16converter.cpp

#include "base16convertergrammar.hpp"

const std::string& convertHexToBase64(const std::string& p_hexString)
{
    grammar::Base16Grammar<std::string::const_iterator> g;
    bool r = boost::spirit::qi::parse(p_hexString.begin(), p_hexString.end(), g); 
}


int main(int argc, char** argv)
{
    std::string test("49276d206b696c6c");
    convertHexToBase64(test);
}

Answer 1

First of all, repeat()[] exposes a vector, so vector<char>, not a string.

void toBase64(const std::vector<char>& p_input, std::string& p_output)

Secondly, please don't do all that work. You don't tell us what the input means, but as long as you want to group it in sixes, I'm assuming you want them interpreted as /something/. You could e.g. use the int_parser:

Live On Coliru

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>    

#include <string>
#include <iostream>

namespace grammar {
    namespace qi = boost::spirit::qi;
    namespace px = boost::phoenix;

    template <typename Iterator>
    struct Base16Grammar : qi::grammar<Iterator, std::string()>
    {
        Base16Grammar() : Base16Grammar::base_type(start, "base16grammar")
        {
            start = +qi::int_parser<uint64_t, 16, 1, 6>() [ qi::_val += to_string(qi::_1) + "; " ];
        }

      private:
        struct to_string_f { template <typename T> std::string operator()(T const& v) const { return std::to_string(v); } };
        px::function<to_string_f> to_string;

        qi::rule<Iterator, std::string()> start;
    };
}

std::string convertHexToBase64(const std::string& p_hexString)
{
    grammar::Base16Grammar<std::string::const_iterator> g;
    std::string result;
    bool r = boost::spirit::qi::parse(p_hexString.begin(), p_hexString.end(), g, result); 
    assert(r);
    return result;
}

int main()
{
    for (std::string test : {"49276d206b696c6c"})
        std::cout << test << " -> " << convertHexToBase64(test) << "\n";
}

Prints

49276d206b696c6c -> 4794221; 2124649; 27756;