# include <iostream>
# include <map>
# include <string>
# include <vector>

# include <boost/assign/std/vector.hpp>
# include <boost/foreach.hpp>
# include <boost/function.hpp>
# include <boost/fusion/include/adapt_struct.hpp>
# include <boost/spirit/include/phoenix_core.hpp>
# include <boost/spirit/include/phoenix_operator.hpp>
# include <boost/spirit/include/phoenix_fusion.hpp>
# include <boost/spirit/include/phoenix_stl.hpp>
# include <boost/spirit/include/phoenix_object.hpp>
# include <boost/spirit/include/qi.hpp>
# include <boost/tokenizer.hpp>
# include <boost/typeof/typeof.hpp>
# include <boost/variant.hpp>

namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
namespace phoenix = boost::phoenix;
using boost::spirit::ascii::space;
using phoenix::at_c;
using namespace qi::labels;
typedef std::string::const_iterator Iter;

struct Data { char val1; char val2; };
BOOST_FUSION_ADAPT_STRUCT(Data,(char, val1)(char, val2));

struct TestGrammar 
: qi::grammar<Iter, std::map<int,Data>(), ascii::space_type>
{
    qi::rule<Iter, std::map<int,Data>(), ascii::space_type> list;
    qi::rule<Iter, Data(), ascii::space_type> value;

    TestGrammar() : TestGrammar::base_type(list) {
        value = qi::char_[ at_c<0>(_val) = _1 ] 
             >> qi::char_[ at_c<1>(_val) = _1 ];
        list = (qi::int_ >> value)[ _val[_1] = _2 ];
    }
};

int main( ) {
    std::string input = "2 c d";
    Iter iter = input.begin(), end = input.end();
    TestGrammar grammar;
    std::map<int,Data> map;
    bool ans = phrase_parse( iter, end, grammar, space, map );

    assert( ans );
    assert( iter == end );
    BOOST_AUTO( it, map.find(2) );
    assert( it != map.end() );
    assert( it->second.val1 == 'c' ); // FAILS!
    assert( it->second.val2 == 'd' ); // FAILS!
}