XMLPatchParser.cc

Go to the documentation of this file.
00001 /*---------------------------------------------------------------------\
00002 |                          ____ _   __ __ ___                          |
00003 |                         |__  / \ / / . \ . \                         |
00004 |                           / / \ V /|  _/  _/                         |
00005 |                          / /__ | | | | | |                           |
00006 |                         /_____||_| |_| |_|                           |
00007 |                                                                      |
00008 \---------------------------------------------------------------------*/
00013 #include <zypp/parser/xmlstore/XMLPatchParser.h>
00014 
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/xmlstore/schemanames.h>
00023 
00024 using namespace std;
00025 
00026 namespace zypp {
00027   namespace parser {
00028     namespace xmlstore {
00029 
00030       XMLPatchParser::~XMLPatchParser()
00031       { }
00032       
00033       XMLPatchParser::XMLPatchParser(istream &is, const string& baseUrl)
00034         : XMLNodeIterator<XMLPatchData_Ptr>(is, baseUrl ,PATCHSCHEMA)
00035       {
00036         fetchNext();
00037       }
00038       
00039       XMLPatchParser::XMLPatchParser()
00040       { }
00041       
00042       XMLPatchParser::XMLPatchParser(XMLPatchData_Ptr& entry)
00043       : XMLNodeIterator<XMLPatchData_Ptr>(entry)
00044       { }
00045       
00046       
00047       // select for which elements process() will be called
00048       bool 
00049       XMLPatchParser::isInterested(const xmlNodePtr nodePtr)
00050       {
00051         return _helper.isElement(nodePtr) && _helper.name(nodePtr) == "patch";
00052       }
00053       
00054       // do the actual processing
00055       XMLPatchData_Ptr
00056       XMLPatchParser::process(const xmlTextReaderPtr reader)
00057       {
00058         xml_assert(reader);
00059         XMLPatchData_Ptr patchPtr = new XMLPatchData();
00060         xmlNodePtr dataNode = xmlTextReaderExpand(reader);
00061         xml_assert(dataNode);
00062         
00063         // default values for optional entries
00064         patchPtr->rebootNeeded = false;
00065         patchPtr->packageManager = false;
00066       
00067         parseResObjectCommonData( patchPtr, dataNode);
00068         parseDependencies( patchPtr, dataNode);
00069         
00070         for (xmlNodePtr child = dataNode->children; child && child != dataNode; child = child->next)
00071         {
00072           if (_helper.isElement(child))
00073           {
00074             string name = _helper.name(child);
00075             
00076             if (name == "id") {
00077               patchPtr->patchId = _helper.content(child);
00078             }
00079             else if (name == "timestamp") {
00080               patchPtr->timestamp = _helper.content(child);
00081             }
00082             else if (name == "category") {
00083               patchPtr->category = _helper.content(child);
00084             }
00085             else if (name == "reboot-needed") {
00086               patchPtr->rebootNeeded = (_helper.content(child) == "true") ? true : false;
00087             }
00088             else if (name == "affects-package-manager") {
00089               patchPtr->packageManager = (_helper.content(child) == "true") ? true : false;
00090             }
00091             else if (name == "interactive") {
00092               patchPtr->interactive = (_helper.content(child) == "true") ? true : false;
00093             }
00094             else if (name == "atoms") {
00095               parseAtomsNode(patchPtr, child);
00096             }
00097           }
00098         }
00099         return patchPtr;
00100       } /* end process */
00101       
00102       
00103       void 
00104       XMLPatchParser::parseAtomsNode(XMLPatchData_Ptr dataPtr, xmlNodePtr formatNode)
00105       {
00106         xml_assert(formatNode);
00107         for (xmlNodePtr child = formatNode->children; child != 0; child = child ->next)
00108         {
00109           if (_helper.isElement(child))
00110           {
00111             string name = _helper.name(child);
00112             XXX << "parseAtomsNode(" << name << ")" << endl;
00113             if (name == "atom")
00114             {
00115                 parseAtomNode (dataPtr, child);
00116             }
00117             else if (name == "script")
00118             {
00119                 parseScriptNode (dataPtr, child);
00120             }
00121             else if (name == "message")
00122             {
00123                 parseMessageNode (dataPtr, child);
00124             }
00125           }
00126         }
00127       } 
00128     
00129       void
00130       XMLPatchParser::parseAtomNode(XMLPatchData_Ptr dataPtr, xmlNodePtr formatNode)
00131       {
00132         XMLPatchAtomData_Ptr atom(new XMLPatchAtomData);
00133         // inject dependencies and other stuff
00134         parseResObjectCommonData( atom, formatNode);
00135         parseDependencies( atom, formatNode);
00136               
00137         dataPtr->atoms.push_back(atom);
00138       }
00139       
00140       void
00141       XMLPatchParser::parseScriptNode(XMLPatchData_Ptr dataPtr, xmlNodePtr formatNode)
00142       {
00143         XMLPatchScriptData_Ptr script(new XMLPatchScriptData);
00144         
00145         parseResObjectCommonData( script, formatNode);
00146         parseDependencies( script, formatNode);
00147         
00148         for (xmlNodePtr child = formatNode->children;  child != 0; child = child ->next)
00149         { 
00150           if (_helper.isElement(child))
00151           {
00152             string name = _helper.name(child);
00153             if (name == "do") {
00154               script->do_script = _helper.content(child);
00155             }
00156             else if (name == "undo")
00157             {
00158               script->undo_script = _helper.content(child);
00159             }
00160           }
00161         }
00162         dataPtr->atoms.push_back(script);
00163       }
00164       
00165       void
00166       XMLPatchParser::parseMessageNode(XMLPatchData_Ptr dataPtr, xmlNodePtr formatNode)
00167       {
00168         XMLPatchMessageData_Ptr message(new XMLPatchMessageData);
00169         
00170         parseResObjectCommonData( message, formatNode);
00171         parseDependencies( message, formatNode);
00172         
00173         for (xmlNodePtr child = formatNode->children;  child != 0; child = child ->next)
00174         {
00175           if (_helper.isElement(child))
00176           {
00177             string name = _helper.name(child);
00178             if (name == "text") {
00179               message->text.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
00180             }
00181           }
00182         }        
00183         dataPtr->atoms.push_back(message);
00184       }
00185 
00186     } // namespace yum
00187   } // namespace parser
00188 } // namespace zypp

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