YUMPatchParser.cc

Go to the documentation of this file.
00001 /*---------------------------------------------------------------------\
00002 |                          ____ _   __ __ ___                          |
00003 |                         |__  / \ / / . \ . \                         |
00004 |                           / / \ V /|  _/  _/                         |
00005 |                          / /__ | | | | | |                           |
00006 |                         /_____||_| |_| |_|                           |
00007 |                                                                      |
00008 \---------------------------------------------------------------------*/
00013 #include <zypp/parser/yum/YUMPatchParser.h>
00014 #include <zypp/parser/yum/YUMPrimaryParser.h>
00015 #include <istream>
00016 #include <string>
00017 #include "zypp/parser/xml_parser_assert.h"
00018 #include <libxml/xmlreader.h>
00019 #include <libxml/tree.h>
00020 #include <zypp/parser/LibXMLHelper.h>
00021 #include <zypp/base/Logger.h>
00022 #include <zypp/parser/yum/schemanames.h>
00023 #include <zypp/ZYppFactory.h>
00024 
00025 using namespace std;
00026 namespace zypp {
00027   namespace parser {
00028     namespace yum {
00029 
00030       YUMPatchParser::~YUMPatchParser()
00031       { }
00032       
00033       YUMPatchParser::YUMPatchParser(istream &is, const string& baseUrl)
00034       : XMLNodeIterator<YUMPatchData_Ptr>(is, baseUrl,PATCHSCHEMA)
00035         , _zypp_architecture( getZYpp()->architecture() )
00036       {
00037         fetchNext();
00038       }
00039       
00040       YUMPatchParser::YUMPatchParser()
00041         : _zypp_architecture( getZYpp()->architecture() )
00042       { }
00043       
00044       YUMPatchParser::YUMPatchParser(YUMPatchData_Ptr& entry)
00045       : XMLNodeIterator<YUMPatchData_Ptr>(entry)
00046         , _zypp_architecture( getZYpp()->architecture() )
00047       { }
00048       
00049       
00050       // select for which elements process() will be called
00051       bool 
00052       YUMPatchParser::isInterested(const xmlNodePtr nodePtr)
00053       {
00054         return _helper.isElement(nodePtr) && _helper.name(nodePtr) == "patch";
00055       }
00056       
00057       // do the actual processing
00058       YUMPatchData_Ptr
00059       YUMPatchParser::process(const xmlTextReaderPtr reader)
00060       {
00061         xml_assert(reader);
00062         YUMPatchData_Ptr patchPtr = new YUMPatchData;
00063         xmlNodePtr dataNode = xmlTextReaderExpand(reader);
00064         xml_assert(dataNode);
00065         patchPtr->timestamp = _helper.attribute(dataNode,"timestamp");
00066         patchPtr->patchId = _helper.attribute(dataNode,"patchid");
00067         patchPtr->engine = _helper.attribute(dataNode,"engine");
00068       
00069         // default values for optional entries
00070         patchPtr->rebootNeeded = false;
00071         patchPtr->packageManager = false;
00072       
00073         // FIXME move the respective method to a common class, inherit it  
00074         YUMPrimaryParser prim;
00075       
00076         for (xmlNodePtr child = dataNode->children; 
00077              child && child != dataNode;
00078              child = child->next) {
00079           if (_helper.isElement(child)) {
00080             string name = _helper.name(child);
00081             if (name == "name") {
00082                 patchPtr->name = _helper.content(child);
00083             }
00084             else if (name == "arch") {
00085                 patchPtr->arch = _helper.content(child);
00086               try {
00087                 if (!Arch(patchPtr->arch).compatibleWith( _zypp_architecture )) {
00088                     patchPtr = NULL;                    // skip <patch>, incompatible architecture
00089                     break;
00090                 }
00091               }
00092               catch( const Exception & excpt_r ) {
00093                 ZYPP_CAUGHT( excpt_r );
00094                 DBG << "Skipping malformed " << patchPtr->arch << endl;
00095                 patchPtr = NULL;
00096                 break;
00097               }
00098             }
00099             else if (name == "summary") {
00100               patchPtr->summary.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
00101             }
00102             else if (name == "description") {
00103               patchPtr->description.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
00104             }
00105             else if (name == "license-to-confirm")
00106             {
00107               patchPtr->license_to_confirm.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
00108             }
00109             else if (name == "version") {
00110               patchPtr->epoch = _helper.attribute(child,"epoch");
00111               patchPtr->ver = _helper.attribute(child,"ver");
00112               patchPtr->rel = _helper.attribute(child,"rel");
00113             }
00114             else if (name == "provides") {
00115               prim.parseDependencyEntries(& patchPtr->provides, child);
00116             }
00117             else if (name == "conflicts") {
00118               prim.parseDependencyEntries(& patchPtr->conflicts, child);
00119             }
00120             else if (name == "obsoletes") {
00121               prim.parseDependencyEntries(& patchPtr->obsoletes, child);
00122             }
00123             else if (name == "prerequires") {
00124               prim.parseDependencyEntries(& patchPtr->prerequires, child);
00125             }
00126             else if (name == "requires") {
00127               prim.parseDependencyEntries(& patchPtr->requires, child);
00128             }
00129             else if (name == "recommends") {
00130               prim.parseDependencyEntries(& patchPtr->recommends, child);
00131             }
00132             else if (name == "suggests") {
00133               prim.parseDependencyEntries(& patchPtr->suggests, child);
00134             }
00135             else if (name == "supplements") {
00136               prim.parseDependencyEntries(& patchPtr->supplements, child);
00137             }
00138             else if (name == "enhances") {
00139               prim.parseDependencyEntries(& patchPtr->enhances, child);
00140             }
00141             else if (name == "freshens") {
00142               prim.parseDependencyEntries(& patchPtr->freshens, child);
00143             }
00144             else if (name == "category") {
00145                 patchPtr->category = _helper.content(child);
00146             }
00147             else if (name == "reboot-needed") {
00148                 patchPtr->rebootNeeded = true;
00149             }
00150             else if (name == "package-manager") {
00151                 patchPtr->packageManager = true;
00152             }
00153             else if (name == "update-script") {
00154                 patchPtr->updateScript = _helper.content(child);
00155             }
00156             else if (name == "atoms") {
00157               parseAtomsNode(patchPtr, child);
00158             }
00159             else {
00160               WAR << "YUM <data> contains the unknown element <" << name << "> "
00161                 << _helper.positionInfo(child) << ", skipping" << endl;
00162             }
00163           }
00164         }
00165         return patchPtr;
00166       } /* end process */
00167       
00168       
00169       void 
00170       YUMPatchParser::parseAtomsNode(YUMPatchData_Ptr dataPtr,
00171                                      xmlNodePtr formatNode)
00172       {
00173         xml_assert(formatNode);
00174         for (xmlNodePtr child = formatNode->children; 
00175              child != 0;
00176              child = child ->next) {
00177           if (_helper.isElement(child)) {
00178             string name = _helper.name(child);
00179 XXX << "parseAtomsNode(" << name << ")" << endl;
00180             if (name == "package")
00181             {
00182                 parsePackageNode( dataPtr, child );
00183             }
00184             else if (name == "script")
00185             {
00186                 parseScriptNode( dataPtr, child );
00187             }
00188             else if (name == "message")
00189             {
00190                 parseMessageNode( dataPtr, child );
00191             }
00192             else {
00193               WAR << "YUM <atoms> contains the unknown element <" << name << "> "
00194                 << _helper.positionInfo(child) << ", skipping" << endl;
00195             }
00196           }
00197         }
00198       }
00199       
00200       void 
00201       YUMPatchParser::parseFormatNode(YUMPatchPackage *dataPtr,
00202                                               xmlNodePtr formatNode)
00203       {
00204         xml_assert(formatNode);
00205         dataPtr->installOnly = false;
00206         dataPtr->media = "1";
00207       
00208         // FIXME move the respective method to a common class, inherit it  
00209         YUMPrimaryParser prim;
00210       
00211         for (xmlNodePtr child = formatNode->children; 
00212              child != 0;
00213              child = child ->next) {
00214           if (_helper.isElement(child)) {
00215             string name = _helper.name(child);
00216             if (name == "license") {
00217               dataPtr->license = _helper.content(child);
00218             }
00219             else if (name == "vendor") {
00220               dataPtr->vendor = _helper.content(child);
00221             }
00222             else if (name == "group") {
00223               dataPtr->group = _helper.content(child);
00224             }
00225             else if (name == "buildhost") {
00226               dataPtr->buildhost = _helper.content(child);
00227             }
00228             else if (name == "sourcerpm") {
00229               dataPtr->sourcerpm = _helper.content(child);
00230             }
00231             else if (name == "header-range") {
00232               dataPtr->headerStart = _helper.attribute(child,"start");
00233               dataPtr->headerEnd = _helper.attribute(child,"end");
00234             }
00235             else if (name == "provides") {
00236               prim.parseDependencyEntries(& dataPtr->provides, child);
00237             }
00238             else if (name == "conflicts") {
00239               prim.parseDependencyEntries(& dataPtr->conflicts, child);
00240             }
00241             else if (name == "obsoletes") {
00242               prim.parseDependencyEntries(& dataPtr->obsoletes, child);
00243             }
00244             else if (name == "prerequires") {
00245               prim.parseDependencyEntries(& dataPtr->prerequires, child);
00246             }
00247             else if (name == "requires") {
00248               prim.parseDependencyEntries(& dataPtr->requires, child);
00249             }
00250             else if (name == "recommends") {
00251               prim.parseDependencyEntries(& dataPtr->recommends, child);
00252             }
00253             else if (name == "suggests") {
00254               prim.parseDependencyEntries(& dataPtr->suggests, child);
00255             }
00256             else if (name == "supplements") {
00257               prim.parseDependencyEntries(& dataPtr->supplements, child);
00258             }
00259             else if (name == "enhances") {
00260               prim.parseDependencyEntries(& dataPtr->enhances, child);
00261             }
00262             else if (name == "file") {
00263               dataPtr->files.push_back
00264                 (FileData(_helper.content(child),
00265                           _helper.attribute(child,"type")));
00266             }
00267             /* SUSE specific elements */
00268             else if (name == "authors") {
00269               prim.parseAuthorEntries(& dataPtr->authors, child);
00270             }
00271             else if (name == "keywords") {
00272               prim.parseKeywordEntries(& dataPtr->keywords, child);
00273             }
00274             else if (name == "media") {
00275               dataPtr->media = _helper.attribute(child,"mediaid");
00276             }
00277             else if (name == "dirsizes") {
00278               prim.parseDirsizeEntries(& dataPtr->dirSizes, child);
00279             }
00280             else if (name == "freshens") {
00281               prim.parseDependencyEntries(& dataPtr->freshens, child);
00282             }
00283             else if (name == "install-only") {
00284               dataPtr->installOnly = true;
00285             }
00286             else {
00287               WAR << "YUM <atom/package/format> contains the unknown element <"
00288                   << name << "> "
00289                 << _helper.positionInfo(child) << ", skipping" << endl;
00290             }
00291           }
00292         }
00293       }
00294       
00295       void
00296       YUMPatchParser::parsePkgPlainRpmNode(YUMPatchPackage *dataPtr,
00297                                         xmlNodePtr formatNode)
00298       {
00299         YUMPlainRpm plainRpm;
00300         plainRpm.arch = _helper.attribute( formatNode, "arch" );
00301         plainRpm.filename = _helper.attribute( formatNode, "filename" );
00302         plainRpm.downloadsize = _helper.attribute( formatNode, "downloadsize" );
00303         plainRpm.md5sum = _helper.attribute( formatNode, "md5sum" );
00304         plainRpm.buildtime = _helper.attribute( formatNode, "buildtime" );
00305         for (xmlNodePtr child = formatNode->children; 
00306              child != 0;
00307              child = child ->next) {
00308           if (_helper.isElement(child)) {
00309             string name = _helper.name(child);
00310             WAR << "YUM <atom/package/pkgfiles/plain> contains the unknown element <"
00311                 << name << "> "
00312               << _helper.positionInfo(child) << ", skipping" << endl;
00313           }
00314         }
00315         dataPtr->plainRpms.push_back(plainRpm);
00316       }
00317       
00318       void
00319       YUMPatchParser::parsePkgPatchRpmNode(YUMPatchPackage *dataPtr,
00320                                         xmlNodePtr formatNode)
00321       {
00322         YUMPatchRpm patchRpm;
00323         patchRpm.arch = _helper.attribute( formatNode, "arch" );
00324         patchRpm.filename = _helper.attribute( formatNode, "filename" );
00325         patchRpm.downloadsize = _helper.attribute( formatNode, "downloadsize" );
00326         patchRpm.md5sum = _helper.attribute( formatNode, "md5sum" );
00327         patchRpm.buildtime = _helper.attribute( formatNode, "buildtime" );
00328         patchRpm.media = "1";
00329         for (xmlNodePtr child = formatNode->children; 
00330              child != 0;
00331              child = child ->next) {
00332           if (_helper.isElement(child)) {
00333             string name = _helper.name(child);
00334             if (name == "base-version") {
00335               YUMBaseVersion base_version;
00336               parsePkgBaseVersionNode( &base_version, child);
00337               patchRpm.baseVersions.push_back( base_version );
00338             }
00339             else if (name == "location") {
00340                 patchRpm.location = _helper.attribute(child,"href");
00341             }
00342             else if (name == "media") {
00343                 patchRpm.media = _helper.content(child);
00344             }
00345             else if (name == "checksum") {
00346               patchRpm.checksumType = _helper.attribute(child,"type");
00347               patchRpm.checksum = _helper.content(child);
00348             }
00349             else if (name == "time") {
00350 //              patchRpm.timeFile = _helper.attribute(child,"file");
00351               patchRpm.buildtime = _helper.attribute(child,"build");
00352             }
00353             else if (name == "size") {
00354 //              patchRpm.sizePackage = _helper.attribute(child,"package");
00355 //              patchRpm.sizeInstalled = _helper.attribute(child,"installed");
00356               patchRpm.downloadsize = _helper.attribute(child,"archive");
00357             }
00358             else {
00359               WAR << "YUM <atom/package/pkgfiles/patch> contains the unknown element <"
00360                   << name << "> "
00361                 << _helper.positionInfo(child) << ", skipping" << endl;
00362             }
00363           }
00364         }
00365         dataPtr->patchRpms.push_back(patchRpm);
00366       }
00367       
00368       void
00369       YUMPatchParser::parsePkgDeltaRpmNode(YUMPatchPackage *dataPtr,
00370                                         xmlNodePtr formatNode)
00371       {
00372         YUMDeltaRpm deltaRpm;
00373         deltaRpm.arch = _helper.attribute( formatNode, "arch" );
00374         deltaRpm.filename = _helper.attribute( formatNode, "filename" );
00375         deltaRpm.downloadsize = _helper.attribute( formatNode, "downloadsize" );
00376         deltaRpm.md5sum = _helper.attribute( formatNode, "md5sum" );
00377         deltaRpm.buildtime = _helper.attribute( formatNode, "buildtime" );
00378         deltaRpm.media = "1";
00379         for (xmlNodePtr child = formatNode->children; 
00380              child != 0;
00381              child = child ->next) {
00382           if (_helper.isElement(child)) {
00383             string name = _helper.name(child);
00384             if (name == "base-version") {
00385               parsePkgBaseVersionNode( &(deltaRpm.baseVersion), child);
00386             }
00387             else if (name == "location") {
00388                 deltaRpm.location = _helper.attribute(child,"href");
00389             }
00390             else if (name == "media") {
00391                 deltaRpm.media = _helper.content(child);
00392             }
00393             else if (name == "checksum") {
00394               deltaRpm.checksumType = _helper.attribute(child,"type");
00395               deltaRpm.checksum = _helper.content(child);
00396             }
00397             else if (name == "time") {
00398 //              deltaRpm.timeFile = _helper.attribute(child,"file");
00399               deltaRpm.buildtime = _helper.attribute(child,"build");
00400             }
00401             else if (name == "size") {
00402 //              deltaRpm.sizePackage = _helper.attribute(child,"package");
00403 //              deltaRpm.sizeInstalled = _helper.attribute(child,"installed");
00404               deltaRpm.downloadsize = _helper.attribute(child,"archive");
00405             }
00406             else {
00407               WAR << "YUM <atom/package/pkgfiles/delta> contains the unknown element <"
00408                   << name << "> "
00409                 << _helper.positionInfo(child) << ", skipping" << endl;
00410             }
00411           }
00412         }
00413         dataPtr->deltaRpms.push_back(deltaRpm);
00414       }
00415       
00416       
00417       void
00418       YUMPatchParser::parsePkgBaseVersionNode(YUMBaseVersion *dataPtr,
00419                                                 xmlNodePtr formatNode)
00420       {
00421         dataPtr->epoch = _helper.attribute( formatNode, "epoch" );
00422         dataPtr->ver = _helper.attribute( formatNode, "ver" );
00423         dataPtr->rel = _helper.attribute( formatNode, "rel" );
00424         dataPtr->md5sum = _helper.attribute( formatNode, "md5sum" );
00425         dataPtr->buildtime = _helper.attribute( formatNode, "buildtime" );
00426         dataPtr->source_info = _helper.attribute( formatNode, "source-info" );
00427       }
00428       
00429       void
00430       YUMPatchParser::parsePkgFilesNode(YUMPatchPackage *dataPtr,
00431                                          xmlNodePtr formatNode)
00432       {
00433         for (xmlNodePtr child = formatNode->children; 
00434              child != 0;
00435              child = child ->next) {
00436           if (_helper.isElement(child)) {
00437             string name = _helper.name(child);
00438             if (name == "plainrpm") {
00439                 parsePkgPlainRpmNode( dataPtr, child );
00440             }
00441             else if (name == "patchrpm") {
00442                 parsePkgPatchRpmNode( dataPtr, child );
00443             }
00444             else if (name == "deltarpm") {
00445                 parsePkgDeltaRpmNode( dataPtr, child );
00446             }
00447             else {
00448               WAR << "YUM <atom/package/pkgfiles> contains the unknown element <"
00449                   << name << "> "
00450                 << _helper.positionInfo(child) << ", skipping" << endl;
00451             }
00452           }
00453         }
00454       }
00455       
00456       
00457       
00458       
00459       
00460       
00461       void
00462       YUMPatchParser::parsePackageNode(YUMPatchData_Ptr dataPtr,
00463                                      xmlNodePtr formatNode)
00464       {
00465         shared_ptr<YUMPatchPackage> package(new YUMPatchPackage);
00466         package->type = _helper.attribute(formatNode,"type");
00467         package->installOnly = false;
00468         package->media = "1";
00469       
00470         // FIXME move the respective method to a common class, inherit it  
00471         YUMPrimaryParser prim;
00472       
00473         for (xmlNodePtr child = formatNode->children; 
00474              child != 0;
00475              child = child ->next) {
00476           if (_helper.isElement(child)) {
00477             string name = _helper.name(child);
00478 XXX << "parsePackageNode(" << name << ")" << endl;
00479             if (name == "name") {
00480                 package->name = _helper.content(child);
00481             }
00482             else if (name == "arch") {
00483               package->arch = _helper.content(child);
00484             }
00485             else if (name == "version") {
00486               package->epoch = _helper.attribute(child,"epoch");
00487               package->ver = _helper.attribute(child,"ver");
00488               package->rel = _helper.attribute(child,"rel");
00489             }
00490             else if (name == "checksum") {
00491               package->checksumType = _helper.attribute(child,"type");
00492               package->checksumPkgid = _helper.attribute(child,"pkgid");
00493               package->checksum = _helper.content(child);
00494             }
00495             else if (name == "summary") {
00496               package->summary = _helper.content(child);
00497             }
00498             else if (name == "description") {
00499               package->description = _helper.content(child);
00500             }
00501             else if (name == "packager") {
00502               package->packager = _helper.content(child);
00503             }
00504             else if (name == "url") {
00505               package->url = _helper.content(child);
00506             }
00507             else if (name == "time") {
00508               package->timeFile = _helper.attribute(child,"file");
00509               package->timeBuild = _helper.attribute(child,"build");
00510             }
00511             else if (name == "size") {
00512               package->sizePackage = _helper.attribute(child,"package");
00513               package->sizeInstalled = _helper.attribute(child,"installed");
00514               package->sizeArchive = _helper.attribute(child,"archive");
00515             }
00516             else if (name == "location") {
00517               package->location = _helper.attribute(child,"href");
00518             }
00519             else if (name == "format") {
00520                 parseFormatNode (&*package, child);
00521             }
00522             else if (name == "pkgfiles")
00523             {
00524                 parsePkgFilesNode (&*package, child);
00525             }
00526             else if (name == "license-to-confirm")
00527             {
00528               package->license_to_confirm.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
00529             }
00530             else {
00531               WAR << "YUM <atoms/package> contains the unknown element <"
00532                   << name << "> "
00533                 << _helper.positionInfo(child) << ", skipping" << endl;
00534             }
00535           }
00536         }
00537         dataPtr->atoms.push_back(package);
00538       }
00539       
00540       void
00541       YUMPatchParser::parseScriptNode(YUMPatchData_Ptr dataPtr,
00542                                      xmlNodePtr formatNode)
00543       {
00544         shared_ptr<YUMPatchScript> script(new YUMPatchScript);
00545         script->do_media = "1";
00546         script->undo_media = "1";
00547       
00548         // FIXME move the respective method to a common class, inherit it  
00549         YUMPrimaryParser prim;
00550       
00551         for (xmlNodePtr child = formatNode->children; 
00552              child != 0;
00553              child = child ->next) {
00554           if (_helper.isElement(child)) {
00555             string name = _helper.name(child);
00556             if (name == "name") {
00557                 script->name = _helper.content(child);
00558             }
00559             else if (name == "version") {
00560               script->epoch = _helper.attribute(child,"epoch");
00561               script->ver = _helper.attribute(child,"ver");
00562               script->rel = _helper.attribute(child,"rel");
00563             }
00564             else if (name == "do") {
00565                 script->do_script = _helper.content(child);
00566             }
00567             else if (name == "undo") {
00568                 script->undo_script = _helper.content(child);
00569             }
00570             else if (name == "do-location") {
00571                 script->do_location = _helper.attribute(child,"href");
00572             }
00573             else if (name == "undo-location") {
00574                 script->undo_location = _helper.attribute(child,"href");
00575             }
00576             else if (name == "do-media") {
00577                 script->do_media = _helper.attribute(child,"mediaid");
00578             }
00579             else if (name == "undo-media") {
00580                 script->undo_media = _helper.attribute(child,"mediaid");
00581             }
00582             else if (name == "do-checksum") {
00583               script->do_checksum_type = _helper.attribute(child,"type");
00584               script->do_checksum = _helper.content(child);
00585             }
00586             else if (name == "undo-checksum") {
00587               script->undo_checksum_type = _helper.attribute(child,"type");
00588               script->undo_checksum = _helper.content(child);
00589             }
00590             else if (name == "provides") {
00591               prim.parseDependencyEntries(& script->provides, child);
00592             }
00593             else if (name == "conflicts") {
00594               prim.parseDependencyEntries(& script->conflicts, child);
00595             }
00596             else if (name == "obsoletes") {
00597               prim.parseDependencyEntries(& script->obsoletes, child);
00598             }
00599             else if (name == "requires") {
00600               prim.parseDependencyEntries(& script->requires, child);
00601             }
00602             else if (name == "prerequires") {
00603               prim.parseDependencyEntries(& script->prerequires, child);
00604             }
00605             else if (name == "recommends") {
00606               prim.parseDependencyEntries(& script->recommends, child);
00607             }
00608             else if (name == "suggests") {
00609               prim.parseDependencyEntries(& script->suggests, child);
00610             }
00611             else if (name == "supplements") {
00612               prim.parseDependencyEntries(& script->supplements, child);
00613             }
00614             else if (name == "enhances") {
00615               prim.parseDependencyEntries(& script->enhances, child);
00616             }
00617             else if (name == "freshens") {
00618               prim.parseDependencyEntries(& script->freshens, child);
00619             }
00620             else {
00621               WAR << "YUM <atoms/script> contains the unknown element <"
00622                   << name << "> "
00623                 << _helper.positionInfo(child) << ", skipping" << endl;
00624             }
00625           }
00626         }
00627         dataPtr->atoms.push_back(script);
00628       }
00629       
00630       void
00631       YUMPatchParser::parseMessageNode(YUMPatchData_Ptr dataPtr,
00632                                      xmlNodePtr formatNode)
00633       {
00634         shared_ptr<YUMPatchMessage> message(new YUMPatchMessage);
00635       
00636         // FIXME move the respective method to a common class, inherit it  
00637         YUMPrimaryParser prim;
00638       
00639         for (xmlNodePtr child = formatNode->children; 
00640              child != 0;
00641              child = child ->next) {
00642           if (_helper.isElement(child)) {
00643             string name = _helper.name(child);
00644             if (name == "name") {
00645               message->name = _helper.content(child);
00646             }
00647             else if (name == "version") {
00648               message->epoch = _helper.attribute(child,"epoch");
00649               message->ver = _helper.attribute(child,"ver");
00650               message->rel = _helper.attribute(child,"rel");
00651             }
00652             else if (name == "text") {
00653               message->text.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
00654             }
00655             else if (name == "provides") {
00656               prim.parseDependencyEntries(& message->provides, child);
00657             }
00658             else if (name == "conflicts") {
00659               prim.parseDependencyEntries(& message->conflicts, child);
00660             }
00661             else if (name == "obsoletes") {
00662               prim.parseDependencyEntries(& message->obsoletes, child);
00663             }
00664             else if (name == "prerequires") {
00665               prim.parseDependencyEntries(& message->prerequires, child);
00666             }
00667             else if (name == "requires") {
00668               prim.parseDependencyEntries(& message->requires, child);
00669             }
00670             else if (name == "recommends") {
00671               prim.parseDependencyEntries(& message->recommends, child);
00672             }
00673             else if (name == "suggests") {
00674               prim.parseDependencyEntries(& message->suggests, child);
00675             }
00676             else if (name == "supplements") {
00677               prim.parseDependencyEntries(& message->supplements, child);
00678             }
00679             else if (name == "enhances") {
00680               prim.parseDependencyEntries(& message->enhances, child);
00681             }
00682             else if (name == "freshens") {
00683               prim.parseDependencyEntries(& message->freshens, child);
00684             }
00685             else {
00686               WAR << "YUM <atoms/message> contains the unknown element <"
00687                   << name << "> "
00688                 << _helper.positionInfo(child) << ", skipping" << endl;
00689             }
00690           }
00691         }
00692         dataPtr->atoms.push_back(message);
00693       }
00694 
00695     } // namespace yum
00696   } // namespace parser
00697 } // namespace zypp

Generated on Thu Jul 6 00:07:21 2006 for zypp by  doxygen 1.4.6