Source/SDXNode.cpp

#include <iostream>

#include "SDXNode.h"
#include "SDXAttribute.h"
#include "SDXContentHandler.h"

using namespace std;
using namespace SDX;

Node::Node(string name) :
        m_name(name)
{
}

Node::Node(Node& other){
        m_name = other.m_name;
        for(vector<Attribute*>::iterator i = other.m_attributes.begin(); i != other.m_attributes.end(); ++i)
                m_attributes.push_back(new Attribute(*i));

        vector<Node*> children = other.getChildren();
        for(vector<Node*>::iterator i = children.begin(); i != children.end(); ++i)
                addChild(new Node(*i));
}

Node::Node(Node* other){
        m_name = other->m_name;
        for(vector<Attribute*>::iterator i = other->m_attributes.begin(); i != other->m_attributes.end(); ++i)
                m_attributes.push_back(new Attribute(*i));

        vector<Node*> children = other->getChildren();
        for(vector<Node*>::iterator i = children.begin(); i != children.end(); ++i)
                addChild(new Node(*i));
}

Node::~Node(){
        if(m_deallocateContentOnDestruct){
                for(vector<Attribute*>::iterator i = m_attributes.begin(); i != m_attributes.end(); ++i)
                        delete *i;
        }
}

Node* Node::addAttribute(Attribute* attribute){
        m_attributes.push_back(attribute);

        return this;
}

Node* Node::addAttribute(string name, string value){
        m_attributes.push_back(new Attribute(name, value));

        return this;
}

const string Node::getName(){
        return m_name;
}

const vector<Attribute*> Node::getAttributes(){
        return m_attributes;
}

const vector<Attribute*> Node::getAttributes(string attributeName){
        vector<Attribute*> retVal;

        for(vector<Attribute*>::iterator i = m_attributes.begin(); i != m_attributes.end(); ++i){
                if((*i)->getName() == attributeName)
                        retVal.push_back(*i);
        }

        return retVal;
}

Attribute* Node::getAttribute(unsigned int index){
        Attribute* retVal = 0;
        if(index >= 0 && index < m_attributes.size())
                retVal = m_attributes[index];

        return retVal;
}

Attribute* Node::getAttribute(std::string attributeName){
        const vector<Attribute*> attributes(getAttributes(attributeName));
        if(attributes.size() == 0)
                return 0;

        return attributes.back();
}

const vector<Attribute*> Node::getNamedAttributes(){
        vector<Attribute*> retVal;

        for(unsigned int i = 0; i < m_attributes.size(); ++i){
                        Attribute* curAttribute = m_attributes.at(i);
                        if(curAttribute->isNamedAttribute())
                                retVal.push_back(curAttribute);
        }

        return retVal;
}

const vector<Attribute*> Node::getUnnamedAttributes(){
        vector<Attribute*> retVal;

        for(unsigned int i = 0; i < m_attributes.size(); ++i){
                        Attribute* curAttribute = m_attributes.at(i);
                        if(!curAttribute->isNamedAttribute())
                                retVal.push_back(curAttribute);
        }

        return retVal;
}

void Node::sendToContentHandler(ContentHandler* contentHandler, bool onlySendContents){
        if(!onlySendContents)
                contentHandler->startNode(m_name);

        for(vector<Attribute*>::iterator i = m_attributes.begin(); i != m_attributes.end(); ++i)
                (*i)->sendToContentHandler(contentHandler);

        vector<Node*> children = getChildren();
        for(vector<Node*>::iterator i = children.begin(); i != children.end(); ++i)
                (*i)->sendToContentHandler(contentHandler);

        if(!onlySendContents)
                contentHandler->endNode();
}

---