ich beschäftige mich nun seit kurzer Zeit mit boost::spirit, um einen recht einfachen Parser zu realisieren. Das Parsen an sich funktioniert schon so wie es soll, doch manches ist mir auch nach einigem lesen nicht ganz klar geworden. Ganz unten steht der aktuell gesamte Code und ein Beispiel einer Inputdatei.

1. Meine Regel "object": Ich möchte sicherstellen, dass die Reihenfolge der Zuweisungen von bore, length und friction beliebig ist, aber trotzdem alle drei vorkommen müssen. Anfangs dachte ich, dazu gäbe es den Operator &. Explizit:

object = *(nodes >> "{" >> ((("length" >> assignment) & ("bore" >> assignment) & ("friction" >> assignment) >> "}");

Meiner Meinung nach sollte das heißen: Ich erwarte 0 bis unendlich viele Objekte der Art: nodes, gefolgt von length=assignment, bore=assignment und friction=assignment in beliebiger Reihenfolge (das Ganze in {}). Allerdings funktioniert das so nicht. Stattdessen gebe ich stumpf jede Möglichkeit einzelnd an. Das muss ja wohl irgendwie anders gehen.

2. Mein angegebenes Beispiel wird zwar komplett geparst (pi.length ist 66, das sind alle Zeichen). Trotzdem ist pi.full false und mein Output damit "parsing data partially". Ich würde gern wissen, warum das so ist.

3. Der Operator () im struct save (der Name ist in Anbetracht seiner Funktion im Moment noch etwas irreleitend) innerhalb meiner Grammatik soll mir so wie es da steht einfach den übergenenen Double ausgeben. Angewandt wird er auf den real_p in der Regel assignment. D.h. im konkreten Beispiel wird 1,2,3,4,5,6 ausgegeben, was auch funktioniert.
Wie der Name vermuten lässt, sollte save aber eigentlich dazu da sein, meine Werte in eine im Moment noch nicht vorhandene Datenstruktur zu speichern, der Einfachheit halber von mir aus erst mal in einen vector o.ä. Wie kann ich das in einer Methode meiner Klasse open_file realisieren? Ich habe mir grundsätzlich sowas vorgestellt, aber keine Idee, wie ich es umsetzen kann.

vector<double> save(){
  vector<double> v;
  //An der Stelle auf irgendeine Art und Weise die d's aus meiner Grammatik abholen und in v schreiben
  return v;
}

Hoffentlich findet sich jemand mit mehr Ahnung als ich es habe. Ich wäre sehr verbunden

Beispiel korrekter Syntax:

1->2{
bore=1;
length=2;
friction=3;
}
2->3{
length=4;
bore=5;
friction=6;
}

#include <boost/spirit.hpp>

#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>

using namespace boost::spirit;
using namespace std;

struct pipenetwork_grammar : public grammar<pipenetwork_grammar> {
  struct save{
    void operator()(const double d) const {
      cout << d << endl;
    }
  }; 

  template <typename Scanner>
  struct definition { 
    rule<Scanner> object, nodes, assignment, identifier, value, coordinates; 
    definition(const pipenetwork_grammar &self) {
      object = *(nodes >> "{" >> ((("length" >> assignment) >> ("bore" >> assignment) >> ("friction" >> assignment))
		               |  (("length" >> assignment) >> ("friction" >> assignment) >> ("bore" >> assignment))
		               |  (("bore" >> assignment) >> ("length" >> assignment) >> ("friction" >> assignment))
		               |  (("bore" >> assignment) >> ("friction" >> assignment) >> ("length" >> assignment))
		               |  (("friction" >> assignment) >> ("bore" >> assignment) >> ("length" >> assignment))
			       |  (("friction" >> assignment) >> ("length" >> assignment) >> ("bore" >> assignment)))
                >> "}");
      nodes = int_p >> "->" >> int_p; 
      assignment = "=" >> real_p[save()] >> ";";
    }
    const rule<Scanner> &start() { 
      return object; 
    } 
  };
};

class open_file{
private:
  ifstream file; 
  ostringstream ss; 
  string data; 
  pipenetwork_grammar g; 
public:
  open_file();
  open_file(char *filename){
    open(filename);
  }
  void open(char *filename){
    file.open(filename);
    ss << file.rdbuf(); 
    data = ss.str();
    parse_info<> pi = parse(data.c_str(), g, space_p);
    if (pi.hit) { 
	if (pi.full) 
	  cout << "parsing all data successfully" << endl; 
	else 
	  cout << "parsing data partially" << endl;
	cout << pi.length << " characters parsed" << endl; 
      } 
    else 
      cout << "parsing failed; stopped at '" << pi.stop << "'" << endl;
  }
};

int main(int argc, char *argv[]){ 
  open_file pipenetwork_file(argv[1]);
  return 0;
}

>> !end_p

anfügen. Ich rate dir aber ganz ernsthaft dazu, Neuentwicklungen mit Spirit 2 anzufangen.

Da bin ich wohl auf ein altes Tutorial gestoßen, ohne dass es mir aufgefallen ist. Hm, ich muss mal herausfinden, welche Boost Version auf unserem Uni-Cluster verwendet wird, gehe aber mal von einer recht neuen aus. Sollte hier aber noch jemand um die Ecke kommen und vor allem eine Antwort oder Gedankenanstoß für Frage 3 haben, würde ich mich trotzdem freuen

Deine Grammatik denke ich mir ungefähr so:

#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/adapted/std_pair.hpp>
#include <boost/fusion/include/adapt_struct.hpp>

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

// Vermutlich sinnvoll: boost::spirit::qi::symbols benutzen und
// hier dann statt std::string eine enum als Schlüsseltypen.
typedef std::map<std::string, double> property_map_t;

struct edge {
  int from;
  int to;

  property_map_t properties;
};

BOOST_FUSION_ADAPT_STRUCT(edge,
                          (int, from)
                          (int, to)
                          (property_map_t, properties))

class edge_grammar
  : public boost::spirit::qi::grammar<std::string::const_iterator,
                                      edge(),
                                      boost::spirit::qi::standard::space_type>
{
public:
  edge_grammar() : edge_grammar::base_type(object) {
    namespace qi = boost::spirit::qi;

    object         = qi::int_ >> "->" >> qi::int_ >> '{' >> property_list >> '}';

    property_list  = *property;
    property       = property_name >> '=' >> property_value >> ';';

    property_name  = qi::string("length") | qi::string("friction") | qi::string("bore");
    property_value = qi::double_;
  }

private:
  typedef std::string::const_iterator iterator_t;
  typedef boost::spirit::qi::standard::space_type space_t;

  // Metafunktion nur, um die Verweise auf iterator_t und space_t zentral zu haben.
  template<typename T> struct rule_type {
    typedef boost::spirit::qi::rule<iterator_t, T(), space_t> type;
  };

  rule_type<edge                           >::type object;
  rule_type<property_map_t                 >::type property_list;
  rule_type<std::pair<std::string, double> >::type property;
  rule_type<std::string                    >::type property_name;
  rule_type<double                         >::type property_value;
};

int main() {
  edge_grammar edge_;
  std::string data =
    "1 -> 2 { length = 1.2; bore = 2.3; friction = 3.4; }"
    "2 -> 3 { bore = 4; length = 5; friction = 6; }"
    ;

  std::string::const_iterator first = data.begin();
  std::string::const_iterator last  = data.end  ();
  std::vector<edge> edges;

  bool r = boost::spirit::qi::phrase_parse(first, last, *edge_, boost::spirit::qi::standard::space, edges);

  if(r && first == last) {
    for(std::vector<edge>::const_iterator i = edges.begin(); i != edges.end(); ++i) {
      std::cout << "Von " << i->from << " nach " << i->to << ":\n\n";

      for(property_map_t::const_iterator p = i->properties.begin(); p != i->properties.end(); ++p) {
        std::cout << p->first << " = " << p->second << '\n';
      }

      std::cout << '\n';
    }
  }
}

Oder für Faule: du definierst fortgelassene Attribute zu einem standardisierten Wert

Was den Code angeht, schau in die Dokus zu Boost.Spirit und Boost.Fusion. Wenn man verstanden hat, was Boost.Fusion soll, ist die Parser-Attributierung in Boost.Spirit ziemlich straightforward, und dann sollte dieses Beispiel dich nicht mehr vor allzu große Verständnisprobleme stellen.