Subversion Repositories HomeAutomation

/***************************************************************************

 *   Copyright (C) November 30, 2008 by Mattias Runge                             *

 *   mattias@runge.se                                                      *

 *   xmlnode.cpp                                            *

 *                                                                         *

 *   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 "xmlnode.h"

void XmlNode::load(string filename)

{

	parse(file_get_contents(filename));

}

void XmlNode::parse(string xmlData)

{

	char c;

	int position = 0;

	while (position < xmlData.length())

	{

		c = xmlData.at(position);

		switch (c)

		{

			case '<':

				position = parseTag(xmlData, position);

				break;

		}

		position++;

	}

}

int XmlNode::parseTag(string xmlData, int position)

{

	if (xmlData.at(position) != '<')

		throw new XmlException("Did not find < as expected. Character " + itos(position));

	position++;

	int endPosition = xmlData.find('>', position);

	if (xmlData.at(position) == '?' || xmlData.at(position) == '!' || xmlData.at(position) == '/')

	{

		return endPosition;

	}

	string tagString;

	try

	{

		tagString = xmlData.substr(position, endPosition-position);

	}

	catch (std::out_of_range& e)

	{

		cout << "DEBUG: parseTag exception: " << e.what() << "\n";

		cout << "DEBUG: A xmlData=" << xmlData << " :: position=" << position << " :: endPosition=" << endPosition << endl;

	}

	tagString = trim(tagString);

	tagString = trim(tagString, '\n');

	tagString = trim(tagString);

	tagString += " ";

	bool foundEnd = false;

	bool foundTag = false;

	string buffer;

	int pos = 0;

	char c;

	int s, e;

	while (pos < tagString.length())

	{

		c = tagString.at(pos);

		switch (c)

		{

			case ' ':

				if (!foundTag)

				{

					myTagName = buffer;

					buffer = "";

					//cout << "Found tag: " << myTagName << endl;

					foundTag = true;

				}

				break;

			case '/':

				foundEnd = true;

				break;

			case '=':

				s = tagString.find('"', pos)+1;

				e = tagString.find('"', s);

				try

				{

					myAttributes[buffer] = tagString.substr(s, e-s);

				}

				catch (std::out_of_range& ex)

				{

					cout << "DEBUG: parseTag exception: " << ex.what() << "\n";

					cout << "DEBUG: B tagString=" << tagString << " :: s=" << s << " :: e=" << e << endl;

					continue;

				}

				//cout << "Found attribute: " << buffer << " = " << myAttributes[buffer] << endl;

				pos = e;

				buffer = "";

				break;

			default:

				buffer += c;

				break;

		}

		pos++;

	}

	position = endPosition;

	if (!foundEnd)

	{

		while (position < xmlData.length())

		{

			c = xmlData.at(position);

			switch (c)

			{

				case '<':

					if (xmlData.at(position+1) == '/')

					{

						position += 2;

						endPosition = xmlData.find('>', position);

						try

						{

							if (myTagName.compare(xmlData.substr(position, endPosition-position)) == 0)

							{

								//cout << "Found end tag: " << myTagName << endl;

								return endPosition;

							}

							else

							{

								throw new XmlException("Invalid end tag found. " + xmlData.substr(position, endPosition-position) + "::" + myTagName);

							}

						}

						catch (std::out_of_range& e)

						{

							cout << "DEBUG: parseTag exception: " << e.what() << "\n";

							cout << "DEBUG: C xmlData=" << xmlData << " :: position=" << position << " :: endPosition=" << endPosition << endl;

							continue;

						}

					}

					XmlNode subNode;

					position = subNode.parseTag(xmlData, position);

					myChildren.push_back(subNode);

					break;

			}

			position++;

		}

	}

	return position;

}

XmlNode XmlNode::findChild(string tagName)

{

	for (int n = 0; n < myChildren.size(); n++)

	{

		if (myChildren[n].getTagName().compare(tagName) == 0)

			return myChildren[n];

	}

	XmlNode defaultNode;

	return defaultNode;

}

string XmlNode::getAttributeValue(string attributeName)

{

	map<string, string>::const_iterator iterator = myAttributes.find(attributeName);

	if (iterator == myAttributes.end())

		return NULL;

	return iterator->second;

}