pxml_utils.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#define ALLOWED_BALISE_CHAR "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:?!-"
 
#define ALLOWED_ATTRIBUTE_CHAR "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:-"
 
#include "pxml_utils.h"
 
 
PFileParser pxml_setXmlParser(const PString & fileContent, bool isSvg){
        PFileParser parser;
        parser.setSeparator("<>\"=");
        if(isSvg){
                parser.setWhiteSpace("");
        }else{
                parser.setWhiteSpace("\t\n ");
        }
        parser.setFileContent(fileContent);
        return parser;
}
 
 
bool pxml_parserFile(PXml & xml, const PPath & fileName, bool isSvg){
        return pxml_parserContent(xml, fileName.loadFileContent(), isSvg);
}
 
 
bool pxml_parserContent(PXml & xml, const PString & fileContent, bool isSvg){
        PFileParser parser(pxml_setXmlParser(fileContent, isSvg));
        xml.setName("root");
        
        return pxml_parserXmlContent(xml, parser, true);
        
//      return pxml_parserVecXml(xml.getVecChild(), parser, isSvg);
}
 
 
bool pxml_isAttributeEnd(PXml & parent, PFileParser & parser){
        if(parser.isMatch("/>")){
                parent.setIsCompact(true);
                return true;
        }else if(parser.isMatch(">")){
                parent.setIsCompact(false);
                return true;
        }else{
                return false;
        }
}
 
 
bool pxml_parserXmlAttribute(PXml & parent, PFileParser & parser){
        parser.setWhiteSpace(" \t\n");
        while(!pxml_isAttributeEnd(parent, parser) && !parser.isEndOfFile()){
                PString attributeName(parser.getStrComposedOf(ALLOWED_ATTRIBUTE_CHAR));
                if(attributeName == ""){
                        std::cerr << "pxml_parserXmlAttribute : error at : " << parser.getLocation() << std::endl;
                        std::cerr << "\tcannot parse the attributes name as '"<<parser.getNextToken()<<"'" << std::endl;
                        return false;
                }
                if(!parser.isMatch("=")){
                        std::cerr << "pxml_parserXmlAttribute : error at : " << parser.getLocation() << std::endl;
                        std::cerr << "\texpected '=' after attribute '"<<attributeName<<"'" << std::endl;
                        return false;
                }
                if(!parser.isMatch("\"")){
                        std::cerr << "pxml_parserXmlAttribute : error at : " << parser.getLocation() << std::endl;
                        std::cerr << "\texpected '\"' after attribute '"<<attributeName<<"='" << std::endl;
                        return false;
                }
                PString attributeValue(parser.getUntilKeyWithoutPatern("\""));
                PXmlAttr tmpAttribute;
                tmpAttribute.setName(attributeName);
                tmpAttribute.setValue(attributeValue);
                parent.getVecAttr().push_back(tmpAttribute);
        }
        parser.setWhiteSpace("");
        return true;
}
 
 
 
bool pxml_parserXmlContent(PXml & parent, PFileParser & parser, bool isMainBalise){
        parser.setSeparator("<>\"=");
        parser.setWhiteSpace("");
        PString balisePartialEnd("/" + parent.getName() + ">");
        PString baliseEnd("<" + balisePartialEnd);
        PXml text;
        text.setIsText(true);
        while(!parser.isMatch(baliseEnd) && !parser.isEndOfFile()){
                PString textString(parser.getUntilKeyWithoutPatern("<"));
                if(textString != ""){   //If the next token is not a < it is a text
                        text.getValue() += textString;
                        if(parent.getVecChild().size() == 0lu){
                                if(parser.isMatch(balisePartialEnd)){
                                        parent.setValue(text.getValue());
                                        return true;
                                }else{
                                        parent.getVecChild().push_back(text);
                                }
                        }else{
                                parent.getVecChild().push_back(text);
                        }
                        text.setValue("");      //Reset value for next one
                }
                if(parser.isEndOfFile()){
                        if(isMainBalise){
                                return true;
                        }else{
                                std::cerr << "pxml_parserXmlContent : error at : " << parser.getLocation() << std::endl;
                                std::cerr << "\tunexpected end of file. We are supposed to be in the balise '"<<parent.getName()<<"'" << std::endl;
                                return false;
                        }
                }
                if(parser.isMatch(balisePartialEnd)){   //We find the end of the balise
                        return true;
                }else{  //Or it can be another balise
                        PString childBaliseName(parser.getStrComposedOf(ALLOWED_BALISE_CHAR));
                        if(childBaliseName != ""){      //We find a new balise
                                PXml xml;
                                xml.setName(childBaliseName);
                                if(childBaliseName == "!--"){
                                        parser.getUntilKeyWithoutPatern("-->"); //Skip the comment
                                }else if(childBaliseName == "?xml"){
                                        parser.getUntilKeyWithoutPatern("?>");  //Skip the svg balise
                                }else{
                                        if(!pxml_parserXmlAttribute(xml, parser)){      //Let's parse the attribute
                                                std::cerr << "pxml_parserXmlContent : error at : " << parser.getLocation() << std::endl;
                                                std::cerr << "\tcannot parse the attributes of balise '"<<childBaliseName<<"'" << std::endl;
                                                return false;
                                        }
                                        if(!xml.getIsCompact()){
                                                //Let's parse the content
                                                if(!pxml_parserXmlContent(xml, parser, false)){
                                                        std::cerr << "pxml_parserXmlContent : error at : " << parser.getLocation() << std::endl;
                                                        std::cerr << "\tcannot parse balise '"<<childBaliseName<<"'" << std::endl;
                                                        return false;
                                                }
                                        }
                                        parent.getVecChild().push_back(xml);
                                }
                        }else if(parser.isMatch("/")){
                                std::cerr << "pxml_parserXmlContent : in balise '"<<parent.getName()<<"' unexpected '</' at : " << parser.getLocation() << std::endl;
                                return false;
                        }else{  //It was just a text <
                                text.getValue() += "<";
                        }
                }
        }
        return true;
}
 
 
 
 
 
 
 
 
bool pxml_getVecChildIfExist(PVecXml & vecMatch, const PXml & xml, const PString & childName){
        bool isFound(false);
        const PVecXml & vecChild = xml.getVecChild();
        for(PVecXml::const_iterator it(vecChild.begin()); it != vecChild.end(); ++it){
                if(it->getName() == childName){
                        vecMatch.push_back(*it);
                        isFound = true;
                }
        }
        return isFound;
}
 
 
bool pxml_getChildIfExist(PXml & match, const PXml & xml, const PString & childName){
        bool isSearched(true);
        const PVecXml & vecChild = xml.getVecChild();
        PVecXml::const_iterator it(vecChild.begin());
        while(it != vecChild.end() && isSearched){
                if(it->getName() == childName){
                        match = *it;
                        isSearched = false;
                }
                ++it;
        }
        return !isSearched;
}
 
 
PXml * pxml_getChildPtr(PXml & xml, const PString & childName){
        PXml * out = NULL;
        PVecXml & vecChild = xml.getVecChild();
        for(PVecXml::iterator it(vecChild.begin()); it != vecChild.end() && out == NULL; ++it){
                if(it->getName() == childName){
                        out = &(*it);
                }
        }
        return out;
}
 
 
bool pxml_getAttrIfExist(PXmlAttr & attr, const PXml & xml, const PString & attrName){
        bool isSearched(true);
        const PVecXmlAttr & vecAttr = xml.getVecAttr();
        PVecXmlAttr::const_iterator it(vecAttr.begin());
        while(it != vecAttr.end() && isSearched){
                if(it->getName() == attrName){
                        attr = *it;
                        isSearched = false;
                }
                ++it;
        }
        return !isSearched;
}
 
 
void pxml_setAttr(PXml & xml, const PString & nameAttr, const PString & valueAttr){
        bool isSearched(true);
        PVecXmlAttr & vecAttr = xml.getVecAttr();
        PVecXmlAttr::iterator it(vecAttr.begin());
        while(it != vecAttr.end() && isSearched){
                if(it->getName() == nameAttr){
                        it->setValue(valueAttr);
                        isSearched = false;
                }
                ++it;
        }
}
 
 
PXml pxml_eraseVecChild(const PXml & xml, const PString & childName){
        PXml out;
        out.setName(xml.getName());
        out.setValue(xml.getValue());
        out.setVecAttr(xml.getVecAttr());
        const PVecXml & vecXml = xml.getVecChild();
        for(PVecXml::const_iterator it(vecXml.begin()); it != vecXml.end(); ++it){
                if(it->getName() != childName){
                        out.getVecChild().push_back(*it);
                }
        }
        return out;
}
 
 
bool pxml_saveFile(const PPath & fileName, const PXml & xml, bool isSvg){
        PString body(pxml_baliseStr(xml, isSvg));
        return fileName.saveFileContent(body);
}
 
 
PString pxml_baliseStr(const PXml & xml, bool isSvg){
        PString body(""), name(xml.getName());
        PString baseXmlNewLine("\n");
        if(isSvg){
                baseXmlNewLine = "";
        }
        if(xml.getIsText()){
                body += xml.getValue();
        }else{
                if(name != ""){
                        body += "<";
                        body += name;
                        body += pxml_vecAttrStr(xml.getVecAttr(), isSvg);
                        
                        if(name == "?xml"){body += " ?>\n";}
                        else if(name == "!--"){body += " -->\n";}
                        else if(xml.getIsCompact()){
                                body += " />"+baseXmlNewLine;
                        }else{
                                body += ">"+baseXmlNewLine;
                                body += pxml_vecXmlStr(xml.getVecChild(), isSvg);
                                body += xml.getValue();
                                body += "</"+ name + ">" + baseXmlNewLine;
                        }
                }else{
                        
                        body += pxml_vecXmlStr(xml.getVecChild(), isSvg);
                }
        }
        return body;
}
 
 
PString pxml_vecXmlStr(const PVecXml & vecXml, bool isSvg){
        PString body("");
        for(PVecXml::const_iterator it(vecXml.begin()); it != vecXml.end(); ++it){
                body += pxml_baliseStr(*it, isSvg);
        }
        return body;
}
 
 
PString pxml_attrStr(const PXmlAttr & xmlAttr, bool isSvg){
        PString body(" ");
        body += xmlAttr.getName() + "=\"" + xmlAttr.getValue() + "\"";
        if(isSvg){
                body += "\n\t";
        }
        return body;
}
 
 
PString pxml_vecAttrStr(const PVecXmlAttr & vecXmlAttr, bool isSvg){
        if(vecXmlAttr.size() == 0lu){return "";}
        PString body("");
        for(PVecXmlAttr::const_iterator it(vecXmlAttr.begin()); it != vecXmlAttr.end(); ++it){
                body += pxml_attrStr(*it, isSvg);
        }
        return body;
}
 
 
PString pxml_getFullContent(const PXml & xml){
        const PVecXml & vecXml = xml.getVecChild();
        if(vecXml.size() != 0lu){
                return pxml_vecXmlStr(vecXml);
        }else{
                return xml.getValue();
        }
}