1

I am trying to debug a simple struct which contains an enum class with BOOST_SPIRIT_DEBUG_NODE, but I always get the compile error "C:\boost\boost\spirit\home\support\attributes.hpp:1226: error: cannot bind 'std::basic_ostream' lvalue to 'std::basic_ostream&&' near 'out << val;'"

I don't know why I get a rvalue error like that, I tried to to add a manual overload for the operator<< for the enum class but that didn't work either.

I am using boost 1.55 and try to compile with gcc 4.8 with MinGW 32-bit on Windows 8.1 x64.

When I change the enum class to a default c++ enum it works, but I'd like to use the new enum classes for proper namespace handling.

Xander
  • 687
  • 9
  • 15
  • You get "rvalues like that" just because the compiler will typically list all candidate overloads of `operator<<`. – sehe Jan 17 '14 at 22:17

1 Answers1

3

I don't know why I get a rvalue error like that, I tried to to add a manual overload for the operator<< for the enum class but that didn't work either.

I think that required code, since that does work:

  1. First, with a classic enum Live on Coliru

    #define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <iostream>

namespace qi    = boost::spirit::qi;

struct data_t
{
    std::string label;
    enum Choice { left, right, up, down } choice;

    data_t(std::string label="default", Choice choice=left): label(std::move(label)), choice(choice) {}

    friend std::ostream& operator<<(std::ostream& os, Choice const& v) {
        switch(v) { 
            case left: return os << "left";
            case right:return os << "right";
            case up:   return os << "up";
            case down: return os << "down";
            default:   return os << "?";
        }
    }
    friend std::ostream& operator<<(std::ostream& os, data_t const& v) {
        return os << "{label:" << v.label << ";choice:" << v.choice << "}";
    }
};


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

        choice_.add
            ("left",  data_t::left)
            ("right", data_t::right)
            ("up",    data_t::up)
            ("down",  data_t::down);

        start %= as_string[ lexeme[+graph] ] >> lexeme [choice_];

        BOOST_SPIRIT_DEBUG_NODE(start);
    }

private:
    qi::symbols<char, data_t::Choice> choice_;
    qi::rule<It, data_t(), Skipper> start;
};

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

    parser<It, qi::space_type> p;
    data_t data;

    try
    {
        bool ok = qi::phrase_parse(f,l,p,qi::space,data);
        if (ok)   
        {
            std::cout << "parse success\n";
            std::cout << "data: " << 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<It>& e)
    {
        std::string frag(e.first, e.last);
        std::cerr << e.what() << "'" << frag << "'\n";
    }

    return false;
}

int main()
{
    bool ok = doParse("label1 up");
    return ok? 0 : 255;
}

  2. Second with an enum class Live on Coliru

    #define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
#include <iostream>

namespace qi    = boost::spirit::qi;

struct data_t
{
    std::string label;
    enum class Choice { left, right, up, down } choice;

    data_t(std::string label="default", Choice choice=Choice::left): label(std::move(label)), choice(choice) {}

    friend std::ostream& operator<<(std::ostream& os, Choice const& v) {
        switch(v) { 
            case Choice::left: return os << "left";
            case Choice::right:return os << "right";
            case Choice::up:   return os << "up";
            case Choice::down: return os << "down";
            default:   return os << "?";
        }
    }
    friend std::ostream& operator<<(std::ostream& os, data_t const& v) {
        return os << "{label:" << v.label << ";choice:" << v.choice << "}";
    }
};


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

        choice_.add
            ("left",  data_t::Choice::left)
            ("right", data_t::Choice::right)
            ("up",    data_t::Choice::up)
            ("down",  data_t::Choice::down);

        start %= as_string[ lexeme[+graph] ] >> lexeme [choice_];

        BOOST_SPIRIT_DEBUG_NODE(start);
    }

private:
    qi::symbols<char, data_t::Choice> choice_;
    qi::rule<It, data_t(), Skipper> start;
};

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

    parser<It, qi::space_type> p;
    data_t data;

    try
    {
        bool ok = qi::phrase_parse(f,l,p,qi::space,data);
        if (ok)   
        {
            std::cout << "parse success\n";
            std::cout << "data: " << 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<It>& e)
    {
        std::string frag(e.first, e.last);
        std::cerr << e.what() << "'" << frag << "'\n";
    }

    return false;
}

int main()
{
    bool ok = doParse("label1 up");
    return ok? 0 : 255;
}

My guess is you forgot to add serialization to either your enum or your struct.

sehe
  • 374,641
  • 47
  • 450
  • 633
  • thanks that worked. I tried to define the operator<< outside of the struct but still got the same error. I think I have to use it like that with frend but thats fine. :) – Xander Jan 17 '14 at 23:03
  • 1
    @Xander your problem then will have been that the operator wasn't visible at the time. Two reasons: it was declared after the relevant instantiations _or_ outside the namespace that defined the `struct` or the `enum class`. In fact, the latter seems likely to me. – sehe Jan 17 '14 at 23:19