cxFrameForest.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/

#include "cxFrameForest.h"

#include "cxData.h"

namespace cx
{

FrameForest::FrameForest(const std::map<QString, DataPtr> &source) : mSource(source)
{
//  std::cout << "Forrest doc2:" << std::endl;
//      DataManager::DataMap allData = mDataManager->getData();
        mDocument.appendChild(mDocument.createElement("root"));

        for (std::map<QString, DataPtr>::const_iterator iter = source.begin(); iter != source.end(); ++iter)
        {
                this->insertFrame(iter->second);
        }

//  std::cout << "Forrest doc:" << std::endl;
//  std::cout << mDocument.toString(4) << std::endl;
}

QDomDocument FrameForest::getDocument()
{
        return mDocument;
}

void FrameForest::insertFrame(DataPtr data)
{
        QString parentFrame = data->getParentSpace();
        QString currentFrame = data->getSpace();

//    if (parentFrame.isEmpty() || currentFrame.isEmpty())
//      return;

        QDomNode parentNode = this->getNodeAnyway(parentFrame);
        QDomNode currentNode = this->getNodeAnyway(currentFrame);

        if (parentNode.isNull())
                return;

        // move currentNode to child of parentNode
        currentNode = currentNode.parentNode().removeChild(currentNode);
        parentNode.appendChild(currentNode);
}

QDomNode FrameForest::getNode(QString frame)
{
        QDomNodeList list = mDocument.elementsByTagName(frame);
        if (list.isEmpty())
                return QDomNode();
        return list.item(0);
}

QDomNode FrameForest::getNodeAnyway(QString frame)
{
        QDomNode retval = this->getNode(frame);
        if (retval.isNull())
        {
                retval = mDocument.createElement(frame);
                mDocument.documentElement().appendChild(retval);
        }
        return retval;
}

bool FrameForest::isAncestorOf(QDomNode node, QDomNode ancestor)
{
        //std::cout << "isAncestorOf : " << node.toElement().tagName() << "---"  << ancestor.toElement().tagName() << std::endl;

        while (!this->isRootNode(node))
        {
                if (node == ancestor)
                {
                        //std::cout << "return true" << std::endl;;
                        return true;
                }
                node = node.parentNode();
        }
        //std::cout << "return false" << std::endl;;
        return false;
}

bool FrameForest::isRootNode(QDomNode node)
{
        return node == mDocument.documentElement();
}

QDomNode FrameForest::getOldestAncestor(QDomNode node)
{
        if (this->isRootNode(node))
                return node;
        while (!this->isRootNode(node.parentNode()))
                node = node.parentNode();
        return node;
}

QDomNode FrameForest::getOldestAncestorNotCommonToRef(QDomNode node, QDomNode ref)
{
        //std::cout << "getOldestAncestorNotCommonToRef " << node.toElement().tagName() << " - " << ref.toElement().tagName() << std::endl;
        if (this->isAncestorOf(ref, node))
                return QDomNode();

        while (!this->isRootNode(node.parentNode()))
        {
                //std::cout << "getOldestAncestorNotCommonToRef iterate start: " << node.toElement().tagName()  << std::endl;
                if (this->isAncestorOf(ref, node.parentNode()))
                        break;
                node = node.parentNode();
                //std::cout << "getOldestAncestorNotCommonToRef iterate stop: " << node.toElement().tagName()  << std::endl;
        }
        //std::cout << std::endl;
        return node;
}

std::vector<QDomNode> FrameForest::getDescendantsAndSelf(QDomNode node)
{
        std::vector<QDomNode> retval;
        retval.push_back(node);

        for (QDomNode child = node.firstChild(); !child.isNull(); child = child.nextSibling())
        {
                std::vector<QDomNode> subnodes = this->getDescendantsAndSelf(child);
                std::copy(subnodes.begin(), subnodes.end(), back_inserter(retval));
        }
        return retval;
}

std::vector<DataPtr> FrameForest::getDataFromDescendantsAndSelf(QDomNode node)
{
        std::vector<QDomNode> nodes = this->getDescendantsAndSelf(node);
        std::vector<DataPtr> retval;

        for (unsigned i = 0; i < nodes.size(); ++i)
        {
                DataPtr data = mSource[nodes[i].toElement().tagName()];
//              DataPtr data = mDataManager->getData(nodes[i].toElement().tagName());
                if (data)
                        retval.push_back(data);
        }
        return retval;
}

}