/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <string>

#include <iostream>

#include <map>

#include <vector>

#include <algorithm>

using namespace std;

#ifndef XMLNODE

#define XMLNODE

class XMLNode

{

public:

	typedef map<string, string> Attributes;

    XMLNode();

    XMLNode(const XMLNode&);

	XMLNode(const string&);

	XMLNode(const string&, const string&);

    virtual ~XMLNode();

	// Operator overloads

	bool operator==(const XMLNode&);

	bool operator==(const string&);

	bool operator!=(const XMLNode&);

	bool operator!=(const string&);

	bool operator<(const XMLNode&) const;

	bool operator<(const string&) const;

	bool operator>(const XMLNode&) const;

	bool operator>(const string&) const;

    XMLNode& operator=(const XMLNode&);

	// Accessors and Mutators

	const string& value() const { return value_; }

	void value(const string& v) { value_ = v; }

	const string& name() const { return name_; }

	void name(const string& n) { name_ = n; }

	void addChild(XMLNode&);

	void child(XMLNode&);

	XMLNode child(const string&);

	XMLNode child(const string& elementname, int& index);

	bool hasChild(const string&);

	size_t childCount() { return children_.size(); }

	bool children() { return (!children_.empty()); }

public:

	vector<XMLNode>		children_;

private:

	string			value_;

	string			name_;

	Attributes		attributes_;

};

XMLNode::XMLNode()

{

}

XMLNode::XMLNode(const std::string& n, const std::string& v)

{

	name_ = n;

	value_ = v;

}

XMLNode::XMLNode(const std::string& n)

{

	name_ = n;

}

XMLNode::XMLNode(const XMLNode& rhs)

{

	if(&rhs == this)

		return;

	this->operator=(rhs);

}

XMLNode::~XMLNode()

{

}

XMLNode& XMLNode::operator=(const XMLNode& rhs)

{

	if(&rhs == this)

		return *this;

	value_ = rhs.value_;

	name_ = rhs.name_;

	children_ = rhs.children_;

	return *this;

}

bool XMLNode::operator==(const XMLNode& n)

{

	return ((n.name_ == name_) && (n.value_ == value_));

}

bool XMLNode::operator==(const std::string& n)

{

	return (n == name_);

}

bool XMLNode::operator!=(const XMLNode& n)

{

	return ((n.name_ != name_) && (n.value_ != value_));

}

bool XMLNode::operator!=(const std::string& n)

{

	return (n != name_);

}

bool XMLNode::operator<(const XMLNode& n) const

{

	return ((n.name_ < name_) && (n.value_ < value_));

}

bool XMLNode::operator<(const std::string& n) const

{

	return (strcmp(name_.c_str(), n.c_str()) < 0);

}

bool XMLNode::operator>(const XMLNode& n) const

{

	return ((n.name_ > name_) && (n.value_ > value_));

}

bool XMLNode::operator>(const std::string& n) const

{

	return (strcmp(name_.c_str(), n.c_str()) > 0);

}

void XMLNode::child(XMLNode& c)

{

	children_.push_back(c);

}

bool XMLNode::hasChild(const std::string& name)

{

	vector<XMLNode>::iterator iter = find(children_.begin(), children_.end(), name);

	return (iter != children_.end());

}

XMLNode XMLNode::child(const std::string& name)

{

	vector<XMLNode>::iterator iter = find(children_.begin(), children_.end(), name);

	if(iter != children_.end())

		return *iter;

	return XMLNode();

}

XMLNode XMLNode::child(const std::string& elementname, int& index)

{

	vector<XMLNode>::iterator iter = find(children_.begin(), children_.end(), elementname);

	if(iter != children_.end())

	{

		index = (int)(iter - children_.begin());

		return *iter;

	}

	return XMLNode();

}

ostream& operator<<(ostream& o, XMLNode& node)

{

	o << "Writing Node name to stream : " << node.name() << endl;

	return o;

}

ostream& operator<<(XMLNode& node, ostream& o)

{

	o << "Writing Node name to stream : " << node.name() << endl;

	return o;

}

void XMLNode::addChild(XMLNode& node)

{

	children_.push_back(node);

}

#endif // XMLNODE