QFD2/QFD/CCanvas/CMind.cpp

#include "CMind.h"

CNodeData::CNodeData(int projId, int evalType, int number, int pNumber, int id)
    : id(id), projectId(projId), evalType(evalType), number(number), pNumber(pNumber)
{
}

bool CNodeData::isValid() const
{
    return projectId >= 0 && evalType > 0 && number >= 0;
}

bool CNodeData::isNull() const
{
    return id == -1 && projectId == -1 && evalType == 0 && number == -1 && pNumber == -1;
}

bool CNodeData::isCached() const
{
    return id >= 0;
}
bool CNodeData::hasParent() const
{
    return pNumber >= 0;
}

CMind::CMind(int projId, int evalType, QObject *parent) : QObject(parent), m_projectId(projId), m_evalType(evalType) { }

QList<CNodeData> CMind::nodeList() const
{
    return m_nodeList;
}

void CMind::setNodeList(QList<CNodeData> list)
{
    m_nodeList.clear();
    for (CNodeData n : list) {
        addNode(n);
    }
}

bool CMind::isNodeValid(CNodeData n) const
{
    bool v = n.isValid() && n.projectId == m_projectId && n.evalType == m_evalType;
    return v;
}

CNodeData CMind::node(int number) const
{
    int i = numberList().indexOf(number);
    if (i < 0 || i >= m_nodeList.count()) {
        return CNodeData();
    }
    return m_nodeList[i];
}

bool CMind::containsNode(int number) const
{
    return numberList().contains(number);
}

CNodeData CMind::createNode(int pNumber) const
{
    CNodeData n;
    if (containsNode(pNumber) || (pNumber < 0 && m_nodeList.count() <= 0)) {
        n = CNodeData(m_projectId, m_evalType, maxNumber() + 1, pNumber);
    }
    return n;
}

void CMind::addNode(CNodeData n)
{
    if (isNodeValid(n) == false) {
        return;
    }

    if (numberList().contains(n.number)) {
        return;
    }

    m_nodeList.append(n);
}

void CMind::removeNode(int number)
{
    // 若是根节点, 则整体删除
    if (number == minNumber()) {
        m_nodeList.clear();
        return;
    }

    // 删除节点
    int i = numberList().indexOf(number);
    if (i >= 0 && i < m_nodeList.count()) {
        m_nodeList.removeAt(i);
    }

    // 删除子节点
    for (int i = m_nodeList.count() - 1; i >= 0; i--) {
        CNodeData n = m_nodeList[i];
        if (hasAncestor(n.number, number)) {
            m_nodeList.removeAt(i);
        }
    }
}

bool CMind::hasAncestor(int childNumber, int ancestorNumber) const
{
    CNodeData c = node(childNumber);
    if (c.isValid()) {
        if (c.hasParent() && c.pNumber == ancestorNumber) {
            return true;
        }
        return hasAncestor(c.pNumber, ancestorNumber);
    }
    return false;
}

QList<int> CMind::numberList() const
{
    QList<int> l;
    for (int i = 0; i < m_nodeList.count(); i++) {
        l.append(m_nodeList[i].number);
    }
    return l;
}

int CMind::maxNumber() const
{
    int n = -1;
    if (m_nodeList.count() > 0) {
        n = m_nodeList.first().number;
    }
    for (int i = 0; i < m_nodeList.count(); i++) {
        n = std::max(n, m_nodeList[i].number);
    }
    return n;
}

int CMind::minNumber() const
{
    int n = -1;
    if (m_nodeList.count() > 0) {
        n = m_nodeList.first().number;
    }
    for (int i = 0; i < m_nodeList.count(); i++) {
        n = std::min(n, m_nodeList[i].number);
    }
    return n;
}