Comment puis-je utiliser POCO de parser un fichier xml et d'en extraire un nœud particulier à un std::string?

J'ai rencontré un problème similaire moi-même. Par exemple, dans votre cas avec la "Poco::XML::NodeFilter::SHOW_ALL" filtre est appliqué, tous les types de nœud(Élément de Texte, CDataSection, etc) sera incluse lors de l'iteratering à travers le document XML. J'ai trouvé que POCO ne comprend pas toutes les données dans chaque nœud, il retourne à partir de "NextNode()".

Si l'on veut accéder à un des nœuds XML attributs, on doit d'abord interroger le nœud de vérifier s'il a des attributs à l'aide de "hasAttributes()" et puis, si elle n', itérer sur chacun de ces attributs pour trouver celles qui l'intéressent.

XML Exemple:

<?xml version="1.0"?>
<reaction id="J1" reversible="false">

C++ Exemple:

...
Poco::XML::NamedNodeMap* attributes = NULL;
Poco::XML::Node* attribute = NULL;

while(pNode)
{
 if( (pNode->nodeName() == "reaction") && pNode->hasAttributes())
 {
   attributes = pNode->attributes(); 
   for(unsigned int i = 0; i < attributes->length(); i++)
   {
     attribute = attributes->item(i);
     cout << attribute->nodeName() << " : " << attribute->nodeValue() << endl
   }
  }
  pNode = it.nextNode();
}
...

Doit de sortie:

id : J1
reversible : false

Si l'on veut accéder au texte entre les deux balises XML, comme le montre l'exemple de XML ci-dessous, on doit d'abord trouver le nœud avec un nom qui correspond à la balise d'intérêt, comme vous l'avez fait dans votre exemple, et puis vérifier le nœud suivant en appelant "NextNode()" pour voir si ce nœud est le nom du nœud "#texte" ou "#cdata-section". Si c'est le cas, la valeur de ce "nœud" contiendra le texte entre les balises XML.

XML Exemple:

<?xml version="1.0"?>
<listOfReactions>Some text</listOfReactions>

C++ Exemple:

...
while(pNode)
{
 if(pNode->nodeName() == "listOfReactions")
 {
   pNode = it.nextNode();
   if(pNode->nodeName() != "#text")
   {
     continue; //No text node present
   }
   cout << "Tag Text: " << pNode->nodeValue() << endl;
  }
  pNode = it.nextNode();
}
...

Doit de sortie:

Some text

Tard pour le jeu, mais peut-être encore utile. Je suis à la recherche dans Poco XML pour extraire des données météorologiques livré en xml. J'ai trouvé le PDF-diapositive @JBently mentionner comme une bonne introduction. Cette offre de l'hpp-fichier. Cette exemple couvre la mise en œuvre. J'ai omis LexicalHandler.

Je m'occupe de la chaîne listOfReactions, et, une fois trouvé, j'ai ajouter un attribut de nom et de valeur à une chaîne dans startElement(). Dans les caractères() j'ai ajouter le texte dans le nœud de la corde et de l'ajouter à un vecteur, qui peut être parcouru.

De sortie:

id=J1,réversible=false,false déplacer

id=J2,réversible=true,true déplacer

J'ai changé votre xml légèrement pour les tests, et s'est échappé des guillemets à utiliser dans le programme.

<?xml version=\"1.0\" encoding=\"UTF-8\"?><sbml xmlns = \"http://www.sbml.org/sbml/level2/version4\" level = \"2\" version = \"4\">
    <model id = \"cell\">
        <listOfSpecies>species</listOfSpecies>
        <listOfParameters>
            <parameter id = \"kk1\" value = \"1\"/>
        </listOfParameters>
        <listOfReactions>
            <reaction id = \"J1\" reversible = \"false\">false move</reaction>
            <reaction id = \"J2\" reversible = \"true\">true move</reaction>
        </listOfReactions>
    </model>
</sbml>

principal:

#include <iostream>

#include "MyHandler.hpp"

using namespace std;

int main() {
    auto s = {XML file from above};
    MyHandler handler {};
    Poco::XML::SAXParser parser {};
    parser.setFeature(Poco::XML::XMLReader::FEATURE_NAMESPACES, false);
    parser.setFeature(Poco::XML::XMLReader::FEATURE_NAMESPACE_PREFIXES, true);
    parser.setContentHandler(&handler);

    try {
        parser.parseString(s);
    } catch (Poco::Exception& e) {
        cerr << e.displayText() << endl;
    }
    auto saved = handler.saved_reactions();
    for (auto& i : saved) {
        cout << i << endl;
    }
    return 0;
}

MyHandler.hpp:

#ifndef MYHANDLER_HPP_
#define MYHANDLER_HPP_
#include <iostream>
#include <vector>
#include <Poco/SAX/Attributes.h>
#include <Poco/SAX/ContentHandler.h>
#include <Poco/SAX/SAXParser.h>
class MyHandler: public Poco::XML::ContentHandler {
public:
MyHandler();
virtual ~MyHandler();
//ContentHandler overrides, begin.
void setDocumentLocator(const Poco::XML::Locator* loc);
void startDocument();
void endDocument();
void startElement(
const Poco::XML::XMLString&,
const Poco::XML::XMLString&,
const Poco::XML::XMLString&,
const Poco::XML::Attributes&);
void endElement(
const Poco::XML::XMLString&,
const Poco::XML::XMLString&,
const Poco::XML::XMLString&);
void characters(const Poco::XML::XMLChar ch[], int, int);
void ignorableWhitespace(const Poco::XML::XMLChar ch[], int, int);
void processingInstruction(const Poco::XML::XMLString&, const Poco::XML::XMLString&);
void startPrefixMapping(const Poco::XML::XMLString&, const Poco::XML::XMLString&);
void endPrefixMapping(const Poco::XML::XMLString&);
void skippedEntity(const Poco::XML::XMLString&);
//ContentHandler overrides, end
std::vector<std::string> saved_reactions();
private:
bool show = false;
std::string reactions_s {};
std::vector<std::string> reactions_v {};
};
#endif /* MYHANDLER_HPP_ */

MyHandler.cpp:

#include "MyHandler.hpp"
MyHandler::MyHandler() {}
MyHandler::~MyHandler() {}
void MyHandler::setDocumentLocator(const Poco::XML::Locator* loc) {
}
void MyHandler::startDocument() {
}
void MyHandler::endDocument() {
}
void MyHandler::startElement(const Poco::XML::XMLString& namespaceURI, const Poco::XML::XMLString& localName, const Poco::XML::XMLString& qname, const Poco::XML::Attributes& attributes) {
int x {0};
std::cout << "qname: " << qname << std::endl;
/*    std::cout << "getValue(): " << attributes.getValue(qname) << std::endl;
std::cout << "getLength(): " << attributes.getLength() << std::endl;*/
if (qname == "listOfReactions") {
show = true;
}
if (show) {
if (attributes.getLength()) {
reactions_s.clear();
x = attributes.getLength();
for (int i = 0; i < x; ++i) {
std::cout << "getQName(): " << attributes.getQName(i) << ", getValue(): " << attributes.getValue(i) << std::endl;
if (reactions_s.size()) reactions_s += ",";
reactions_s += attributes.getQName(i) + "=" + attributes.getValue(i);
}
}
}
}
void MyHandler::endElement(const Poco::XML::XMLString& allocator,
const Poco::XML::XMLString& allocator1,
const Poco::XML::XMLString& allocator2) {
}
void MyHandler::characters(const Poco::XML::XMLChar ch[], int start, int length) {
std::cout << std::string(ch + start, length) << std::endl;
if (show) {
reactions_s += "," + std::string(ch + start, length);
reactions_v.emplace_back(reactions_s);
}
}
void MyHandler::ignorableWhitespace(const Poco::XML::XMLChar ch[], int start, int length) {
}
void MyHandler::processingInstruction(const Poco::XML::XMLString& allocator, const Poco::XML::XMLString& allocator1) {
}
void MyHandler::startPrefixMapping(const Poco::XML::XMLString& allocator, const Poco::XML::XMLString& allocator1) {
}
void MyHandler::endPrefixMapping(const Poco::XML::XMLString& allocator) {
}
std::vector<std::string> MyHandler::saved_reactions() {
return reactions_v;
}
void MyHandler::skippedEntity(const Poco::XML::XMLString& allocator) {
}