Source/SDXNodeContainer.cpp

#include "SDXNodeContainer.h"
#include "SDXNode.h"

using namespace std;
using namespace SDX;

NodeContainer::NodeContainer() :
        m_deallocateContentOnDestruct(false)
{
}

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

void NodeContainer::setDeallocateContentOnDestruct(bool v){
        m_deallocateContentOnDestruct = v;
}

NodeContainer& NodeContainer::addChild(Node* node){
        m_children.push_back(node);

        return *this;
}

void NodeContainer::removeChild(unsigned int index, bool deallocate){
        if(index >= 0 && index < m_children.size()){
                if(deallocate)
                        delete m_children.at(index);

                m_children.erase(m_children.begin() + index);
        }
}

void NodeContainer::removeChild(Node* node, bool deallocate){
        for(unsigned int i = 0; i < m_children.size(); ++i){
                if(m_children.at(i) == node){
                        removeChild(i, deallocate);
                        return;
                }
        }
}

const vector<Node*> NodeContainer::getChildren(){
        return m_children;
}

const vector<Node*> NodeContainer::getChildren(std::string nodeName){
        vector<Node*> retVal;

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

        return retVal;
}

Node* NodeContainer::getChild(std::string nodeName){
        Node* retVal = 0;

        const vector<Node*> childNodes = getChildren(nodeName);
        if(childNodes.size() > 0)
                retVal = childNodes.back();

        return retVal;
}

Node* NodeContainer::getChild(unsigned int index){
        Node* retVal = 0;
        if(index >= 0 && index < m_children.size())
                retVal = m_children[index];

        return retVal;
}

Node* NodeContainer::getChild(string nodeName, string attributeValue, string attributeName){
        Node* retVal = 0;

        for(unsigned int i = 0; i < m_children.size(); ++i){
                Node* curNode = m_children.at(i);

                vector<Attribute*> curAttributes = attributeName.empty() ? curNode->getUnnamedAttributes() : curNode->getNamedAttributes();
                for(unsigned int j = 0; j < curAttributes.size(); ++j){
                                Attribute* curAttribute = curAttributes.at(j);

                                string curValue;
                                if(!curAttribute->getValue(&curValue))
                                        continue;

                                if(curValue == attributeValue && (attributeName.empty() || curAttribute->getName() == attributeName))
                                        return curNode;
                }

        }

        return retVal;
}

---