Russian Qt Forum

C++ (Qt)
    while (!fileStream_.atEnd()){
        QString line(fileStream_.readLine());
        if (line == "END NODES"){
            break;
        }
 
        Q_ASSERT(line.startsWith("*node("));
        QTextStream lineStream(&line, QIODevice::ReadOnly);
 
        lineStream.seek(6);
 
        ParsedNode node;
        lineStream >> node.number;
 
        float x;
        float y;
        float z;
 
        lineStream.seek(lineStream.pos() + 1);
        lineStream >> x;
        lineStream.seek(lineStream.pos() + 1);
        lineStream >> y;
        lineStream.seek(lineStream.pos() + 1);
        lineStream >> z;
 
        node.coordinates = QVector3D(x, y, z);
        nodes << node;
    }
 

C++ (Qt)
std::tuple<float, float, float> parse_coords(QString text) {
    const QStringList& parts = text.replace("*node(", "").replace(")", "").split(",");
    return std::make_tuple(parts[1].toFloat(), parts[2].toFloat(), parts[3].toFloat());
}
 
QString text = "*node(363484,232.7625,-113.996,40.69956,0,0,0,0,0)";
std::tuple<float, float, float> coord = parse_coords(text);
qDebug() << std::get<0>(coord) << std::get<1>(coord) << std::get<2>(coord);
 

C++ (Qt)
#include <QStringRef>
#include <QDebug>
 
namespace QStringParser {
 
inline QStringRef BeforeFirst( const QStringRef & src, const QString & splitter )
{
	return src.left(src.indexOf(splitter));
}
 
inline QStringRef AfterFirst( const QStringRef & src, const QString & splitter )
{
	int pos = src.indexOf(splitter);
	iif (pos < 0) return src.right(0);
	return src.mid(pos + splitter.size());
}
 
inline bool ReadInt( QStringRef & ref, const QString & splitter, int & val )
{
	bool ok;
	val = BeforeFirst(ref, splitter).trimmed().toInt(&ok);
	if (!ok) return false;
	ref = AfterFirst(ref, splitter);
	return true;
}
 
inline bool ReadFloat( QStringRef & ref, const QString & splitter, float & val )
{
	bool ok;
	val = BeforeFirst(ref, splitter).trimmed().toFloat(&ok);
	if (!ok) return false;
	ref = AfterFirst(ref, splitter);
	return true;
}
 
}	// namespace
 
using namespace QStringParser;
 
bool Error( const QStringRef & ref, QString & err, const QString & txt )
{
	err = "\nError at position " + QString::number(ref.position()) + ": " + txt +
		  "\n" + ref.trimmed().toString(); 
	return false;
}
 
bool Parse( const QString & srcStr, int & number, float val[3], QString & err )
{
	static const QString prefix("node");
	static const QString comma(",");
 
	QStringRef src(&srcStr);
	if (!src.startsWith(prefix)) 
		return Error(src, err, "string must start with 'node'");
 
	src = AfterFirst(QStringRef(&srcStr), prefix).trimmed();
	if (!src.startsWith('(')) 
		return Error(src, err, "'(' expected");
	src = src.mid(1);
 
	if (!ReadInt(src, comma, number)) 
		return Error(src, err, "integer value expected");
 
	for (int i = 0; i < 3; ++i) 
		if (!ReadFloat(src, comma, val[i])) 
			return Error(src, err, "float value expected");
 
	return true;
}
 
int main(int argc, char **argv)
{
	int nodeNum;
	float val[3] = { 0 };
 
	QString err;
	QString test("node  ( 363484   ,232.7625,    -113.996, 40.69x956,0,0,0,0,0)");
	bool ok = Parse(test, nodeNum, val, err);
	qDebug() << ok << nodeNum << val[0] << val[1] << val[2];
	if (!ok) qDebug() << err;
	return 0;
}

C++ (Qt)
    while (!fileStream_.atEnd()){
        QString line(fileStream_.readLine());
        if (line == endNodesGroupString){
            break;
        }
 
        if (line.startsWith(nodeIndicatorString)){
            const QStringList &lineParts = line.remove(nodeIndicatorString).remove(" ").remove(")").split(',');
            constexpr int partCountRequried = 4;
            if (lineParts.count() < partCountRequried){
                qCritical() << "Got bad node line";
            }
            else{
 
                ParsedNode node;
                node.number = lineParts.at(0).toFloat();
 
                for (int k = 0; k < nodeDimension; ++k){
                    node.coordinates[k] = lineParts.at(k + 1).toFloat();
                }
                nodes << node;
            }
        }
    }
 

C++ (Qt)
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <QString>
 
#include <iostream>
#include <string>
 
constexpr int nodeDimension = 3;
struct ParsedNode{
    uint number = -1;
    std::array<float, nodeDimension> coordinates = {{-1, -1, -1}};
};
 
template <typename Iterator>
bool parse_hypermesh(Iterator first, Iterator last, ParsedNode& node)
{
    using boost::spirit::qi::uint_;
    using boost::spirit::qi::float_;
    using boost::spirit::qi::_1;
    using boost::spirit::qi::phrase_parse;
    using boost::spirit::ascii::space;
    using boost::phoenix::ref;
 
    uint nodeNumber;
    float x;
    float y;
    float z;
 
    bool result = phrase_parse(first, last,
        (
            "*node(" >> uint_[ref(nodeNumber) = _1] >> ','
            >> float_[ref(x) = _1] >> ','
            >> float_[ref(y) = _1] >> ','
            >> float_[ref(z) = _1] >> ','
            >> *(uint_ >> ',')
            >> uint_ >> ')'
        ),
        space);
 
    if (!result || first != last){
        return false;
    }
 
    node.number = nodeNumber;
    node.coordinates = {x, y, z};
    return result;
}
 
int main()
{
    const QString testString("*node( 363484 , 232.7625 , -113.996 , 40.69956 , 0 , 0 , 0 , 0 , 0 )");
 
    const std::wstring& convertedTestString = testString.toStdWString();
    ParsedNode node;
 
    if (parse_hypermesh(convertedTestString.begin(), convertedTestString.end(), node))
    {
        std::cout << "Parsing succeeded\n";
    }
    else
    {
        std::cout << "Parsing failed\n";
    }
 
    return 0;
}
 

C++ (Qt)
uint nodeNumber;
    float x;
    float y;
    float z;
 

C++ (Qt)
using namespace boost::spirit;
namespace phx = boost::phoenix;
namespace sw = boost::spirit::standard_wide;
 
struct Node
{
    static constexpr uint nodeDimension = 3;
    uint number = -1;
    std::array<float, nodeDimension> coordinates = {{-1, -1, -1}};
};
 
template <typename Iterator>
bool parse_hypermesh(Iterator first, Iterator last, Node& node)
{
    return qi::phrase_parse(first, last,
        (
            qi::lit("*node(") >> qi::uint_[phx::ref(node.number) = _1] >> ','
            >> qi::float_[phx::ref(node.coordinates[0]) = _1] >> ','
            >> qi::float_[phx::ref(node.coordinates[1]) = _1] >> ','
            >> qi::float_[phx::ref(node.coordinates[2]) = _1] >> ','
            >> *(qi::uint_ >> ',')
            >> qi::uint_ >> ')'
        ),
        sw::space) && first == last;
}
 
int main()
{
        std::string str = "*node( 363484 , 232.7625 , -113.996 , 40.69956 , 0 , 0 , 0 , 0 , 0 )";
 
        Node node;
 
        if (parse_hypermesh(str.begin(), str.end(), node))
        {
            std::cout << "Parsing succeeded\n";
            std::cout << node.number << std::endl;
            for (auto x : node.coordinates)
                std::cout << x << std::endl;
        }
        else
        {
            std::cout << "Parsing failed\n";
        }
    return 0;
}
 

C++ (Qt)
template <class ForwardIterator, class Skipper>
class NodeParser : public qi::grammar<ForwardIterator, Node(), Skipper>
{
...
};
 
template <class ForwardIterator, class Container>
bool node_parse(ForwardIterator begin,
                  ForwardIterator end,
                  Container & container)
{
    return qi::phrase_parse(begin, end, *NodeParser<ForwardIterator, sw::space_type>(), sw::space, container);
}
 

C++ (Qt)
typedef boost::spirit::istream_iterator istream_iterator_type;
        std::ifstream in(filename);
        in.unsetf( std::ios_base::skipws );
 
        istream_iterator_type beg( in );
        istream_iterator_type end;
        std::vector<node> container; 
        node_parse(beg, end, container);
 

C++ (Qt)
#include <stdio.h>
 
int main( void )
{
  int num, last = 0;
  float val[3] = { 1, 2, 3 };
 
  const char * fmt = "node ( %d , %f, %f, %f ) %d";
  const char * test = "node ( 363484   ,232.7625,    -113.996, 40.69956)777";
//  const char * test = "node(363484,232.7625,-113.996,40.69956)777";
 
  int count = sscanf(test, fmt, &num, val, val + 1, val + 2, &last);
  printf("Ok = %d\n", int(last == 777));
  printf("%d (%f, %f, %f)\n", num, val[0], val[1], val[2]);
 
  return 0;
}

C++ (Qt)
 >> qi::float_[phx::ref(node.coordinates[0]) = _1] >> ','

C++ (Qt)
struct Node
{
    Node() : number(0) {}
    static constexpr uint nodeDimension = 3;
    uint number;
    std::array<float, nodeDimension> coordinates = {{-1, -1, -1}};
};
 
namespace qi = boost::spirit::qi;
namespace phx = boost::phoenix;
namespace sw = boost::spirit::standard_wide;
 
 
template <class ForwardIterator>
class NodeParser : public qi::grammar<ForwardIterator, Node(), sw::space_type>
{
public:
    NodeParser() : NodeParser::base_type(start_, "NodeParser")
    {
        start_ = qi::lit("*node(")  >> qi::uint_[phx::bind(&NodeParser::set_number, qi::_val, qi::_1)] >> ','
                                    >> qi::float_[phx::bind(&NodeParser::set_x, qi::_val, qi::_1)] >> ','
                                    >> qi::float_[phx::bind(&NodeParser::set_y, qi::_val, qi::_1)] >> ','
                                    >> qi::float_[phx::bind(&NodeParser::set_z, qi::_val, qi::_1)] >> ','
                                    >> *(qi::uint_ >> ',')
                                    >> qi::uint_ >> ')';
    }
private:
    qi::rule<ForwardIterator, Node(), sw::space_type> start_;
 
    static void set_number(Node & node, uint number){ node.number = number; }
    static void set_x(Node & node, float x){ node.coordinates[0] = x; }
    static void set_y(Node & node, float y){ node.coordinates[1] = y; }
    static void set_z(Node & node, float z){ node.coordinates[2] = z; }
};
 

C++ (Qt)
QStringRef src(&text);
src = BeforeFirst(src, "//");

C++ (Qt)
start_ = qi::lit("*node(")  >> qi::uint_[phx::bind(&NodeParser::set_number, qi::_val, qi::_1)] >> ','
                                    >> qi::float_[phx::bind(&NodeParser::set_x, qi::_val, qi::_1)] >> ','
                                    >> qi::float_[phx::bind(&NodeParser::set_y, qi::_val, qi::_1)] >> ','
                                    >> qi::float_[phx::bind(&NodeParser::set_z, qi::_val, qi::_1)] >> ','
                                    >> *(qi::uint_ >> ',')
                                    >> qi::uint_ >> ')' >> '//' >> *(qi::char_);

C++ (Qt)
start =
          space                               // tab/space/cr/lf
     |   "//" >> *(char_ - eol) >> eol     // C++ style comments
;
 

C++ (Qt)
        switch (e->type()) {
            case QEvent::MouseButtonDblClick:
                break;
            default:
                return false;
        }
 

C++ (Qt)
merge_istream_iterator begin({"file1.obj", "file2.obj", "file3.obj"});
merge_istream_iterator end;
 
qi::phrase_parse(begin, end, *parser, sw::space | '\' >> qi::eof, container);