парсинг на несколько членов вектора

Есть несколько способов 🙂

1. Пользовательские атрибуты
2. То же самое с использованием семантических действий
3. Все в семантических действиях, на уровне детализации

1. Пользовательские атрибуты

Самое чистое, IMO бы заменить адаптацию Fusion Sequence (BOOST_FUSION_ADAPT_STRUCT) по специальным признакам атрибута контейнера для Spirit:

namespace boost { namespace spirit { namespace traits {

template<>
struct is_container<ElemParseData, void> : mpl::true_ { };
template<>
struct container_value<ElemParseData, void> {
typedef boost::variant<float, unsigned int> type;
};
template <>
struct push_back_container<ElemParseData, std::vector<float>, void> {
static bool call(ElemParseData& c, std::vector<float> const& val) {
c.verts.insert(c.verts.end(), val.begin(), val.end());
return true;
}
};
template <>
struct push_back_container<ElemParseData, std::vector<unsigned int>, void> {
static bool call(ElemParseData& c, std::vector<unsigned int> const& val) {
c.idx.insert(c.idx.end(), val.begin(), val.end());
return true;
}
};
}}}

Без изменений в грамматике это просто приведет к тому же эффекту. Тем не менее, теперь вы можете изменить синтаксический анализатор, ожидая нужную грамматику:

    vertex   = 'v' >> qi::double_ >> qi::double_ >> qi::double_;
elements = 'f' >> qi::int_ >> qi::int_ >> qi::int_;

start = *(vertex | elements);

И из-за черт, Дух будет «просто знать», как вставить в ElemParseData, Видеть это жить на Колиру

2. То же самое с использованием семантических действий

Вы можете связать это в семантических действиях:

    start = *(
vertex   [phx::bind(insert, _val, _1)]
| elements [phx::bind(insert, _val, _1)]
);

С insert член типа inserter:

struct inserter {
template <typename,typename> struct result { typedef void type; };

template <typename Attr, typename Vec>
void operator()(Attr& attr, Vec const& v) const { dispatch(attr, v); }
private:
static void dispatch(ElemParseData& data, std::vector<float> vertices) {
data.verts.insert(data.verts.end(), vertices.begin(), vertices.end());
}
static void dispatch(ElemParseData& data, std::vector<unsigned int> indices) {
data.idx.insert(data.idx.end(), indices.begin(), indices.end());
}
};

Это выглядит в значительной степени одинаково, и это делает то же самое: жить на Колиру

3. Все в семантических действиях, на уровне детализации

Это единственное решение, которое не требует никакой сантехники, кроме, возможно, включения boost/spirit/include/phoenix.hpp:

struct objGram : qi::grammar<std::string::const_iterator, ElemParseData(), iso8859::space_type>
{
objGram() : objGram::base_type(start)
{
using namespace qi;

auto add_vertex = phx::push_back(phx::bind(&ElemParseData::verts, _r1), _1);
auto add_index  = phx::push_back(phx::bind(&ElemParseData::idx,   _r1), _1);
vertex   = 'v' >> double_ [add_vertex] >> double_ [add_vertex] >> double_ [add_vertex];
elements = 'f' >> int_    [add_index]  >> int_    [add_index]  >> int_    [add_index] ;

start = *(vertex(_val) | elements(_val));
}

qi::rule<std::string::const_iterator, ElemParseData(), iso8859::space_type> start;
qi::rule<std::string::const_iterator, void(ElemParseData&), iso8859::space_type> vertex, elements;
} objGrammar;

Замечания:

• Один небольшой преимущество здесь было бы что меньше копирование значений
• Недостатком является то, что вы теряете «атомарность» (если линия не удается проанализировать после, скажем, второго значения, первые два значения будут помещены в ElemParseData участники безвозвратно).

В цикле чтения есть ошибка, предпочитайте более простые параметры:

std::filebuf fb;
if (fb.open("parsetest.txt", std::ios::in))
{
ss << &fb;
fb.close();
}

Или посмотрим boost::spirit::istream_iterator