Russian Qt Forum

• зачем переопределять конструкор копии и оператор присваивания, чем сгенерированные по умолчанию не подходят?
• зачем жестко привязываться к std::basic_string, вроде бы такая обертка возможна для любого bidirectional итератора?
• почему бы не отслеживать текущий элемент в _comments_list и не делать линейный поиск в ++/-- ?
• почему в == не сравниваются begin/end?

C++ (Qt)
    tex_string_iterator<char> iter(buffer.begin(), buffer.end(), expr);
    tex_string_iterator<char> end(buffer.end(), buffer.end(), expr);
 
    for (; iter != end; ++iter) { // У iter и у end не совпадают диапазоны 
        std::cout << *iter;
    }
 

C++ (Qt)
#include <list>
#include <iterator>
#include <boost/regex.hpp>
#include <boost/range/istream_range.hpp>
#include <algorithm>
 
template <class BidirectIter, class Traits = std::iterator_traits<BidirectIter>>
class tex_iterator
{
public:
    typedef BidirectIter iterator;
    typedef typename Traits::value_type value_type;
    typedef typename Traits::pointer pointer;
    typedef typename Traits::reference reference;
    typedef typename Traits::difference_type difference_type;
    typedef typename std::bidirectional_iterator_tag iterator_category;
 
 
    typedef boost::basic_regex<value_type> regex_type;
 
    tex_iterator(iterator begin, iterator end, const regex_type & comment)
        : _begin(begin), _end(end), _it(begin), _comment(comment)
    {
        make_comments_list();
        if (_comments_list.begin()->begin() == _begin)
            ++*this;
    }
 
    tex_iterator() {}
 
    reference operator*() const { return *_it; }
 
    pointer operator->() const { return _it; }
 
    tex_iterator<BidirectIter, Traits>& operator++() {
        auto cur = _it;
        ++_it;
        for (const auto & comment : _comments_list) {
            if ((comment.begin() == _it) || (comment.begin() == cur)) {
                _it = comment.end();
                if (_it == _end)
                    break;
                ++_it;
            }
        }
 
        return *this;
    }
 
    tex_iterator<BidirectIter, Traits> operator++(int) {
        tex_iterator<BidirectIter, Traits> tmp = *this;
        ++*this;
        return tmp;
    }
 
    tex_iterator<BidirectIter, Traits>& operator--() {
        auto cur = _it;
        --_it;
        for (const auto & comment : _comments_list) {
            if ((comment.end() == _it) || (comment.end() == cur)) {
                _it = comment.begin();
                if (_it == _begin)
                    break;
                --_it;
            }
        }
 
        return *this;
    }
 
    tex_iterator<BidirectIter, Traits> operator--(int) {
        tex_iterator<BidirectIter, Traits> tmp = *this;
        --*this;
        return tmp;
    }
 
    template <class It, class T>
    friend bool operator==(const tex_iterator<It, T> &, const tex_iterator<It, T> &);
 
    template <class It, class T>
    friend bool operator!=(const tex_iterator<It, T> &, const tex_iterator<It, T> &);
 
private:
    iterator _begin;
    iterator _end;
    iterator _it;    //current iterator
    regex_type _comment;
    std::list<boost::iterator_range<iterator>> _comments_list;
 
    void make_comments_list() {
        if (_begin == _end)
            return;
 
        auto first = _begin;
        boost::match_results<iterator> what;
        while (boost::regex_search(first, _end, what, _comment)) {
            _comments_list.push_back(boost::iterator_range<iterator>(what[1].first, what[1].second));
            first = what[1].second;
        }
    }
};
 
template<class It, class T>
inline bool operator==(const tex_iterator<It, T> & x, const tex_iterator<It, T> & y) {
    return (x._it == y._it);
}
 
template<class It, class T>
inline bool operator!=(const tex_iterator<It, T> & x, const tex_iterator<It, T> & y) {
    return !(x == y);
}
 

C++ (Qt)
    std::string str = "text1, #commented text\n text3,";
 
    tex_iterator<std::string::const_iterator> it(str.begin(), str.end(), boost::regex("(#[^\n]*)"));
    tex_iterator<std::string::const_iterator> end(str.end(), str.end(), boost::regex("(#[^\n]*)"));
 
    for (; it != end; ++it)
        std::cout << *it;
 

tex_string_iterator<char> ibegin(buffer.begin(), buffer.end(), '%', '\n');

C++ (Qt)
   boost::regex expr("(#[^\\n\\r]*)");
 
    std::string buffer = "AA, BB, C#DD, F\n++, D #Perl\r";
 
    tex_iterator<std::string::const_iterator> iter(buffer.begin(), buffer.end(), expr);
    tex_iterator<std::string::const_iterator> end(buffer.end(), buffer.end(), expr);
 
    for (; iter != end; ++iter)
        std::cout << *iter;
 

C++ (Qt)
tex_iterator<std::string::const_iterator> iter(buffer.begin(), buffer.end(), expr);

C++ (Qt)
EnumServicesStatus(hSCM,SERVICE_WIN32, SERVICE_STATE_ALL, (LPENUM_SERVICE_STATUS)&Status, Size, &Needed, &Return, &Handle)

C++ (Qt)
boost::asio::async_write(socket_, boost::asio::buffer(data_, bytes_transferred), boost::bind(&session::handle_write, this, boost::asio::placeholders::error));

Bash
@article{PhysRevD.89.072015,
  title = {Updated cross section measurement of <span class="aps-inline-formula">
<math display="inline"><mrow><msup><mrow><mi>e</mi></mrow><mrow><mo>+</mo>
</mrow></msup><msup><mrow><mi>e</mi></mrow><mrow><mo>−</mo></mrow></msup>
<mo stretchy="false">→</mo><msup><mrow><mi>K</mi></mrow><mrow><mo>+</mo></mrow>
</msup><msup><mrow><mi>K</mi></mrow><mrow><mo>−</mo></mrow></msup><mi>J</mi>
<mo stretchy="false">/</mo><mi>ψ</mi></mrow></math></span> and <span class="aps-inline-formula">
<math display="inline"><mrow><msubsup><mrow><mi>K</mi></mrow><mrow><mi>S</mi></mrow>
<mrow><mn>0</mn></mrow></msubsup><msubsup><mrow><mi>K</mi></mrow><mrow><mi>S</mi>
</mrow><mrow><mn>0</mn></mrow></msubsup><mi>J</mi><mo stretchy="false">/</mo><mi>ψ</mi></mrow></math></span> via initial state radiation at Belle},
 
  author = {Shen, C.\,P. and Yuan, C.\,Z. and Wang, P. and Abdesselam, A. and Adachi, I. 
and Aihara, H. and Al Said, S. and Asner, D.\,M. and Aulchenko, V. and Aushev, T. and Ayad, R. 
and Bakich, A.\,M. and Bala, A. and Bobrov, A. and Bonvicini, G. and Bozek, A. 
and Bra\ifmmode \check{c}\else \v{c}\fi{}ko, M. and Browder, T.\,E. and Chekelian, V. and 
Chen, A. and Cheon, B.\,G. and Chilikin, K. and Chistov, R. and Cho, K. and Chobanova, V. and 
Choi, S.-K. and Choi, Y. and Cinabro, D. and Dalseno, J. and Danilov, M. and Dole\ifmmode \check{z}\else \v{z}\fi{}al, Z. 
and Drutskoy, A. and Dutta, D. and Eidelman, S. and Epifanov, D. and Farhat, H. and Fast, J.\,E. and Ferber, T. and Frey, A. 
and Gaur, V. and Ganguly, S. and Gillard, R. and Glattauer, R. and Goh, Y.\,M. and Golob, B. and Haba, J. and Hayasaka, K. and Hayashii, H. and He, X.\,H. and Hoshi, Y. and Hou, W.-S. and Hsiung, Y.\,B. and Hyun, H.\,J. and Iijima, T. and Ishikawa, A. and Itoh, R. and Iwasaki, Y. and Joffe, D. and Julius, T. and Kang, J.\,H. 
and Kato, E. and Kawasaki, T. and Kiesling, C. and Kim, D.\,Y. and Kim, H.\,J. and Kim, J.\,B. and Kim, J.\,H. 
and Kim, K.\,T. and Kim, M.\,J. and Kim, Y.\,J. and Kinoshita, K. and Ko, B.\,R. 
and Kody\ifmmode \check{s}\else \v{s}\fi{}, P. and Korpar, S. and Kri\ifmmode \check{z}\else \v{z}\fi{}an, P. and Krokovny, P. and Kuzmin, A. and Kwon, Y.-J. and Lee, S.-H. and Li, J. and Li Gioi, L. and Libby, J. and Liu, C. and Liu, Z.\,Q. and Lukin, P. 
and Matvienko, D. and Miyabayashi, K. and Miyata, H. and Mizuk, R. and Moll, A. and Mussa, R. and Nagasaka, Y. and Nakano, E. and Nakao, M. and Natkaniec, Z. and Nayak, M. and Nedelkovska, E. and Nisar, N.\,K. and Nishida, S. and Nitoh, O. and Okuno, S. and Park, C.\,W. and Park, H. 
and Pedlar, T.\,K. and Pestotnik, R. and Petri\ifmmode \check{c}\else \v{c}\fi{}, M. and Piilonen, L.\,E. and Ritter, M. 
and R\"ohrken, M. and Rostomyan, A. and Ryu, S. and Saito, T. and Sakai, Y. and Sanuki, T. and Sato, Y. and Schneider, O. 
and Schnell, G. and Semmler, D. and Senyo, K. 
and Seon, O. and Sevior, M.\,E. and Shapkin, M. and Shebalin, V. and Shibata, T.-A. and Shiu, J.-G. 
and Shwartz, B. and Sibidanov, A. and Simon, F. and Sohn, Y.-S. and Sokolov, A. and Solovieva, E. and Stani\ifmmode \check{c}\else \v{c}\fi{}, S. 
and Stari\ifmmode \check{c}\else \v{c}\fi{}, M. and Steder, M. and Sumiyoshi, T. and Tamponi, U. 
and Tatishvili, G. and Teramoto, Y. and Uchida, M. and Unno, Y. and Uno, S. and Urquijo, P. and Usov, Y. 
and Van Hulse, C. and Vanhoefer, P. and Varner, G. 
and Vorobyev, V. and Wagner, M.\,N. and Wang, C.\,H. and Watanabe, M. and Watanabe, Y. and Williams, K.\,M. and Won, E. and Yamamoto, H. 
and Yamashita, Y. and Yashchenko, S. and Yook, Y. and Zhang, C.\,C. and Zhang, Z.\,P. and Zhulanov, V. and Zupanc, A.},
 
 
  collaboration = {(Belle Collaboration)},
  journal = {Phys. Rev. D},
  volume = {89},
  issue = {7},
  pages = {072015}, %commented text, commented text,  
  numpages = {9},
  year = {2014},
  month = {Apr},
  publisher = {American Physical Society},
%  doi = {10.1103/PhysRevD.89.072015},
%  url = {http://link.aps.org/doi/10.1103/PhysRevD.89.072015},
}
 

C++ (Qt)
#ifndef BIBTEX_PARSER_H
#define BIBTEX_PARSER_H
 
#include <string>
 
#include <boost/algorithm/string/case_conv.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/regex.hpp>
#include <boost/tokenizer.hpp>
 
#include "core/spec_token_functions.h"
#include "core/tex_iterator.h"
#include "core/bibtex_entry.h"
 
namespace bibmake {
 
namespace core {
 
class bibtex_parser
{
public:
    typedef std::string string_type;
 
    template <class Iterator>
    static bool parse(Iterator begin, Iterator end, const string_type & key, bibtex_entry & entry)
    {
        static const boost::regex comment_regex("[^\\\\](%[^\\n\\r]*)");
 
        tex_iterator<Iterator> _begin(begin, end, comment_regex);
        tex_iterator<Iterator> _end(end, end, comment_regex);
 
        boost::match_results<tex_iterator<Iterator>> what;
        boost::regex regex("@(\\w+)[\\s\\t]*\\{[\\s\\t]*"+key);
 
        if (!boost::regex_search(_begin, _end, what, regex))
            return false;
 
        entry.set_key(key);
        entry.set_type(what.str(1));
 
        _begin = what[0].first;
 
        quote_list<char> quotes('{', '}');
        quotes.add_quote('"', '"');
 
        quote_extractor<char> qextractor(quotes);
        string_type _entry;
 
        if (!qextractor(_begin, _end, _entry))
            return false;
 
        boost::tokenizer<spec_char_separator<char>> tok(_entry, spec_char_separator<char>(",", "", quotes));
 
        regex.assign("[\\s\\t]*(\\w+)[\\s\\t]*=(.+)");
 
        for (auto s : tok)
        {
            boost::smatch w;
            if (boost::regex_search(s, w, regex))
            {
                string_type tag = boost::algorithm::to_lower_copy(w.str(1));
                string_type content = w.str(2);
                auto first = w[2].first;
                auto second = w[2].second;
                qextractor(first, second, content);
                boost::algorithm::trim(content);
                if (!content.empty())
                    entry.add_field(tag, content);
            }
        }
 
        return true;
    }
 
};
 
} /* namespace core */
 
} /* namespace bibmake */
 
#endif // BIBTEX_PARSER_H
 

C++ (Qt)
void CBib::ReadFile( CReader & reader )
{
 while (reader.GetNextLine()) {
   switch (GetBibType(reader.mLine)) {
     case type_None:
       continue;
 
     case type_Book:
      mItems.push_back(new CBook());
      mItems.back()->Read(reader);
      break;
    ...
   }
 }
}

C++ (Qt)
struct bibtex_entry 
{
    std::string citation_key; // for example: @article{citation_key, ...
 
    std::string type; // article, book, inbook, etc.
 
    std::map<std::string, std::string> fields // tag = content
};
 

C++ (Qt)
#include <string>
#include <map>
#include <fstream>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/include/support_istream_iterator.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/std_pair.hpp>
#include <boost/operators.hpp>
 
using namespace std;
using namespace boost::spirit;
namespace ph = boost::phoenix;
namespace sn = boost::spirit::standard_wide;
 
// ===================================================================================
 
typedef string			String;
typedef pair<String, String>	Field;
typedef map<String, String>	FieldList;
 
struct Entry
{
	String		type;			// article, book, inbook, etc.
	String		citation_key;	// for example: @article{citation_key, ...
	FieldList	fields;			// tag = content
 
	void	dump()
	{
		cout << "-------------------------------------" << endl
			 << "Type: " << type << endl
			 << "Key : " << citation_key << endl;
		for( auto v : fields )
			cout << v.first << " = " << v.second << endl;
	}
};
 
BOOST_FUSION_ADAPT_STRUCT(
	Entry,
	(String,	type)
	(String,	citation_key)
	(FieldList,	fields)
)
 
// ===================================================================================
template <class ForwardIterator, class Skipper>
class Parser : public qi::grammar<ForwardIterator, Entry(), Skipper>
{
public:
	Parser() : Parser::base_type( m_start, "Parser" )
	{
		// Документ может состоять из мусора и записей
		m_start = m_junk >> m_entry;
 
		// Мусор это любые символы кроме @
		m_junk = *~qi::lit( '@' );
		// Запись начинается с @ и содержит тип записи и тело, которое находится между {}
		m_entry = '@' >>
					m_type[ ph::at_c<0>( _val ) = _1 ] >>
					'{' >> m_body[ ph::at_c<1>( _val ) = ph::at_c<0>( _1 ), ph::at_c<2>( _val ) = ph::at_c<1>( _1 ) ] >> '}';
 
		// Тип это несколько букв и/или цифр
		m_type = +sn::alnum;
		// Тело содержит ключ и набор полей
		m_body = m_citation_key >> ',' >> m_fields >> -qi::lit( ',' );
 
		// Ключ это любые символы до запятой
		m_citation_key = qi::lexeme[ +(~qi::char_( ',' ) - sn::space) ];
		// Набор полей состояит из нескольких полей
		m_fields = -( m_field % ',' );
 
		// Поле содержит ключ и значение
		m_field = m_key >> '=' >> m_value;
 
		m_key = qi::lexeme[ +(~qi::char_( "=,})" ) - sn::space) ];
		m_value = m_quoted | +~qi::char_( ",})#" );
 
		m_quoted = qi::lexeme[ ( '"' >> *m_innerQuoteText >> '"' ) | ( '{' >> *m_innerBraceText >> '}' ) ]
							 [ _val = ph::accumulate(_1, ph::construct<std::string>()) ];
 
		m_innerQuoteText %= qi::as_string[ qi::char_('{') >> *(m_innerQuoteText | m_escapedText) >> qi::char_('}') ] | m_quoteText;
		m_innerBraceText %= qi::as_string[ qi::char_('{') >> *(m_innerBraceText | m_escapedText) >> qi::char_('}') ] | m_escapedText;
 
		m_quoteText = +( m_escapedQuote | ~qi::char_("\"{}") );
		m_escapedText = !qi::lit('{') >> +( m_escapedBrace | ~qi::char_("{}") );
 
		m_escapedBrace.add
			("\\{", '{')
			("\\}", '}')
			;
		m_escapedQuote.add
			("\\\"", '"')
			;
	}
 
private:
	typedef boost::fusion::vector<String,FieldList>	BodyParam;
 
	qi::symbols<char, char>					m_escapedBrace;
	qi::symbols<char, char>					m_escapedQuote;
 
	qi::rule<ForwardIterator, Entry(),	Skipper>	m_start;
	qi::rule<ForwardIterator,		Skipper>	m_junk;
	qi::rule<ForwardIterator, Entry(),	Skipper>	m_entry;
	qi::rule<ForwardIterator, String(),	Skipper>	m_type;
	qi::rule<ForwardIterator, BodyParam(),	Skipper>	m_body;
	qi::rule<ForwardIterator, String(),	Skipper>	m_citation_key;
	qi::rule<ForwardIterator, FieldList(),	Skipper>	m_fields;
	qi::rule<ForwardIterator, Field(),	Skipper>	m_field;
	qi::rule<ForwardIterator, String(),	Skipper>	m_key;
	qi::rule<ForwardIterator, String(),	Skipper>	m_value;
	qi::rule<ForwardIterator, String(),	Skipper>	m_quoted;
	qi::rule<ForwardIterator, String()>			m_innerQuoteText;
	qi::rule<ForwardIterator, String()>			m_innerBraceText;
	qi::rule<ForwardIterator, String()>			m_quoteText;
	qi::rule<ForwardIterator, String()>			m_escapedText;
};
 
// ===================================================================================
 
template<class ForwardIterator, class Skipper, class Container>
inline bool read( ForwardIterator first, ForwardIterator last, Skipper& s, Container& e,
				  boost::enable_if<boost::is_same<typename Container::value_type, Entry> >* /*dummy*/ = NULL )
{
	Parser<ForwardIterator, Skipper> p;
	return qi::phrase_parse(first, last, *p, s, e );
}
 
// ===================================================================================
 
int main( int argc, char *argv[] )
{
	if( argc < 2 )
	{
		cerr << "Using: bibparser file.bib" << endl;
		return 1;
	}
 
	string filename = argv[ 1 ];
	cout << "Parsing file: " << filename << endl;
 
	ifstream is( filename );
	is.unsetf( ios_base::skipws );
	if( !is )
	{
		cerr << "Error open source file" << endl;
		return 1;
	}
 
	boost::spirit::istream_iterator beg( is );
	boost::spirit::istream_iterator end;
 
	deque<Entry> e;
 
	auto space = sn::space | '%' >> *(qi::char_ - qi::eol) >> qi::eol;
 
	cout << "result = " << read( beg, end, space, e ) << endl;
 
	for( auto v : e )
		v.dump();
 
	return 0;
}
 

C++ (Qt)
int main()
{
 
    const char * filename = "bibliography.bib";
 
    std::ifstream in(filename);
    std::ostringstream oss;
    oss << in.rdbuf();
 
    std::string buff = oss.str();
    std::list<bibtex_entry> entrys;
 
    auto start = std::chrono::high_resolution_clock::now();
    bibtex_parser::parse(buff.cbegin(), buff.cend(), entrys);
    auto stop = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(stop-start).count();
 
    std::cout << "m_ax: parsing time, (ms) = " << duration << std::endl;
    std::cout << "number of entries = " << entrys.size() << std::endl << std::endl;
 
 
 
    std::vector<Entry> e;
 
    auto space = sn::space | '%' >> *(qi::char_ - qi::eol) >> qi::eol;
 
    start = std::chrono::high_resolution_clock::now();
    read( buff.cbegin(), buff.cend(), space, e );
    stop = std::chrono::high_resolution_clock::now();
    duration = std::chrono::duration_cast<std::chrono::milliseconds>(stop-start).count();
 
    std::cout << "old: parsing time, (ms) = " << duration << std::endl;
    std::cout << "number of entries = " << e.size() << std::endl << std::endl;
 
 
 
    QFile bibFile(filename);
    if (!bibFile.open(QIODevice::ReadOnly))
        return -1;
 
    QList <CBibTag> theBib;
    CBibReader reader(bibFile);
 
    start = std::chrono::high_resolution_clock::now();
    while (reader.ReadLine()) {
        int type;
        QString citeKey;
        if (!reader.BibStart(type, citeKey)) continue;
 
        theBib.push_back(CBibTag(type, citeKey));
 
    }
    stop = std::chrono::high_resolution_clock::now();
    duration = std::chrono::duration_cast<std::chrono::milliseconds>(stop-start).count();
 
    std::cout << "igors: parsing time, (ms) = " << duration << std::endl;
    std::cout << "number of entries = " << theBib.size() << std::endl << std::endl;
 
    return 0;
}
 

Bash
m_ax: parsing time, (ms) = 26
number of entries = 126
 
old: parsing time, (ms) = 9
number of entries = 126
 
igors: parsing time, (ms) = 11
number of entries = 123
 
---------------------------------------------------------------------------
m_ax: parsing time, (ms) = 22
number of entries = 126
 
old: parsing time, (ms) = 5
number of entries = 126
 
igors: parsing time, (ms) = 10
number of entries = 123
 
---------------------------------------------------------------------------
m_ax: parsing time, (ms) = 20
number of entries = 126
 
old: parsing time, (ms) = 7
number of entries = 126
 
igors: parsing time, (ms) = 13
number of entries = 123
 
 

C++ (Qt)
#ifndef BIBTEX_PARSER_H
#define BIBTEX_PARSER_H
 
#include <string>
 
#include <boost/algorithm/string/trim.hpp>
#include <boost/regex.hpp>
#include <boost/xpressive/xpressive.hpp>
#include <boost/tokenizer.hpp>
 
#include "core/spec_token_functions.h"
#include "core/skipper_iterator.h"
#include "core/bibtex_entry.h"
 
namespace bibmake {
 
namespace core {
 
class bibtex_parser
{
public:
    typedef std::string string_type;
 
    template <class Iterator, class Container>
    static size_t parse(Iterator begin, Iterator end, Container & entry_list)
    {
        if (begin == end)
            return 0;
 
        using namespace boost::xpressive;
        basic_regex<Iterator> comment = (~as_xpr('\\') | bos) >> (s1 = ('%' >> *(~_n) >> (_n | eos)));
 
        boost::regex start_entry_regex("@(\\w+)[\\s\\t]*\\{");
 
        basic_regex<Iterator> field = *space >> (s1 = +_w) >> *space >> '=' >> (s2 = +_);
 
        quote_list<char> quotes('{', '}');
        quotes.add_quote('"', '"');
        quote_extractor<char> qextractor(quotes);
 
        skipper_iterator<Iterator> _begin(begin, end, comment);
        skipper_iterator<Iterator> _end(end, end, comment);
 
        boost::match_results<skipper_iterator<Iterator>> what;
        size_t counter(0);
        while (boost::regex_search(_begin, _end, what, start_entry_regex))
        {
            bibtex_entry entry;
            entry.set_type(what.str(1));
 
            _begin = what[1].second;
            string_type fields;
            if (!qextractor(_begin, _end, fields))
            {
                _begin = what[1].second;
                continue;
            }
 
            boost::tokenizer<spec_char_separator<char>> tok(fields, spec_char_separator<char>(",", "", quotes));
            auto it = tok.begin();
            if (it == tok.end())
                 continue;
 
            entry.set_key(boost::algorithm::trim_copy(*it));
            ++it;
 
            for (; it != tok.end(); ++it)
            {
                smatch w;
                if (regex_search(*it, w, field))
                {
                    string_type tag = w.str(1);
                    string_type content = w.str(2);
                    auto first = w[2].first;
                    auto second = w[2].second;
                    if (!qextractor(first, second, content))
                        content = w.str(2);
                    boost::algorithm::trim(content);
                    if (!content.empty())
                        entry.add_field(tag, content);
                }
            }
            entry_list.push_back(entry);
            ++counter;
        }
 
        return counter;
    }
 
};
 
} /* namespace core */
 
} /* namespace bibmake */
 
#endif // BIBTEX_PARSER_H
 

C++ (Qt)
#ifndef BIBTEX_ENTRY_H
#define BIBTEX_ENTRY_H
 
#include <string>
#include <map>
#include <boost/algorithm/string/case_conv.hpp>
 
namespace bibmake {
 
namespace core {
 
class bibtex_entry
{
public:
    typedef std::string string_type;
    typedef std::map<string_type, string_type> fields_type;
    typedef typename fields_type::size_type size_type;
    typedef typename fields_type::const_iterator const_iterator;
 
    bibtex_entry() {}
 
    string_type key() const { return m_key; }
 
    string_type type() const { return m_type; }
 
    void set_type(const string_type & type)
    {
        m_type = boost::algorithm::to_lower_copy(type);
    }
 
    void set_key(const string_type & key)
    {
        m_key = key;
    }
 
    void add_field(const string_type & tag, const string_type & content)
    {
        m_fields[boost::algorithm::to_lower_copy(tag)] = content;
    }
 
    void erase(const string_type & tag)
    {
        m_fields.erase(boost::algorithm::to_lower_copy(tag));
    }
 
    string_type content(const string_type & tag) const
    {
        auto it = m_fields.find(boost::algorithm::to_lower_copy(tag));
        return (it != m_fields.end()) ? it->second : string_type();
    }
 
    bool is_contains(const string_type & tag) const
    {
        return (m_fields.find(boost::algorithm::to_lower_copy(tag)) != m_fields.end());
    }
 
    size_type size() const { return m_fields.size(); }
 
    bool empty() const { return m_fields.empty(); }
 
    const_iterator begin() const { return m_fields.begin(); }
 
    const_iterator end() const { return m_fields.end(); }
 
private:
    string_type m_key;
    string_type m_type;
    fields_type m_fields;
};
 
} /* namespace core */
 
} /* namespace bibmake */
 
#endif // BIBTEX_ENTRY_H
 

C++ (Qt)
if (!reader.ReadBibTag(theBib.back()))
                    theBib.pop_back();
 

Bash
m_ax: parsing time, (ms) = 18
number of entries = 126
 
old: parsing time, (ms) = 4
number of entries = 126
 
igors: parsing time, (ms) = 22
number of entries = 123
 
-------------------------------------------------------------------
m_ax: parsing time, (ms) = 20
number of entries = 126
 
old: parsing time, (ms) = 12
number of entries = 126
 
igors: parsing time, (ms) = 16
number of entries = 123
 
-------------------------------------------------------------------
m_ax: parsing time, (ms) = 18
number of entries = 126
 
old: parsing time, (ms) = 9
number of entries = 126
 
igors: parsing time, (ms) = 21
number of entries = 123
 
 

C++ (Qt)
template <class ForwardIterator, class Skipper>
class ObjParser : public qi::grammar<ForwardIterator, Skipper, ModelData()>
{
public:
	ObjParser() : ObjParser::base_type( m_start )
	{
		using boost::phoenix::at_c;
 
		m_start = *(
				 m_vertex_lst[ at_c<0>(_val) = _1 ] |
				 m_normal_lst[ at_c<1>(_val) = _1 ] |
				 m_texcoord_lst[ at_c<2>(_val) = _1 ] |
				 m_face_lst[ at_c<3>(_val) = _1 ]
				 ) >> qi::eoi;
 
		m_vertex_lst = m_vertex >> *m_vertex;
		m_vertex = lit( "v" ) >> double_[ at_c<0>(_val) = _1 ] >> double_[ at_c<1>(_val) = _1 ] >> double_[ at_c<2>(_val) = _1 ] >> -double_[ at_c<3>(_val) = _1 ];
 
		m_normal_lst = m_normal >> *m_normal;
		m_normal = lit( "vn" ) >> double_[ at_c<0>(_val) = _1 ] >> double_[ at_c<1>(_val) = _1 ] >> double_[ at_c<2>(_val) = _1 ];
 
		m_texcoord_lst = m_texcoord >> *m_texcoord;
		m_texcoord = lit( "vt" ) >> double_[ at_c<0>(_val) = _1 ] >> double_[ at_c<1>(_val) = _1 ] >> -double_[ at_c<2>(_val) = _1 ];
 
		m_face_lst = m_face >> *m_face;
		m_face = lit( "f" ) >> m_index >> m_index >> m_index >> *m_index;
		m_index = int_[ at_c<0>(_val) = _1 ] >> -( '/' >> -int_[ at_c<1>(_val) = _1 ] >> -( '/' >> int_[ at_c<2>(_val) = _1 ] ) );
	}
 
private:
	qi::rule<ForwardIterator, Skipper, ModelData()>		m_start;
	qi::rule<ForwardIterator, Skipper, VertexList()>	m_vertex_lst;
	qi::rule<ForwardIterator, Skipper, Vertex()>		m_vertex;
	qi::rule<ForwardIterator, Skipper, NormalList()>	m_normal_lst;
	qi::rule<ForwardIterator, Skipper, Normal()>		m_normal;
	qi::rule<ForwardIterator, Skipper, TexCoordList()>	m_texcoord_lst;
	qi::rule<ForwardIterator, Skipper, TexCoord()>		m_texcoord;
	qi::rule<ForwardIterator, Skipper, FaceList()>		m_face_lst;
	qi::rule<ForwardIterator, Skipper, Face()>		m_face;
	qi::rule<ForwardIterator, Skipper, Index()>		m_index;
};
 

C++ (Qt)
struct Vertex
{
	explicit Vertex() : x( 0. ), y( 0. ), z( 0. ), w( 1. ) {}
	explicit Vertex( double vx, double vy, double vz, double vw = 1 ) : x( vx ), y( vy ), z( vz ), w( vw ) {}
 
	double	x;
	double	y;
	double	z;
	double	w;
};
 
struct Normal
{
	explicit Normal() : x( 0. ), y( 0. ), z( 0. ) {}
	explicit Normal( double vx, double vy, double vz ) : x( vx ), y( vy ), z( vz ) {}
 
	double	x;
	double	y;
	double	z;
};
 
struct TexCoord
{
	explicit TexCoord() : u( 0. ), v( 0. ), w( 0. ) {}
	explicit TexCoord( double vu, double vv, double vw = 0 ) : u( vu ), v( vv ), w( vw ) {}
 
	double	u;
	double	v;
	double	w;
};
 
struct Index
{
	explicit Index() : v( -1 ), vn( -1 ), vt( -1 ) {}
	explicit Index( int vv, int vvn, int vvt ) : v( vv ), vn( vvn ), vt( vvt ) {}
 
	int		v;
	int		vn;
	int		vt;
};
 
typedef deque<Vertex>	VertexList;
typedef deque<Normal>	NormalList;
typedef deque<TexCoord>	TexCoordList;
typedef deque<Index>	Face;
typedef deque<Face>	FaceList;
 
struct ModelData
{
	VertexList	v;
	NormalList	vn;
	TexCoordList	vt;
	FaceList	f;
};
 

C++ (Qt)
// Изменяем структуру списка поверхностей
// Добавляем метод addFace, в котором проверяем передаваемые индексы,
// корректируем их при необходимости и добавляем в коллекцию
struct FaceList : public deque<Face>
{
	void	addFace( const Face &f )
	{
		cout << "addFace" << endl;
		push_back( f );
	}
};
 
// И меняем правило получения списка поверхностей
// Теперь, после разбора всех индексов одного face, будет вызываться наш метод addFace, в котором мы все будем фиксить
// Правило можно упростить, перейдя на форму записи списков (%), но тогда потребуется еще кое что менять - лень.
m_face_lst = m_face[ boost::phoenix::bind( &FaceList::addFace, _val, _1 ) ] >> *m_face[ boost::phoenix::bind( &FaceList::addFace, _val, _1 ) ];
 

C++ (Qt)
struct Group
{
    string    name;
    FaceList faces;
};
 

C++ (Qt)
m_vertex = lit( "v" ) >> double_[ at_c<0>(_val) = _1 ] >> double_[ at_c<1>(_val) = _1 ] >> double_[ at_c<2>(_val) = _1 ] >> -double_[ at_c<3>(_val) = _1 ];

C++ (Qt)
#ifndef BIBTEX_PARSER_H
#define BIBTEX_PARSER_H
 
#include <string>
 
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/fusion/include/std_pair.hpp>
#include <boost/fusion/include/map.hpp>
 
#include "core/bibtex_entry.h"
 
namespace bibmake {
 
namespace core {
 
using namespace boost::spirit;
namespace phx = boost::phoenix;
namespace sw = boost::spirit::standard_wide;
 
namespace detail {
 
template <class Logger>
class logger_wrapper_impl
{
public:
    logger_wrapper_impl(const Logger & logger) : _logger(logger) {}
 
    template <class, class, class, class>
    struct result
    {
        typedef void type;
    };
 
    template <class Iterator, class String>
    void operator()(const String & what,
                    Iterator it_1,
                    Iterator it_2,
                    Iterator it_3) const
    {
        _logger(what, it_1, it_2, it_3);
    }
 
private:
    const Logger & _logger;
};
 
struct default_logger
{
    template <class Iterator, class String>
    void operator()(const String & what, Iterator /*it_1*/, Iterator it_2, Iterator it_3) const
    {
        std::cerr   << "Error! Expecting "
                    << what
                    << " here: \""
                    << std::string(it_2, it_3)
                    << "\""
                    << std::endl;
    }
};
 
} /* namrspace detail */
 
template <class ForwardIterator>
class inner_brace_text : public qi::grammar<ForwardIterator, std::string()>
{
public:
    inner_brace_text() : inner_brace_text::base_type(start_)
    {
        escaped_brace_ = qi::char_('\\') >> qi::char_;
 
        simple_text_ = +(escaped_brace_ | ~qi::char_("{}"));
 
        inner_brace_text_ %= simple_text_
                |
                qi::as_string
                [
                qi::char_('{') >> *(inner_brace_text_ | simple_text_) >> qi::char_('}')
                ];
 
        start_ %= '{' >> qi::omit[*sw::space] >> *inner_brace_text_ >> qi::omit[*sw::space] >> '}';
    }
 
private:
    qi::rule<ForwardIterator, std::string()> simple_text_, inner_brace_text_, escaped_brace_, start_;
};
 
 
template <class ForwardIterator>
class inner_quote_text : public qi::grammar<ForwardIterator, std::string()>
{
public:
    inner_quote_text() : inner_quote_text::base_type(start_)
    {
        escaped_quote_ = qi::char_('\\') >> qi::char_;
 
        inner_quote_text_ = +(escaped_quote_ | ~qi::char_('"'));
 
        start_ %= '"' >> qi::omit[*sw::space] >> *inner_quote_text_ >> qi::omit[*sw::space] >> '"';
    }
 
private:
    qi::rule<ForwardIterator, std::string()> inner_quote_text_, escaped_quote_, start_;
};
 
 
template <class ForwardIterator, class Skipper>
class bibtex_parser : public qi::grammar<ForwardIterator, bibtex_entry(), Skipper>
{
public:
    template <class Logger = detail::default_logger>
    bibtex_parser(const Logger & logger = detail::default_logger()) : bibtex_parser::base_type(start_, "BibTeX Parser")
    {
        type_ = +qi::alpha;
 
        key_ = +(qi::alnum | qi::char_("-_:/"));
 
        tag_ = +(qi::alnum | qi::char_("-_:/"));
 
        simple_content_ = +qi::alnum;
 
        content_ = inner_brace_content_ | inner_quote_content_ | simple_content_;
 
        body_ = '{' > key_ > ',' > fields_ >> -qi::lit(',') > '}';
 
        fields_ = -(field_ % ',');
 
        field_ = tag_ > '=' > content_;
 
        start_ = *~qi::lit('@') >> qi::lit('@')
                >>
                type_[phx::at_c<0>(_val) = _1]
                >>
                body_
                [
                    phx::at_c<1>(_val) = phx::at_c<0>(_1),
                    phx::at_c<2>(_val) = phx::at_c<1>(_1)
                ];
 
 
        start_.name("start");
        body_.name("body");
        fields_.name("fields");
        field_.name("field");
        type_.name("type");
        key_.name("citation key");
        tag_.name("tag");
        content_.name("content");
 
        phx::function<detail::logger_wrapper_impl<Logger>> logger_wrapper = detail::logger_wrapper_impl<Logger>(logger);
 
        qi::on_error<qi::fail>(start_, logger_wrapper(_4, _1, _3, _2));
    }
 
private:
    qi::rule<ForwardIterator, bibtex_entry(), Skipper> start_;
    qi::rule<ForwardIterator, std::pair<std::string, bibtex_entry::fields_type>(), Skipper> body_;
    qi::rule<ForwardIterator, bibtex_entry::fields_type(), Skipper> fields_;
    qi::rule<ForwardIterator, std::pair<std::string, std::string>(), Skipper> field_;
    qi::rule<ForwardIterator, std::string()> type_;
    qi::rule<ForwardIterator, std::string()> key_;
    qi::rule<ForwardIterator, std::string()> tag_;
    inner_brace_text<ForwardIterator> inner_brace_content_;
    inner_quote_text<ForwardIterator> inner_quote_content_;
    qi::rule<ForwardIterator, std::string()> simple_content_;
    qi::rule<ForwardIterator, std::string()> content_;
};
 
 
template <class ForwardIterator, class Container, class Logger = detail::default_logger>
bool bibtex_parse(ForwardIterator begin,
                  ForwardIterator end,
                  Container & container,
                  const Logger & logger = detail::default_logger())
{
    auto skipper = sw::space | '%' >> *(qi::char_ - (qi::eol | qi::eoi)) >> (qi::eol | qi::eoi);
 
    bibtex_parser<ForwardIterator, decltype(skipper)> parser(logger);
 
    return qi::phrase_parse(begin, end, *parser, skipper, container) && (begin == end);
}
 
} /* namespace core */
 
} /* namespace bibmake */
 
#endif // BIBTEX_PARSER_H