host/c%2B%2B/SysMon.cpp

/* 
 * i-scream central monitoring system
 * http://www.i-scream.org.uk
 * Copyright (C) 2000-2002 i-scream
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#include "SysMon.h"

SysMon::SysMon( Config config, int printDebug){
        // debugging on?
        debug = printDebug;
        
        if ( debug == 1 ){
                std::cout << "SysMon::Constructor\n";
        }
        
        // setup some standard variables
        sequence = 0; // no packets sent yet
        
        // setup our arrays
        titlepointer = 0;
        for ( int i=0; i < max_titles; i++ ){
                titles[i] = "";
                values[i] = "";
        }
        
        checks = 0;
        
} // constructor

int SysMon::collect(){
        if ( debug == 1 ){
                std::cout << "SysMon::collect()\n";
        } // if
        
        // say we have checked again
        checks++;
        
        // collect the system data and place it in an array of strings.
        // presume that the data is all formtted correctly.

        if ( debug == 1 ){
                std::cout << "SysMon::collect::ipipestream\n";
        }

        p = new SubPipe("./statgrab.pl");
        
        // get the output into input from statgrab
        string sinput;
        while ( p->getLine(&sinput) == 0 ){
                
                if ( titlepointer == max_titles ){
                    std::cout << "WARNING: Max Titles reached, skipping remaining" << endl;
                    std::cout << "Try recompiling with a value greater than the current (" << max_titles << ")" << endl;
                    titlepointer--;
                    break;
                } // if
                
                // locate the first white space
                int found = sinput.find(" ",0);
                if ( found == string::npos ){
                        // error
                        if ( debug == 1 ){
                                std::cout << "SysMon::collect::Parse error from statgrab.pl\n";
                        } // if
                } else {
                        int gotTitle = 0;
                        // now use the array of titles and values 
                        for ( int i = 0; i < max_titles; i++ ){
                                // check against the array value
                                if ( titles[i] == sinput.substr(0,found) ){
                                        // is the one we are looking for.
                                        if ( debug == 2 ){
                                                std::cout << "SysMon::collect::Found Value\n";
                                        } // if debug
                                        
                                        gotTitle = 1;
                                        // now modify the data in the arrays if they are numbers
                            } // if (titles[i])
                        } // for
                                        
                        // did we find this title? if not add it
                        if ( gotTitle == 0 ){
                                // didnt
                                if ( debug == 1 ){
                                        std::cout << "SysMon::collect::Adding New Value\n";
                                        std::cout << "'" << sinput.substr(0,found) << "' : ";
                                        std::cout << "'" <<  sinput.substr(found+1, sinput.length()) << "'\n";
                                } // if
                                titles[titlepointer] = sinput.substr(0,found);
                                values[titlepointer] = sinput.substr(found+1, sinput.length());
                                titlepointer++;
                        } // if
                        
                } // if (not) found
                
        } // while
        
        // delete the pointer to free up memory
        delete p;
        
        if ( debug == 1 ){
                std::cout << "SysMon::collect::Parse from StatGrab finished\n";
        } // if
        
        // return sucessful
        return 0;
        
} // collect

void SysMon::clearData(){
    
    titlepointer = 0;
        for ( int i=0; i < max_titles; i++ ){
                titles[i] = "";
                values[i] = "";
        } // for
    
    return;
    
} // clearData


string SysMon::getData(){
        
        if ( debug == 1 ){
                std::cout << "SysMon::getData()\n";
        } // if
        
        // create an xml object
        XMLFormatter xml = XMLFormatter();

    if ( debug == 1 ){
                std::cout << "SysMon::getData::Sorting " << titlepointer << " elements\n";
        } // if

    // firstly sort the data.
    // simple bubble sort
    int flag = 1;
    while ( flag == 1 ){
        flag = 0;
        for ( int i=1; i<=titlepointer; i++ ){
                 if (titles[i-1].compare(titles[i]) > 0 ){
                    // swap them
                    string temp;
                    temp = titles[i-1];
                    titles[i-1] = titles[i];
                    titles[i] = temp;
                    // now do the values
                    temp = values[i-1];
                    values[i-1] = values[i];
                    values[i] = temp;
                    // say we have changed something
                    flag = 1;                    
                 }  // if   
        } // for
    } // while
        
    /* used to check the array has sorted correctly
    for ( int i=0; i < titlepointer; i++ ){
        std::cout << titles[i] << endl;    
    }
    */
       
        // work through each one of the titles in turn and 
        // work out their levels.
        
        int count = 0;
        string currentLevel = "packet";
        string currentLevels[10];
        int currentLevelint = 0;
        int retryCount = 0;
        string attributes = "";
        int isAttrib = 0;
        string attributeLevel = "";
        
        // init that array quickly ;)
        for ( int i=0; i< 10; i++ ){
            currentLevels[i] = "";
        } // for
        
        if ( debug == 1 ){
                std::cout << "SysMon::getData::Starting while\n";
        } // if
        
        while ( count <= titlepointer ){

            if ( debug == 1 ){
                    std::cout << "Processing: " << titles[count] << endl;
            } // if
            
            retryCount++;
                    
            currentLevel = "";
        for ( int i=0; i<currentLevelint; i++ ){
            if (( currentLevel != "" ) && ( i != currentLevelint )){
                currentLevel += ".";
            } // if
            currentLevel += currentLevels[i];
        } // for   
            
            // set the title into a variable
            string currentTitle = titles[count];
            
            // make an array of strings to hold the levels
            string levels[10];
            for ( int i=0; i< 10; i++ ){
                levels[i] = "";
            } // for
            int level = 0;
           
            
            // firstly find the first .
            int dotPosition = currentTitle.find(".");
                   
            while ( dotPosition != string::npos ){
                
                levels[level] = currentTitle.substr(0,dotPosition);
                
                // now remove this bit
                currentTitle = currentTitle.substr(dotPosition+1);
                
                // now find the position of the next dot
                dotPosition = currentTitle.find(".");           
                
                // increment level etc
                level++;
                
                // we already are at 'packet' level because of
                // the outer packet tags, get rif of it , only
                // first one mind!       
                if ( levels[0] == "packet" ){
                    level--;
                } // if
                        
            } // while dotPosition
            
            // now grab the value title
            levels[level] = currentTitle;
            
            // now have the levels and the level depth.
            // check it against the last one, reconstruct a
            // level string
            
            // only do this if the 2nd to last string is not
            // atrribute
            string newLevelString = "";
            
            if ( level > 0 ){
            if ( levels[level-1] != "attributes" ){
                // say it isn't an attribute, but write out
                // the attribute first if the last one was
                if ( attributeLevel != "" ){
                         xml.addElement(attributeLevel,attributes,"");
                         if ( debug == 1 ){
                               std::cout << "Adding Element + attributes" << endl;
                         } // if
                         
                    } // if
                isAttrib = 0;
                attributeLevel = "";
                attributes = "";
                
                for ( int i=0; i < level; i++ ){
                    newLevelString += levels[i];                
                    if ( i != level-1 ){
                        newLevelString += ".";
                    } // if
                } // for
            } // if levels[level]
            
            else 
            
            {
                 // we need to add to the attributes
                level -= 2;
                for ( int i=0; i < level; i++ ){
                    newLevelString += levels[i];                
                    if ( i != level-1 ){
                        newLevelString += ".";
                    } // if
                } // for
                
                isAttrib = 1;
                if ( attributeLevel == "" ){
                    // set this attribute to be the level
                    attributeLevel = levels[level];
                } else {
                   if ( levels[level] != attributeLevel ){
                        // arrg! its a different level!
                        if ( attributeLevel != levels[level] ){
                           xml.addElement(attributeLevel,attributes,"");
                           if ( debug == 1 ){
                                        std::cout << "Adding Element + attributes1" << endl;
                                } // if
                           attributeLevel = "";
                           attributes = "";
                           count++;
                        } // if
                        if ( count == titlepointer ){
                                xml.addElement(attributeLevel,attributes,"");
                            if ( debug == 1 ){
                                        std::cout << "Adding Element + attributes2" << endl;
                                } // if
                            attributeLevel = "";
                            attributes = "";
                            count++;
                        } // if
                   } // if
                } // if else
                    
            } // else attributes
            } // if level > 1
            else {
            if ( count == titlepointer ){
                if ( attributeLevel != "" ){
                    xml.addElement(attributeLevel,attributes,"");
                    if ( debug == 1 ){
                                std::cout << "Adding Element + attributes3" << endl;
                        } // if
                    attributeLevel = "";
                    attributes = "";
                    count++;
                } // if
            } // if
                
                
                for ( int i=0; i < level; i++ ){
                    newLevelString += levels[i];                
                    if ( i != level-1 ){
                        newLevelString += ".";
                    } // if
                } // for
            } // if level == 1
            
            // check if it is the same
            if ( newLevelString == currentLevel ){
                // it is the same level, just add this as another element   
                if ( isAttrib ){
                    attributes += levels[level+2];
                    attributes += "=\"";
                    attributes += values[count];        
                    attributes += "\" ";
                            
                } else {
                xml.addElement(levels[level],  values[count]);
                count++;            
                if ( debug == 1 ){
                    std::cout << "Adding Element" << endl;
                } // if
            } // if
                    
            } else {
                // gotta change it    
                
                while( newLevelString.find(currentLevel) == string::npos ){
                
                if ( currentLevelint <= 0 ){
                    break;
                } // if
                
                // back up atleast one level...
                xml.closeNest();
                if ( debug == 1 ){
                    std::cout << "Closing Nest" << endl;
                } // if
                // remove the last item
                currentLevelint--;
                
                currentLevel = "";
                for ( int i=0; i<currentLevelint; i++ ){
                    currentLevel += currentLevels[i];
                    if ( i != currentLevelint-1 ){
                            currentLevel += ".";
                    } // if
                } // for        
                                
                } // while
                
                
                while ( newLevelString != currentLevel ){
                                    
                // now got to a level which we like.
                currentLevels[currentLevelint] = levels[currentLevelint];
                
                // add in one more level and restart the loop
                xml.addNest(levels[currentLevelint]);
                if ( debug == 1 ){
                    std::cout << "Adding nest " << levels[currentLevelint] << endl;
                } // if
                
                // set this to be the top level of the new level
                currentLevelint++;
                
                currentLevel = "";
                for ( int i=0; i<currentLevelint; i++ ){
                    currentLevel += currentLevels[i];
                    if ( i != currentLevelint-1 ){
                            currentLevel += ".";
                    } // if
                } // for   
                
            } // while
                
                        
            } // if
          
            if ( debug == 1 ){
             std::cout << "Retrying Main While" << endl;
        } // if
          
            if ( retryCount > 10 ){
                count++;
                if ( debug == 1 ){
                std::cout << "Tried too many times" << endl;
            } // if
                retryCount = 0;
            } // if
            
        } // while

    if ( debug == 1 ){
                std::cout << "\n";
        } // if

        // return the string
        return xml.returnXML();
        
} // getData
Revision:	1.10
Committed:	Tue May 21 16:47:11 2002 UTC (22 years, 6 months ago) by tdb
Branch:	MAIN
Changes since 1.9:	+1 -0 lines
Log Message:	Added URL to GPL headers.
#	User	Rev	Content
1	tdb	1.9	/*
2			* i-scream central monitoring system
3	tdb	1.10	* http://www.i-scream.org.uk
4	tdb	1.9	* Copyright (C) 2000-2002 i-scream
5			*
6			* This program is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU General Public License
8			* as published by the Free Software Foundation; either version 2
9			* of the License, or (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19			*/
20
21	ab11	1.1	#include "SysMon.h"
22
23			SysMon::SysMon( Config config, int printDebug){
24			// debugging on?
25			debug = printDebug;
26
27			if ( debug == 1 ){
28			std::cout << "SysMon::Constructor\n";
29			}
30
31			// setup some standard variables
32			sequence = 0; // no packets sent yet
33
34			// setup our arrays
35			titlepointer = 0;
36	ab11	1.8	for ( int i=0; i < max_titles; i++ ){
37	ab11	1.1	titles[i] = "";
38			values[i] = "";
39			}
40
41			checks = 0;
42
43			} // constructor
44
45			int SysMon::collect(){
46			if ( debug == 1 ){
47			std::cout << "SysMon::collect()\n";
48	ab11	1.8	} // if
49	ab11	1.1
50			// say we have checked again
51			checks++;
52
53			// collect the system data and place it in an array of strings.
54			// presume that the data is all formtted correctly.
55	ab11	1.8
56	ab11	1.1	if ( debug == 1 ){
57			std::cout << "SysMon::collect::ipipestream\n";
58			}
59	ab11	1.8
60			p = new SubPipe("./statgrab.pl");
61	ab11	1.1
62			// get the output into input from statgrab
63	ab11	1.3	string sinput;
64	ab11	1.4	while ( p->getLine(&sinput) == 0 ){
65	ab11	1.3
66	ab11	1.8	if ( titlepointer == max_titles ){
67			std::cout << "WARNING: Max Titles reached, skipping remaining" << endl;
68			std::cout << "Try recompiling with a value greater than the current (" << max_titles << ")" << endl;
69			titlepointer--;
70			break;
71			} // if
72
73	ab11	1.1	// locate the first white space
74			int found = sinput.find(" ",0);
75			if ( found == string::npos ){
76			// error
77			if ( debug == 1 ){
78			std::cout << "SysMon::collect::Parse error from statgrab.pl\n";
79	ab11	1.8	} // if
80	ab11	1.1	} else {
81			int gotTitle = 0;
82			// now use the array of titles and values
83	ab11	1.8	for ( int i = 0; i < max_titles; i++ ){
84	ab11	1.1	// check against the array value
85			if ( titles[i] == sinput.substr(0,found) ){
86			// is the one we are looking for.
87	ab11	1.2	if ( debug == 2 ){
88	ab11	1.1	std::cout << "SysMon::collect::Found Value\n";
89	ab11	1.4	} // if debug
90
91	ab11	1.2	gotTitle = 1;
92	ab11	1.1	// now modify the data in the arrays if they are numbers
93	ab11	1.4	} // if (titles[i])
94	ab11	1.1	} // for
95	ab11	1.4
96	ab11	1.1	// did we find this title? if not add it
97			if ( gotTitle == 0 ){
98			// didnt
99			if ( debug == 1 ){
100	ab11	1.8	std::cout << "SysMon::collect::Adding New Value\n";
101			std::cout << "'" << sinput.substr(0,found) << "' : ";
102			std::cout << "'" << sinput.substr(found+1, sinput.length()) << "'\n";
103			} // if
104	ab11	1.1	titles[titlepointer] = sinput.substr(0,found);
105			values[titlepointer] = sinput.substr(found+1, sinput.length());
106			titlepointer++;
107			} // if
108
109			} // if (not) found
110
111			} // while
112
113	ab11	1.8	// delete the pointer to free up memory
114	ab11	1.3	delete p;
115	ab11	1.2
116	ab11	1.1	if ( debug == 1 ){
117			std::cout << "SysMon::collect::Parse from StatGrab finished\n";
118	ab11	1.8	} // if
119	ab11	1.1
120			// return sucessful
121			return 0;
122
123			} // collect
124
125	ab11	1.4	void SysMon::clearData(){
126
127			titlepointer = 0;
128	ab11	1.8	for ( int i=0; i < max_titles; i++ ){
129	ab11	1.4	titles[i] = "";
130			values[i] = "";
131	ab11	1.8	} // for
132	ab11	1.4
133			return;
134
135			} // clearData
136
137
138	ab11	1.1	string SysMon::getData(){
139
140			if ( debug == 1 ){
141			std::cout << "SysMon::getData()\n";
142	ab11	1.8	} // if
143	ab11	1.1
144			// create an xml object
145			XMLFormatter xml = XMLFormatter();
146	ab11	1.2
147	ab11	1.4	if ( debug == 1 ){
148			std::cout << "SysMon::getData::Sorting " << titlepointer << " elements\n";
149	ab11	1.8	} // if
150	ab11	1.4
151			// firstly sort the data.
152			// simple bubble sort
153			int flag = 1;
154			while ( flag == 1 ){
155			flag = 0;
156			for ( int i=1; i<=titlepointer; i++ ){
157			if (titles[i-1].compare(titles[i]) > 0 ){
158			// swap them
159			string temp;
160			temp = titles[i-1];
161			titles[i-1] = titles[i];
162			titles[i] = temp;
163			// now do the values
164			temp = values[i-1];
165			values[i-1] = values[i];
166			values[i] = temp;
167			// say we have changed something
168			flag = 1;
169			} // if
170			} // for
171			} // while
172
173	ab11	1.8	/* used to check the array has sorted correctly
174	ab11	1.4	for ( int i=0; i < titlepointer; i++ ){
175			std::cout << titles[i] << endl;
176			}
177	ab11	1.8	*/
178	ab11	1.4
179			// work through each one of the titles in turn and
180			// work out their levels.
181
182	ab11	1.2	int count = 0;
183	ab11	1.4	string currentLevel = "packet";
184			string currentLevels[10];
185			int currentLevelint = 0;
186			int retryCount = 0;
187	ab11	1.2	string attributes = "";
188	ab11	1.4	int isAttrib = 0;
189			string attributeLevel = "";
190
191			// init that array quickly ;)
192			for ( int i=0; i< 10; i++ ){
193			currentLevels[i] = "";
194			} // for
195	ab11	1.2
196	ab11	1.4	if ( debug == 1 ){
197			std::cout << "SysMon::getData::Starting while\n";
198	ab11	1.8	} // if
199	ab11	1.2
200	ab11	1.4	while ( count <= titlepointer ){
201	ab11	1.8
202	ab11	1.4	if ( debug == 1 ){
203			std::cout << "Processing: " << titles[count] << endl;
204	ab11	1.8	} // if
205	ab11	1.4
206			retryCount++;
207
208			currentLevel = "";
209			for ( int i=0; i<currentLevelint; i++ ){
210			if (( currentLevel != "" ) && ( i != currentLevelint )){
211			currentLevel += ".";
212			} // if
213			currentLevel += currentLevels[i];
214			} // for
215
216			// set the title into a variable
217			string currentTitle = titles[count];
218
219			// make an array of strings to hold the levels
220			string levels[10];
221			for ( int i=0; i< 10; i++ ){
222			levels[i] = "";
223			} // for
224			int level = 0;
225
226
227			// firstly find the first .
228			int dotPosition = currentTitle.find(".");
229
230			while ( dotPosition != string::npos ){
231
232			levels[level] = currentTitle.substr(0,dotPosition);
233
234			// now remove this bit
235			currentTitle = currentTitle.substr(dotPosition+1);
236
237			// now find the position of the next dot
238			dotPosition = currentTitle.find(".");
239
240			// increment level etc
241			level++;
242
243			// we already are at 'packet' level because of
244			// the outer packet tags, get rif of it , only
245			// first one mind!
246			if ( levels[0] == "packet" ){
247			level--;
248	ab11	1.8	} // if
249
250	ab11	1.4	} // while dotPosition
251
252			// now grab the value title
253			levels[level] = currentTitle;
254
255			// now have the levels and the level depth.
256			// check it against the last one, reconstruct a
257			// level string
258
259			// only do this if the 2nd to last string is not
260			// atrribute
261			string newLevelString = "";
262
263			if ( level > 0 ){
264			if ( levels[level-1] != "attributes" ){
265			// say it isn't an attribute, but write out
266			// the attribute first if the last one was
267			if ( attributeLevel != "" ){
268			xml.addElement(attributeLevel,attributes,"");
269			if ( debug == 1 ){
270			std::cout << "Adding Element + attributes" << endl;
271	ab11	1.8	} // if
272
273	ab11	1.4	} // if
274			isAttrib = 0;
275			attributeLevel = "";
276			attributes = "";
277
278			for ( int i=0; i < level; i++ ){
279			newLevelString += levels[i];
280			if ( i != level-1 ){
281			newLevelString += ".";
282	ab11	1.8	} // if
283	ab11	1.4	} // for
284			} // if levels[level]
285
286			else
287
288			{
289			// we need to add to the attributes
290			level -= 2;
291			for ( int i=0; i < level; i++ ){
292			newLevelString += levels[i];
293			if ( i != level-1 ){
294			newLevelString += ".";
295	ab11	1.8	} // if
296	ab11	1.4	} // for
297
298			isAttrib = 1;
299			if ( attributeLevel == "" ){
300			// set this attribute to be the level
301			attributeLevel = levels[level];
302			} else {
303			if ( levels[level] != attributeLevel ){
304			// arrg! its a different level!
305			if ( attributeLevel != levels[level] ){
306			xml.addElement(attributeLevel,attributes,"");
307			if ( debug == 1 ){
308	ab11	1.7	std::cout << "Adding Element + attributes1" << endl;
309	ab11	1.8	} // if
310	ab11	1.4	attributeLevel = "";
311			attributes = "";
312			count++;
313			} // if
314			if ( count == titlepointer ){
315			xml.addElement(attributeLevel,attributes,"");
316			if ( debug == 1 ){
317	ab11	1.7	std::cout << "Adding Element + attributes2" << endl;
318	ab11	1.8	} // if
319	ab11	1.4	attributeLevel = "";
320			attributes = "";
321			count++;
322			} // if
323			} // if
324			} // if else
325
326			} // else attributes
327			} // if level > 1
328			else {
329			if ( count == titlepointer ){
330			if ( attributeLevel != "" ){
331			xml.addElement(attributeLevel,attributes,"");
332			if ( debug == 1 ){
333	ab11	1.7	std::cout << "Adding Element + attributes3" << endl;
334	ab11	1.8	} // if
335	ab11	1.4	attributeLevel = "";
336			attributes = "";
337			count++;
338			} // if
339			} // if
340
341
342			for ( int i=0; i < level; i++ ){
343			newLevelString += levels[i];
344			if ( i != level-1 ){
345			newLevelString += ".";
346	ab11	1.8	} // if
347	ab11	1.4	} // for
348			} // if level == 1
349
350			// check if it is the same
351			if ( newLevelString == currentLevel ){
352			// it is the same level, just add this as another element
353			if ( isAttrib ){
354			attributes += levels[level+2];
355	ab11	1.6	attributes += "=\"";
356	ab11	1.4	attributes += values[count];
357	ab11	1.6	attributes += "\" ";
358	ab11	1.8
359	ab11	1.4	} else {
360			xml.addElement(levels[level], values[count]);
361	ab11	1.7	count++;
362	ab11	1.4	if ( debug == 1 ){
363			std::cout << "Adding Element" << endl;
364	ab11	1.8	} // if
365			} // if
366	ab11	1.7
367	ab11	1.4	} else {
368			// gotta change it
369
370			while( newLevelString.find(currentLevel) == string::npos ){
371
372			if ( currentLevelint <= 0 ){
373			break;
374	ab11	1.8	} // if
375	ab11	1.4
376			// back up atleast one level...
377			xml.closeNest();
378			if ( debug == 1 ){
379			std::cout << "Closing Nest" << endl;
380	ab11	1.8	} // if
381	ab11	1.4	// remove the last item
382			currentLevelint--;
383
384			currentLevel = "";
385			for ( int i=0; i<currentLevelint; i++ ){
386			currentLevel += currentLevels[i];
387			if ( i != currentLevelint-1 ){
388			currentLevel += ".";
389			} // if
390			} // for
391
392			} // while
393
394
395			while ( newLevelString != currentLevel ){
396
397			// now got to a level which we like.
398			currentLevels[currentLevelint] = levels[currentLevelint];
399
400			// add in one more level and restart the loop
401			xml.addNest(levels[currentLevelint]);
402			if ( debug == 1 ){
403			std::cout << "Adding nest " << levels[currentLevelint] << endl;
404	ab11	1.8	} // if
405	ab11	1.4
406			// set this to be the top level of the new level
407			currentLevelint++;
408
409			currentLevel = "";
410			for ( int i=0; i<currentLevelint; i++ ){
411			currentLevel += currentLevels[i];
412			if ( i != currentLevelint-1 ){
413			currentLevel += ".";
414			} // if
415			} // for
416
417			} // while
418
419
420			} // if
421
422			if ( debug == 1 ){
423			std::cout << "Retrying Main While" << endl;
424			} // if
425
426			if ( retryCount > 10 ){
427			count++;
428			if ( debug == 1 ){
429			std::cout << "Tried too many times" << endl;
430			} // if
431			retryCount = 0;
432			} // if
433
434	ab11	1.2	} // while
435	ab11	1.4
436			if ( debug == 1 ){
437			std::cout << "\n";
438	ab11	1.8	} // if
439	ab11	1.4
440	ab11	1.1	// return the string
441			return xml.returnXML();
442
443			} // getData