Boost Karma, reordering struct elements

Question

Say I have a struct like so:

struct MyStruct
{
    int a;
    int b; 
    int c;
}

BOOST_FUSION_ADAPT_STRUCT
(
    MyStruct,
    (int, a)
    (int, b)
    (int, c)
)

And then if I have a simple generator:

struct MyStructGenerator
    : boost::spirit::karma::grammar<boost::spirit::ostream_iterator, MyStruct()>
{
    MyStructGenerator() : MyStructGenerator::base_type(start_)
    {

        namespace bsk = boost::spirit::karma;

        start_ = '<' 
            << bsk::int_
            << ','
            << bsk::int_
            << ','
            << bsk::int_
            << '>';
    }

    ~MyStructGenerator() = default;
    boost::spirit::karma::rule<boost::spirit::ostream_iterator, MyStruct()> start_;
};

And I run the following:

int main()
{
    MyStruct ms = { 3, 2, 1 };
    std::cout << boost::spirit::karma::format(MyStructGenerator(), ms) << std::endl;
}

I, of course, expect to see <3, 2, 1>. What I cannot figure out is how to change the order within the rule? What if I wanted to see <1, 2, 3> or even if I wanted to see <2, 1, 3>?

Also, is there anyway I could do this without BOOST_FUSION_ADAPT_STRUCT?

sehe · Answer 1 · 2018-02-06T16:22:25.877

Q1 What if I wanted to see <1, 2, 3> or even if I wanted to see `<2, 1, 3>`

Just change the adapted order:

Simplified Live On Wandbox:

#include <boost/fusion/adapted/struct.hpp>

struct MyStruct { int a, b, c; };
BOOST_FUSION_ADAPT_STRUCT(MyStruct, a, b, c)

#include <boost/spirit/include/karma.hpp>
namespace bsk = boost::spirit::karma;

template <typename It = boost::spirit::ostream_iterator>
struct MyGen : bsk::grammar<It, MyStruct()> {
    MyGen() : MyGen::base_type(start_) {
        using namespace bsk;
        start_ = '<' << int_ << ',' << int_ << ',' << int_ << '>';
    }
  private:
    bsk::rule<It, MyStruct()> start_;
};

int main() {
    MyGen<> gen;
    std::cout << format(gen, MyStruct { 3, 2, 1 }) << "\n";
}

Prints <3,2,1>, but with

BOOST_FUSION_ADAPT_STRUCT(MyStruct, c, b, a)

Prints <1,2,3>.

Q2 Without Adapting?

Well. I can show you a couple of things that might interest you:

without Karma: Live On Wandbox:

#include <boost/fusion/adapted/struct.hpp>

struct MyStruct { int a, b, c; };
BOOST_FUSION_ADAPT_STRUCT(MyStruct, c, b, a)

#include <iostream>
#include <boost/fusion/include/io.hpp>
#include <boost/fusion/include/as_vector.hpp>
using boost::fusion::as_vector;

int main() {
    MyStruct ms { 3, 2, 1 };
    std::cout << as_vector(ms) << "\n";

    std::cout 
        << boost::fusion::tuple_open("<")
        << boost::fusion::tuple_delimiter(",")
        << boost::fusion::tuple_close(">");

    std::cout << as_vector(ms) << "\n";
}

Prints

(1 2 3)
<1,2,3>

Named adaptations: you can adapt different orders at the same time by using the *_NAMED macros. Here's a demo that shows it both using Fusion IO and the Karma generator.

Note I slightly modified the struct so it's easier to track which field is 'a', 'b' or 'c'.

See it Live On Wandbox:

#include <boost/fusion/adapted/struct.hpp>

struct MyStruct { char a, b, c; };
BOOST_FUSION_ADAPT_STRUCT_NAMED(MyStruct, AsABC, a, b, c)
BOOST_FUSION_ADAPT_STRUCT_NAMED(MyStruct, AsBCA, b, c, a)
BOOST_FUSION_ADAPT_STRUCT_NAMED(MyStruct, AsCBA, c, b, a)

#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/qi.hpp>
namespace bsk = boost::spirit::karma;

template <typename Attr, typename It = boost::spirit::ostream_iterator>
struct MyGen : bsk::grammar<It, Attr()> {
    MyGen() : MyGen::base_type(start_) {
        using namespace bsk;
        start_ = '<' << auto_ << ',' << auto_ << ',' << auto_ << '>';
    }
  private:
    bsk::rule<It, Attr()> start_;
};

#include <iostream>
#include <boost/fusion/include/io.hpp>
#include <boost/fusion/include/as_vector.hpp>
using boost::fusion::as_vector;

template <typename Attr>
void do_tests(Attr const& ms) {
    std::cout << as_vector(ms) << "\n";
    std::cout << format(MyGen<Attr>{}, ms) << "\n";
}

int main() {
    std::cout << boost::fusion::tuple_open("<") << boost::fusion::tuple_delimiter(",") << boost::fusion::tuple_close(">");

    MyStruct ms { 'a', 'b', 'c' };

    using namespace boost::fusion::adapted;
    do_tests(AsABC{ms});
    do_tests(AsCBA{ms});
    do_tests(AsBCA{ms});
}

Prints

<a,b,c>
<a,b,c>
<c,b,a>
<c,b,a>
<b,c,a>
<b,c,a>

Yes you can do without adapting (don't though):

Live On Wandbox (commenting parts because of compiletime limitations)

struct MyStruct { char a, b, c; };

#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix.hpp>
namespace bsk = boost::spirit::karma;
namespace phx = boost::phoenix;

template <typename It = boost::spirit::ostream_iterator>
struct MyGen : bsk::grammar<It, MyStruct()> {
    MyGen() : MyGen::base_type(start_) {
        using boost::proto::deep_copy;
        using namespace bsk;
        auto A = deep_copy(char_[ _1 = phx::bind(&MyStruct::a, _val) ]);
        auto B = deep_copy(char_[ _1 = phx::bind(&MyStruct::b, _val) ]);
        auto C = deep_copy(char_[ _1 = phx::bind(&MyStruct::c, _val) ]);
        start_ =
            '<' << A << ',' << B << ',' << C << '>' << eol <<
            '<' << A << ',' << C << ',' << B << '>' << eol <<
            '<' << B << ',' << A << ',' << C << '>' << eol <<
            '<' << C << ',' << A << ',' << B << '>' << eol <<
            '<' << B << ',' << C << ',' << A << '>' << eol <<
            '<' << C << ',' << B << ',' << A << '>' << eol
            ;
    }
  private:
    bsk::rule<It, MyStruct()> start_;
};

int main() {
    std::cout << format(MyGen<>{}, MyStruct { 'a', 'b', 'c' });
}

Prints

<a,b,c>
<a,c,b>
<b,a,c>
<c,a,b>
<b,c,a>
<c,b,a>

Very thorough answer, as always. [This](http://www.boost.org/libs/spirit/example/karma/reorder_struct.cpp) is another possible approach. — llonesmiz, Feb 06 '18 at 18:30

mkaes · Accepted Answer · 2018-02-06T15:53:27.103

You could simply use phoenix and bind to access the member values. So for your example to swap the member it would be like this:

#include <iostream>
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/phoenix/bind/bind_member_variable.hpp>
using namespace std;
struct MyStruct {
    int a;
    int b; 
    int c;
};

struct MyStructGenerator : boost::spirit::karma::grammar<boost::spirit::ostream_iterator, MyStruct()>
{
    MyStructGenerator() : MyStructGenerator::base_type(start_)
    {
        namespace bsk = boost::spirit::karma;
        start_ = '<' 
            << bsk::int_[bsk::_1 = boost::phoenix::bind(&MyStruct::c, bsk::_val)]
            << ','
            << bsk::int_[bsk::_1 = boost::phoenix::bind(&MyStruct::b, bsk::_val)]
            << ','
            << bsk::int_[bsk::_1 = boost::phoenix::bind(&MyStruct::a, bsk::_val)]
            << '>';
    }

    ~MyStructGenerator() = default;
    boost::spirit::karma::rule<boost::spirit::ostream_iterator, MyStruct()> start_;
};

int main() {
    MyStruct ms = { 3, 2, 1 };
    std::cout << boost::spirit::karma::format(MyStructGenerator(), ms) << std::endl;
}

Wow. I spent too long :) Note however this sample sorts under the one section I labeled "Don't though" in my answer. See also https://stackoverflow.com/questions/8259440/boost-spirit-semantic-actions-are-evil — sehe, Feb 06 '18 at 16:08
@sehe: I know that you should not use `Semantic Actions` but for a quick hack I found them to be very useful. But as always when it comes to spirit/karma your answer is as complete as it only can be ;-) — mkaes, Feb 06 '18 at 16:43

Boost Karma, reordering struct elements

2 Answers2

Q1 What if I wanted to see <1, 2, 3> or even if I wanted to see <2, 1, 3>

Q2 Without Adapting?

Q1 What if I wanted to see <1, 2, 3> or even if I wanted to see `<2, 1, 3>`