s10k/XmlTools/xmltools.cpp

#include "xmltools.h"

// Filters constructor
XmlTools::XmlTools(QString filesWildcard, XmlFilter filter, bool noBackups, bool noVerbose)
{
    this->filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);
    this->filters=filter;
    this->backupsEnabled=!noBackups;
    this->verboseEnabled=!noVerbose;

    if(this->filesToProcess.isEmpty()){
        UtilXmlTools::displayErrorMessage("Loading xml files","No XML files were found for the wildcard: "+filesWildcard);
    }
}

// XPath constructor
XmlTools::XmlTools(QString filesWildcard, QString xPathExpression, bool noBackups, bool noVerbose)
{
    this->filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);
    this->xPathExpression=xPathExpression;
    this->backupsEnabled=!noBackups;
    this->verboseEnabled=!noVerbose;
}

// Adds new values to an element
void XmlTools::addValues(QString newValues){

    try{
        // Process all XmlFiles
        for(int i=0; i<this->filesToProcess.size(); i++){

            QStringList newValuesList, currValuesList;
            QList<pugi::xml_node> elements;

            UtilXmlTools::loadXmlFile(this->filesToProcess[i],this->document,this->rootNode,this->backupsEnabled,this->verboseEnabled,"add-values");

            newValuesList=UtilXmlTools::qStringListFromSpacedString(newValues);

            // Check how the elements will be fetched via element name or xpath expression
            if(this->xPathExpression==""){
                UtilXmlTools::getAllNamedElements(this->rootNode,elements,this->filters);
            }
            else{
                UtilXmlTools::getAllXpathElements(this->xPathExpression,this->document,elements);
            }

            for(int j=0; j<elements.size(); j++){

                currValuesList=UtilXmlTools::qStringListFromSpacedString(QSTR_TO_CSTR(elements[j].text().as_string())); // convert each element in a list (uses space as separator)

                for(int k=0; k<newValuesList.size(); k++){
                    if(currValuesList.contains(newValuesList[k])){ // If the current element already contains this value proceed to the next
                        continue;
                    }

                    elements[j].text() = QSTR_TO_CSTR( QString(elements[j].text().as_string()) + " " + newValuesList[k] ); // If it doesn't exists yet let's add it
                }
            }

            UtilXmlTools::saveXmlFile(this->filesToProcess[i],this->document,"add-values");
        }
    }
    catch(const std::exception &e){
        UtilXmlTools::displayErrorMessage("add-values", QString("An exception was caught: ") + e.what());
    }

    UtilXmlTools::displaySuccessMessage(this->filesToProcess.size(), "add-values");

}

void XmlTools::removeValues(QString valuesToRemove){

    try{
        // Process all XmlFiles
        for(int i=0; i<this->filesToProcess.size(); i++){

            QList<pugi::xml_node> elements;
            QStringList valuesToRemoveList, currValuesList;
            bool elementChanged=false;

            UtilXmlTools::loadXmlFile(this->filesToProcess[i],this->document,this->rootNode,this->backupsEnabled, this->verboseEnabled, "remove-values");

            // Check how the elements will be fetched via element name or xpath expression
            if(this->xPathExpression==""){
                UtilXmlTools::getAllNamedElements(this->rootNode,elements,this->filters);
            }
            else{
                UtilXmlTools::getAllXpathElements(this->xPathExpression,this->document,elements);
            }

            valuesToRemoveList=UtilXmlTools::qStringListFromSpacedString(valuesToRemove);

            for(int j=0; j<elements.size(); j++){ // O(3)... Optimization may be necessary.
                currValuesList=UtilXmlTools::qStringListFromSpacedString(QSTR_TO_CSTR(elements[j].text().as_string())); // convert each element in a list (uses space as separator)

                for(int k=0; k<currValuesList.size(); k++){
                    for(int m=0; m<valuesToRemoveList.size(); m++){
                        if(currValuesList[k]==valuesToRemoveList[m]){
                            currValuesList[k]=""; // flag to deletion
                            elementChanged=true;
                        }
                    }
                }

                if(elementChanged){ // If curr element changed update the XML
                    currValuesList.removeAll(""); // remove all files flagged to deletion
                    elements[j].text()=currValuesList.join(' ').toUtf8().constData();
                    elementChanged=false;
                }
            }

            UtilXmlTools::saveXmlFile(this->filesToProcess[i],this->document, "remove-values");
        }
    }
    catch(const std::exception &e){
        UtilXmlTools::displayErrorMessage("remove-values", QString("An exception was caught: ") + e.what());
    }

    UtilXmlTools::displaySuccessMessage(this->filesToProcess.size(),"remove-values");
}

void XmlTools::replaceValue(QString oldValue, QString newValue){

    try{
        // Process all XmlFiles
        for(int i=0; i<this->filesToProcess.size(); i++){

            QList<pugi::xml_node> elements;
            QStringList currValuesList;
            bool elementChanged=false;

            UtilXmlTools::loadXmlFile(this->filesToProcess[i],this->document,this->rootNode,this->backupsEnabled, this->verboseEnabled, "replace-value");

            // Check how the elements will be fetched via element name or xpath expression
            if(this->xPathExpression==""){
                UtilXmlTools::getAllNamedElements(this->rootNode,elements,this->filters);
            }
            else{
                UtilXmlTools::getAllXpathElements(this->xPathExpression,this->document,elements);
            }

            for(int j=0; j<elements.size(); j++){
                currValuesList=UtilXmlTools::qStringListFromSpacedString(QSTR_TO_CSTR(elements[j].text().as_string())); // convert each element in a list (uses space as separator)

                for(int k=0; k<currValuesList.size(); k++){
                    if(currValuesList[k]==oldValue){ // Found a match with the old value?
                        currValuesList[k]=newValue; // If found replace it with the new value
                        elementChanged=true;
                    }
                }

                if(elementChanged){ // If curr element changed update the XML
                    elements[j].text()=currValuesList.join(" ").toUtf8().constData();
                }
                elementChanged=false;
            }

            UtilXmlTools::saveXmlFile(this->filesToProcess[i],this->document, "replace-value");
        }
    }
    catch(const std::exception &e){
        UtilXmlTools::displayErrorMessage("replace-value", QString("An exception was caught: ") + e.what());
    }

    UtilXmlTools::displaySuccessMessage(this->filesToProcess.size(), "replace-value");
}

// Replaces all current values of an element by another (can be specified only specific positions)
void XmlTools::replaceAll(QString value, QString valuePositions){

    try{
        // Process all XmlFiles
        for(int i=0; i<this->filesToProcess.size(); i++){

            QList<pugi::xml_node> elements;

            UtilXmlTools::loadXmlFile(this->filesToProcess[i],this->document,this->rootNode,this->backupsEnabled, this->verboseEnabled, "replace-all");

            // Check how the elements will be fetched via element name or xpath expression
            if(this->xPathExpression==""){
                UtilXmlTools::getAllNamedElements(this->rootNode,elements,this->filters);
            }
            else{
                UtilXmlTools::getAllXpathElements(this->xPathExpression,this->document,elements);
            }


            // Let's start the override
            for(int j=0; j<elements.size(); j++){
                if(valuePositions!=""){
                    elements[j].text()=replaceSpecificPositions(value, QSTR_TO_CSTR(elements[j].text().as_string()),valuePositions).toUtf8().constData();
                }
                else{
                    elements[j].text()=value.toUtf8().constData();
                }
            }

            UtilXmlTools::saveXmlFile(this->filesToProcess[i],this->document, "replace-all");
        }
    }
    catch(const std::exception &e){
        UtilXmlTools::displayErrorMessage("replace-all", QString("An exception was caught: ") + e.what());
    }

    UtilXmlTools::displaySuccessMessage(this->filesToProcess.size(), "replace-all");
}

// Update a set of XML elements values based in the difference between the old and new value
// This can be used in multiple files if the difference between one file and other are the same e.g. increment to all current object positions 100 in y (A difference of -100).
// E.g. oldValue=5 , newValue=7; diffBetweenOldAndNewValue=-2
void XmlTools::updateElements(QString diffBetweenOldAndNewValue){

    try{
        // Process all XmlFiles
        for(int i=0; i<this->filesToProcess.size(); i++){

            QList<pugi::xml_node> elements;
            MultiDimVar lastXmlValue(0); // inicialize with any value or dimension
            MultiDimVar currXmlValue(0);
            MultiDimVar newXmlValue(0); // value that will update currValue

            UtilXmlTools::loadXmlFile(this->filesToProcess[i],this->document,this->rootNode,this->backupsEnabled,this->verboseEnabled, "update-elements");

            // Check how the elements will be fetched via element name or xpath expression
            if(this->xPathExpression==""){
                UtilXmlTools::getAllNamedElements(this->rootNode,elements,this->filters);
            }
            else{
                UtilXmlTools::getAllXpathElements(this->xPathExpression,this->document,elements);
            }

            if(elements.size() > 0){

                lastXmlValue=MultiDimVar(QSTR_TO_CSTR(elements[0].text().as_string())); // the lastXmlValue will begin to be the first one of the node
                newXmlValue=MultiDimVar::sub(lastXmlValue, MultiDimVar(diffBetweenOldAndNewValue));
                elements[0].text() = newXmlValue.toString().toUtf8().constData(); // update the first element with the new one already

                // If we have more than 1 element
                if(elements.size()>1){
                    currXmlValue=MultiDimVar(QSTR_TO_CSTR(elements[1].text().as_string())); // the currXmlValue will begin to be the second one of the node

                    // Let's start the node update
                    for(int j=1; j<elements.size()-1; j++){ // We start in 1 because the 0 is already saved in lastXmlValue // -1 because we will also work with the next one in the current

                        newXmlValue=MultiDimVar::sum(newXmlValue,MultiDimVar::sub(currXmlValue,lastXmlValue));
                        elements[j].text() = newXmlValue.toString().toUtf8().constData(); // update element with the new value
                        lastXmlValue=currXmlValue;
                        currXmlValue=MultiDimVar(QSTR_TO_CSTR(elements[j+1].text().as_string()));

                    }

                    // To update too last element (avoid out of bound because i+1)
                    newXmlValue=MultiDimVar::sum(newXmlValue,MultiDimVar::sub(currXmlValue,lastXmlValue));
                    elements[elements.size()-1].text() = newXmlValue.toString().toUtf8().constData(); // update element with the new value
                }
            }

            UtilXmlTools::saveXmlFile(this->filesToProcess[i],this->document, "update-elements");
        }
    }
    catch(const std::exception &e){
        UtilXmlTools::displayErrorMessage("update-elements", QString("An exception was caught: ") + e.what());
    }

    UtilXmlTools::displaySuccessMessage(this->filesToProcess.size(),"update-elements");

}

// Invert a set of XML elements with specified name (and optionally a parent name)
void XmlTools::invertElements(){

    try{
        // Process all XmlFiles
        for(int i=0; i<this->filesToProcess.size(); i++){
            UtilXmlTools::loadXmlFile(this->filesToProcess[i],this->document,this->rootNode,this->backupsEnabled, this->verboseEnabled, "invert-elements");

            QList<pugi::xml_node> elements;
            QStringList invertedElements; //Inverting the element order

            // Check how the elements will be fetched via element name or xpath expression
            if(this->xPathExpression==""){
                UtilXmlTools::getAllNamedElements(this->rootNode,elements,this->filters);
            }
            else{
                UtilXmlTools::getAllXpathElements(this->xPathExpression,this->document,elements);
            }

            // Read all elements and save to the list
            for(int j=elements.size()-1; j>=0; j--){
                invertedElements << QSTR_TO_CSTR(elements[j].text().as_string());
            }

            // Override the tree with the inverted order
            for(int j=0; j<elements.size(); j++){
                elements[j].text()= invertedElements[j].toUtf8().constData();
            }

            UtilXmlTools::saveXmlFile(this->filesToProcess[i],this->document, "invert-elements");
        }
    }
    catch(const std::exception &e){
        UtilXmlTools::displayErrorMessage("invert-elements", QString("An exception was caught: ") + e.what());
    }

    UtilXmlTools::displaySuccessMessage(this->filesToProcess.size(),"invert-elements");

}

// Replaces specific values (given the position) for a new value
// [ currValues / positionsToReplaced are strings with composed by another strings space separated ]
// Returns a new string (space separated) will values replaced
QString XmlTools::replaceSpecificPositions(const QString &newValue, const QString &currValues, const QString &positionsToReplace){

    QList<int> positionsToReplaceList;
    QStringList currValuesList;

    positionsToReplaceList=UtilXmlTools::qListIntFromSpacedString(positionsToReplace);
    currValuesList=UtilXmlTools::qStringListFromSpacedString(currValues);

    // Make some validation before the replacing
    if(currValuesList.size()<positionsToReplaceList.size()){
        UtilXmlTools::displayErrorMessage("replaceSpecificPositions","There are more positions to replace than the current xml values.");
    }

    foreach(int pos, positionsToReplaceList){
        if(pos>currValuesList.size()-1 || pos < 0){ //Are positions valid for the current values? //-1 because starts at 0
            UtilXmlTools::displayErrorMessage("replaceSpecificPositions","One or more of the specified positions to replace are out of range.");
        }
    }
    //

    // Finally replace the specified values
    foreach(int pos, positionsToReplaceList){
        currValuesList[pos]=newValue;
    }

    return currValuesList.join(" ");

}
Revision:	1073
Committed:	Thu Oct 5 17:48:32 2017 UTC (8 years, 1 month ago) by s10k
Content type:	text/x-c++src
File size:	15185 byte(s)
Log Message:	added XML Tools latest version (2.0d) and s10k's common libs
#	Content
1	#include "xmltools.h"
2
3	// Filters constructor
4	XmlTools::XmlTools(QString filesWildcard, XmlFilter filter, bool noBackups, bool noVerbose)
5	{
6	this->filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);
7	this->filters=filter;
8	this->backupsEnabled=!noBackups;
9	this->verboseEnabled=!noVerbose;
10
11	if(this->filesToProcess.isEmpty()){
12	UtilXmlTools::displayErrorMessage("Loading xml files","No XML files were found for the wildcard: "+filesWildcard);
13	}
14	}
15
16	// XPath constructor
17	XmlTools::XmlTools(QString filesWildcard, QString xPathExpression, bool noBackups, bool noVerbose)
18	{
19	this->filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);
20	this->xPathExpression=xPathExpression;
21	this->backupsEnabled=!noBackups;
22	this->verboseEnabled=!noVerbose;
23	}
24
25	// Adds new values to an element
26	void XmlTools::addValues(QString newValues){
27
28	try{
29	// Process all XmlFiles
30	for(int i=0; i<this->filesToProcess.size(); i++){
31
32	QStringList newValuesList, currValuesList;
33	QList<pugi::xml_node> elements;
34
35	UtilXmlTools::loadXmlFile(this->filesToProcess[i],this->document,this->rootNode,this->backupsEnabled,this->verboseEnabled,"add-values");
36
37	newValuesList=UtilXmlTools::qStringListFromSpacedString(newValues);
38
39	// Check how the elements will be fetched via element name or xpath expression
40	if(this->xPathExpression==""){
41	UtilXmlTools::getAllNamedElements(this->rootNode,elements,this->filters);
42	}
43	else{
44	UtilXmlTools::getAllXpathElements(this->xPathExpression,this->document,elements);
45	}
46
47	for(int j=0; j<elements.size(); j++){
48
49	currValuesList=UtilXmlTools::qStringListFromSpacedString(QSTR_TO_CSTR(elements[j].text().as_string())); // convert each element in a list (uses space as separator)
50
51	for(int k=0; k<newValuesList.size(); k++){
52	if(currValuesList.contains(newValuesList[k])){ // If the current element already contains this value proceed to the next
53	continue;
54	}
55
56	elements[j].text() = QSTR_TO_CSTR( QString(elements[j].text().as_string()) + " " + newValuesList[k] ); // If it doesn't exists yet let's add it
57	}
58	}
59
60	UtilXmlTools::saveXmlFile(this->filesToProcess[i],this->document,"add-values");
61	}
62	}
63	catch(const std::exception &e){
64	UtilXmlTools::displayErrorMessage("add-values", QString("An exception was caught: ") + e.what());
65	}
66
67	UtilXmlTools::displaySuccessMessage(this->filesToProcess.size(), "add-values");
68
69	}
70
71	void XmlTools::removeValues(QString valuesToRemove){
72
73	try{
74	// Process all XmlFiles
75	for(int i=0; i<this->filesToProcess.size(); i++){
76
77	QList<pugi::xml_node> elements;
78	QStringList valuesToRemoveList, currValuesList;
79	bool elementChanged=false;
80
81	UtilXmlTools::loadXmlFile(this->filesToProcess[i],this->document,this->rootNode,this->backupsEnabled, this->verboseEnabled, "remove-values");
82
83	// Check how the elements will be fetched via element name or xpath expression
84	if(this->xPathExpression==""){
85	UtilXmlTools::getAllNamedElements(this->rootNode,elements,this->filters);
86	}
87	else{
88	UtilXmlTools::getAllXpathElements(this->xPathExpression,this->document,elements);
89	}
90
91	valuesToRemoveList=UtilXmlTools::qStringListFromSpacedString(valuesToRemove);
92
93	for(int j=0; j<elements.size(); j++){ // O(3)... Optimization may be necessary.
94	currValuesList=UtilXmlTools::qStringListFromSpacedString(QSTR_TO_CSTR(elements[j].text().as_string())); // convert each element in a list (uses space as separator)
95
96	for(int k=0; k<currValuesList.size(); k++){
97	for(int m=0; m<valuesToRemoveList.size(); m++){
98	if(currValuesList[k]==valuesToRemoveList[m]){
99	currValuesList[k]=""; // flag to deletion
100	elementChanged=true;
101	}
102	}
103	}
104
105	if(elementChanged){ // If curr element changed update the XML
106	currValuesList.removeAll(""); // remove all files flagged to deletion
107	elements[j].text()=currValuesList.join(' ').toUtf8().constData();
108	elementChanged=false;
109	}
110	}
111
112	UtilXmlTools::saveXmlFile(this->filesToProcess[i],this->document, "remove-values");
113	}
114	}
115	catch(const std::exception &e){
116	UtilXmlTools::displayErrorMessage("remove-values", QString("An exception was caught: ") + e.what());
117	}
118
119	UtilXmlTools::displaySuccessMessage(this->filesToProcess.size(),"remove-values");
120	}
121
122	void XmlTools::replaceValue(QString oldValue, QString newValue){
123
124	try{
125	// Process all XmlFiles
126	for(int i=0; i<this->filesToProcess.size(); i++){
127
128	QList<pugi::xml_node> elements;
129	QStringList currValuesList;
130	bool elementChanged=false;
131
132	UtilXmlTools::loadXmlFile(this->filesToProcess[i],this->document,this->rootNode,this->backupsEnabled, this->verboseEnabled, "replace-value");
133
134	// Check how the elements will be fetched via element name or xpath expression
135	if(this->xPathExpression==""){
136	UtilXmlTools::getAllNamedElements(this->rootNode,elements,this->filters);
137	}
138	else{
139	UtilXmlTools::getAllXpathElements(this->xPathExpression,this->document,elements);
140	}
141
142	for(int j=0; j<elements.size(); j++){
143	currValuesList=UtilXmlTools::qStringListFromSpacedString(QSTR_TO_CSTR(elements[j].text().as_string())); // convert each element in a list (uses space as separator)
144
145	for(int k=0; k<currValuesList.size(); k++){
146	if(currValuesList[k]==oldValue){ // Found a match with the old value?
147	currValuesList[k]=newValue; // If found replace it with the new value
148	elementChanged=true;
149	}
150	}
151
152	if(elementChanged){ // If curr element changed update the XML
153	elements[j].text()=currValuesList.join(" ").toUtf8().constData();
154	}
155	elementChanged=false;
156	}
157
158	UtilXmlTools::saveXmlFile(this->filesToProcess[i],this->document, "replace-value");
159	}
160	}
161	catch(const std::exception &e){
162	UtilXmlTools::displayErrorMessage("replace-value", QString("An exception was caught: ") + e.what());
163	}
164
165	UtilXmlTools::displaySuccessMessage(this->filesToProcess.size(), "replace-value");
166	}
167
168	// Replaces all current values of an element by another (can be specified only specific positions)
169	void XmlTools::replaceAll(QString value, QString valuePositions){
170
171	try{
172	// Process all XmlFiles
173	for(int i=0; i<this->filesToProcess.size(); i++){
174
175	QList<pugi::xml_node> elements;
176
177	UtilXmlTools::loadXmlFile(this->filesToProcess[i],this->document,this->rootNode,this->backupsEnabled, this->verboseEnabled, "replace-all");
178
179	// Check how the elements will be fetched via element name or xpath expression
180	if(this->xPathExpression==""){
181	UtilXmlTools::getAllNamedElements(this->rootNode,elements,this->filters);
182	}
183	else{
184	UtilXmlTools::getAllXpathElements(this->xPathExpression,this->document,elements);
185	}
186
187
188	// Let's start the override
189	for(int j=0; j<elements.size(); j++){
190	if(valuePositions!=""){
191	elements[j].text()=replaceSpecificPositions(value, QSTR_TO_CSTR(elements[j].text().as_string()),valuePositions).toUtf8().constData();
192	}
193	else{
194	elements[j].text()=value.toUtf8().constData();
195	}
196	}
197
198	UtilXmlTools::saveXmlFile(this->filesToProcess[i],this->document, "replace-all");
199	}
200	}
201	catch(const std::exception &e){
202	UtilXmlTools::displayErrorMessage("replace-all", QString("An exception was caught: ") + e.what());
203	}
204
205	UtilXmlTools::displaySuccessMessage(this->filesToProcess.size(), "replace-all");
206	}
207
208	// Update a set of XML elements values based in the difference between the old and new value
209	// This can be used in multiple files if the difference between one file and other are the same e.g. increment to all current object positions 100 in y (A difference of -100).
210	// E.g. oldValue=5 , newValue=7; diffBetweenOldAndNewValue=-2
211	void XmlTools::updateElements(QString diffBetweenOldAndNewValue){
212
213	try{
214	// Process all XmlFiles
215	for(int i=0; i<this->filesToProcess.size(); i++){
216
217	QList<pugi::xml_node> elements;
218	MultiDimVar lastXmlValue(0); // inicialize with any value or dimension
219	MultiDimVar currXmlValue(0);
220	MultiDimVar newXmlValue(0); // value that will update currValue
221
222	UtilXmlTools::loadXmlFile(this->filesToProcess[i],this->document,this->rootNode,this->backupsEnabled,this->verboseEnabled, "update-elements");
223
224	// Check how the elements will be fetched via element name or xpath expression
225	if(this->xPathExpression==""){
226	UtilXmlTools::getAllNamedElements(this->rootNode,elements,this->filters);
227	}
228	else{
229	UtilXmlTools::getAllXpathElements(this->xPathExpression,this->document,elements);
230	}
231
232	if(elements.size() > 0){
233
234	lastXmlValue=MultiDimVar(QSTR_TO_CSTR(elements[0].text().as_string())); // the lastXmlValue will begin to be the first one of the node
235	newXmlValue=MultiDimVar::sub(lastXmlValue, MultiDimVar(diffBetweenOldAndNewValue));
236	elements[0].text() = newXmlValue.toString().toUtf8().constData(); // update the first element with the new one already
237
238	// If we have more than 1 element
239	if(elements.size()>1){
240	currXmlValue=MultiDimVar(QSTR_TO_CSTR(elements[1].text().as_string())); // the currXmlValue will begin to be the second one of the node
241
242	// Let's start the node update
243	for(int j=1; j<elements.size()-1; j++){ // We start in 1 because the 0 is already saved in lastXmlValue // -1 because we will also work with the next one in the current
244
245	newXmlValue=MultiDimVar::sum(newXmlValue,MultiDimVar::sub(currXmlValue,lastXmlValue));
246	elements[j].text() = newXmlValue.toString().toUtf8().constData(); // update element with the new value
247	lastXmlValue=currXmlValue;
248	currXmlValue=MultiDimVar(QSTR_TO_CSTR(elements[j+1].text().as_string()));
249
250	}
251
252	// To update too last element (avoid out of bound because i+1)
253	newXmlValue=MultiDimVar::sum(newXmlValue,MultiDimVar::sub(currXmlValue,lastXmlValue));
254	elements[elements.size()-1].text() = newXmlValue.toString().toUtf8().constData(); // update element with the new value
255	}
256	}
257
258	UtilXmlTools::saveXmlFile(this->filesToProcess[i],this->document, "update-elements");
259	}
260	}
261	catch(const std::exception &e){
262	UtilXmlTools::displayErrorMessage("update-elements", QString("An exception was caught: ") + e.what());
263	}
264
265	UtilXmlTools::displaySuccessMessage(this->filesToProcess.size(),"update-elements");
266
267	}
268
269	// Invert a set of XML elements with specified name (and optionally a parent name)
270	void XmlTools::invertElements(){
271
272	try{
273	// Process all XmlFiles
274	for(int i=0; i<this->filesToProcess.size(); i++){
275	UtilXmlTools::loadXmlFile(this->filesToProcess[i],this->document,this->rootNode,this->backupsEnabled, this->verboseEnabled, "invert-elements");
276
277	QList<pugi::xml_node> elements;
278	QStringList invertedElements; //Inverting the element order
279
280	// Check how the elements will be fetched via element name or xpath expression
281	if(this->xPathExpression==""){
282	UtilXmlTools::getAllNamedElements(this->rootNode,elements,this->filters);
283	}
284	else{
285	UtilXmlTools::getAllXpathElements(this->xPathExpression,this->document,elements);
286	}
287
288	// Read all elements and save to the list
289	for(int j=elements.size()-1; j>=0; j--){
290	invertedElements << QSTR_TO_CSTR(elements[j].text().as_string());
291	}
292
293	// Override the tree with the inverted order
294	for(int j=0; j<elements.size(); j++){
295	elements[j].text()= invertedElements[j].toUtf8().constData();
296	}
297
298	UtilXmlTools::saveXmlFile(this->filesToProcess[i],this->document, "invert-elements");
299	}
300	}
301	catch(const std::exception &e){
302	UtilXmlTools::displayErrorMessage("invert-elements", QString("An exception was caught: ") + e.what());
303	}
304
305	UtilXmlTools::displaySuccessMessage(this->filesToProcess.size(),"invert-elements");
306
307	}
308
309	// Replaces specific values (given the position) for a new value
310	// [ currValues / positionsToReplaced are strings with composed by another strings space separated ]
311	// Returns a new string (space separated) will values replaced
312	QString XmlTools::replaceSpecificPositions(const QString &newValue, const QString &currValues, const QString &positionsToReplace){
313
314	QList<int> positionsToReplaceList;
315	QStringList currValuesList;
316
317	positionsToReplaceList=UtilXmlTools::qListIntFromSpacedString(positionsToReplace);
318	currValuesList=UtilXmlTools::qStringListFromSpacedString(currValues);
319
320	// Make some validation before the replacing
321	if(currValuesList.size()<positionsToReplaceList.size()){
322	UtilXmlTools::displayErrorMessage("replaceSpecificPositions","There are more positions to replace than the current xml values.");
323	}
324
325	foreach(int pos, positionsToReplaceList){
326	if(pos>currValuesList.size()-1 \|\| pos < 0){ //Are positions valid for the current values? //-1 because starts at 0
327	UtilXmlTools::displayErrorMessage("replaceSpecificPositions","One or more of the specified positions to replace are out of range.");
328	}
329	}
330	//
331
332	// Finally replace the specified values
333	foreach(int pos, positionsToReplaceList){
334	currValuesList[pos]=newValue;
335	}
336
337	return currValuesList.join(" ");
338
339	}