/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the tools applications of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

/*

  node.cpp

*/

#include <QtCore>

#include "node.h"

QT_BEGIN_NAMESPACE

/*!

  \class Node

  \brief The Node class is a node in the Tree.

  A Node represents a class or function or something else

  from the source code..

 */

/*!

  When this Node is destroyed, if it has a parent Node, it

  removes itself from the parent node's child list.

 */

Node::~Node()

{

    if (par)

        par->removeChild(this);

    if (rel)

        rel->removeRelated(this);

}

/*!

  Sets this Node's Doc to \a doc. If \a replace is false and

  this Node already has a Doc, a warning is reported that the

  Doc is being overridden, and it reports where the previous

  Doc was found. If \a replace is true, the Doc is replaced

  silently.

 */

void Node::setDoc(const Doc& doc, bool replace)

{

    if (!d.isEmpty() && !replace) {

        doc.location().warning(tr("Overrides a previous doc"));

        d.location().warning(tr("(The previous doc is here)"));

    }

    d = doc;

}

/*!

 */

Node::Node(Type type, InnerNode *parent, const QString& name)

    : typ(type),

      acc(Public),

      sta(Commendable),

      saf(UnspecifiedSafeness),

      par(parent),

      rel(0),

      nam(name)

{

    if (par)

        par->addChild(this);

}

/*!

 */

QString Node::url() const

{

    return u;

}

/*!

 */

void Node::setUrl(const QString &url)

{

    u = url;

}

/*!

 */

void Node::setRelates(InnerNode *pseudoParent)

{

    if (rel)

            rel->removeRelated(this);

    rel = pseudoParent;

    pseudoParent->related.append(this);

}

/*!

  This function creates a pair that describes a link.

  The pair is composed from \a link and \a desc. The

  \a linkType is the map index the pair is filed under.

 */

void Node::setLink(LinkType linkType, const QString &link, const QString &desc)

{

    QPair<QString,QString> linkPair;

    linkPair.first = link;

    linkPair.second = desc;

    linkMap[linkType] = linkPair;

}

/*!

 */

Node::Status Node::inheritedStatus() const

{

    Status parentStatus = Commendable;

    if (par)

        parentStatus = par->inheritedStatus();

    return (Status)qMin((int)sta, (int)parentStatus);

}

/*!

 */

Node::ThreadSafeness Node::threadSafeness() const

{

    if (par && saf == par->inheritedThreadSafeness())

        return UnspecifiedSafeness;

    return saf;

}

/*!

 */

Node::ThreadSafeness Node::inheritedThreadSafeness() const

{

    if (par && saf == UnspecifiedSafeness)

        return par->inheritedThreadSafeness();

    return saf;

}

/*!

 */

QString Node::fileBase() const

{

    QString base = name();

    if (base.endsWith(".html"))

        base.chop(5);

    base.replace(QRegExp("[^A-Za-z0-9]+"), " ");

    base = base.trimmed();

    base.replace(" ", "-");

    return base.toLower();

}

/*!

  \class InnerNode

 */

/*!

 */

InnerNode::~InnerNode()

{

    deleteChildren();

    removeFromRelated();

}

/*!

 */

Node *InnerNode::findNode(const QString& name)

{

    Node *node = childMap.value(name);

    if (node)

        return node;

    return primaryFunctionMap.value(name);

}

/*!

 */

Node *InnerNode::findNode(const QString& name, Type type)

{

    if (type == Function) {

        return primaryFunctionMap.value(name);

    }

    else {

        Node *node = childMap.value(name);

        if (node && node->type() == type) {

            return node;

        }

        else {

            return 0;

        }

    }

}

/*!

  Find the function node in this node for the function named \a name.

 */

FunctionNode *InnerNode::findFunctionNode(const QString& name)

{

    return static_cast<FunctionNode *>(primaryFunctionMap.value(name));

}

/*!

  Find the function node in this node that has the same name as \a clone.

 */

FunctionNode *InnerNode::findFunctionNode(const FunctionNode *clone)

{

    QMap<QString, Node *>::ConstIterator c =

	    primaryFunctionMap.find(clone->name());

    if (c != primaryFunctionMap.end()) {

	if (isSameSignature(clone, (FunctionNode *) *c)) {

	    return (FunctionNode *) *c;

	}

        else if (secondaryFunctionMap.contains(clone->name())) {

	    const NodeList& secs = secondaryFunctionMap[clone->name()];

	    NodeList::ConstIterator s = secs.begin();

	    while (s != secs.end()) {

		if (isSameSignature(clone, (FunctionNode *) *s))

		    return (FunctionNode *) *s;

		++s;

	    }

	}

    }

    return 0;

}

/*!

  Returns the list of keys from the primary function map.

 */

QStringList InnerNode::primaryKeys()

{

    QStringList t;

    QMap<QString, Node*>::iterator i = primaryFunctionMap.begin();

    while (i != primaryFunctionMap.end()) {

        t.append(i.key());

        ++i;

    }

    return t;

}

/*!

  Returns the list of keys from the secondary function map.

 */

QStringList InnerNode::secondaryKeys()

{

    QStringList t;

    QMap<QString, NodeList>::iterator i = secondaryFunctionMap.begin();

    while (i != secondaryFunctionMap.end()) {

        t.append(i.key());

        ++i;

    }

    return t;

}

/*!

 */

void InnerNode::setOverload(const FunctionNode *func, bool overlode)

{

    Node *node = (Node *) func;

    Node *&primary = primaryFunctionMap[func->name()];

    if (secondaryFunctionMap.contains(func->name())) {

	NodeList& secs = secondaryFunctionMap[func->name()];

	if (overlode) {

	    if (primary == node) {

		primary = secs.first();

		secs.erase(secs.begin());

		secs.append(node);

	    }

            else {

		secs.removeAll(node);

                secs.append(node);

            }

	}

        else {

	    if (primary != node) {

		secs.removeAll(node);

		secs.prepend(primary);

		primary = node;

	    }

	}

    }

}

/*!

 */

void InnerNode::makeUndocumentedChildrenInternal()

{

    foreach (Node *child, childNodes()) {

        if (child->doc().isEmpty()) {

            child->setAccess(Node::Private);

            child->setStatus(Node::Internal);

        }

    }

}

/*!

 */

void InnerNode::normalizeOverloads()

{

    QMap<QString, Node *>::Iterator p1 = primaryFunctionMap.begin();

    while (p1 != primaryFunctionMap.end()) {

        FunctionNode *primaryFunc = (FunctionNode *) *p1;

        if (secondaryFunctionMap.contains(primaryFunc->name()) &&

            (primaryFunc->status() != Commendable ||

             primaryFunc->access() == Private)) {

	    NodeList& secs = secondaryFunctionMap[primaryFunc->name()];

	    NodeList::ConstIterator s = secs.begin();

	    while (s != secs.end()) {

		FunctionNode *secondaryFunc = (FunctionNode *) *s;

                // Any non-obsolete, non-compatibility, non-private functions

                // (i.e, visible functions) are preferable to the primary

                // function.

                if (secondaryFunc->status() == Commendable &&

                    secondaryFunc->access() != Private) {

                    *p1 = secondaryFunc;

                    int index = secondaryFunctionMap[primaryFunc->name()].indexOf(secondaryFunc);

                    secondaryFunctionMap[primaryFunc->name()].replace(index, primaryFunc);

                    break;

                }

                ++s;

            }

        }

        ++p1;

    }

    QMap<QString, Node *>::ConstIterator p = primaryFunctionMap.begin();

    while (p != primaryFunctionMap.end()) {

	FunctionNode *primaryFunc = (FunctionNode *) *p;

	if (primaryFunc->isOverload())

	    primaryFunc->ove = false;

	if (secondaryFunctionMap.contains(primaryFunc->name())) {

	    NodeList& secs = secondaryFunctionMap[primaryFunc->name()];

	    NodeList::ConstIterator s = secs.begin();

	    while (s != secs.end()) {

		FunctionNode *secondaryFunc = (FunctionNode *) *s;

		if (!secondaryFunc->isOverload())

		    secondaryFunc->ove = true;

		++s;

	    }

	}

	++p;

    }

    NodeList::ConstIterator c = childNodes().begin();

    while (c != childNodes().end()) {

	if ((*c)->isInnerNode())

	    ((InnerNode *) *c)->normalizeOverloads();

	++c;

    }

}

/*!

 */

void InnerNode::removeFromRelated() 

{

    while (!related.isEmpty()) {

        Node *p = static_cast<Node *>(related.takeFirst());

        if (p != 0 && p->relates() == this) p->clearRelated();

    }

}

/*!

 */

void InnerNode::deleteChildren()

{

    qDeleteAll(children);

}

/*!

  Returns true.

 */

bool InnerNode::isInnerNode() const

{

    return true;

}

/*!

 */

const Node *InnerNode::findNode(const QString& name) const

{

    InnerNode *that = (InnerNode *) this;

    return that->findNode(name);

}

/*!

 */

const Node *InnerNode::findNode(const QString& name, Type type) const

{

    InnerNode *that = (InnerNode *) this;

    return that->findNode(name, type);

}

/*!

  Find the function node in this node that has the given \a name. 

 */

const FunctionNode *InnerNode::findFunctionNode(const QString& name) const

{

    InnerNode *that = (InnerNode *) this;

    return that->findFunctionNode(name);

}

/*!

  Find the function node in this node that has the same name as \a clone.

 */

const FunctionNode *InnerNode::findFunctionNode(const FunctionNode *clone) const

{

    InnerNode *that = (InnerNode *) this;

    return that->findFunctionNode(clone);

}

/*!

 */

const EnumNode *InnerNode::findEnumNodeForValue(const QString &enumValue) const

{

    foreach (const Node *node, enumChildren) {

        const EnumNode *enume = static_cast<const EnumNode *>(node);

        if (enume->hasItem(enumValue))

            return enume;

    }

    return 0;

}

/*!

 */

int InnerNode::overloadNumber(const FunctionNode *func) const

{

    Node *node = (Node *) func;

    if (primaryFunctionMap[func->name()] == node) {

        return 1;

    }

    else {

        return secondaryFunctionMap[func->name()].indexOf(node) + 2;

    }

}

/*!

 */

int InnerNode::numOverloads(const QString& funcName) const

{

    if (primaryFunctionMap.contains(funcName)) {

        return secondaryFunctionMap[funcName].count() + 1;

    }

    else {

        return 0;

    }

}

/*!

 */

NodeList InnerNode::overloads(const QString &funcName) const

{

    NodeList result;

    Node *primary = primaryFunctionMap.value(funcName);

    if (primary) {

        result << primary;

        result += secondaryFunctionMap[funcName];

    }

    return result;

}

/*!

 */

InnerNode::InnerNode(Type type, InnerNode *parent, const QString& name)

    : Node(type, parent, name)

{

}

/*!

 */

void InnerNode::addInclude(const QString& include)

{

    inc.append(include);

}

/*!

 */

void InnerNode::setIncludes(const QStringList& includes)

{

    inc = includes;

}

/*!

  f1 is always the clone

 */

bool InnerNode::isSameSignature(const FunctionNode *f1, const FunctionNode *f2)

{

    if (f1->parameters().count() != f2->parameters().count())

        return false;

    if (f1->isConst() != f2->isConst())

        return false;

    QList<Parameter>::ConstIterator p1 = f1->parameters().begin();

    QList<Parameter>::ConstIterator p2 = f2->parameters().begin();

    while (p2 != f2->parameters().end()) {

	if ((*p1).hasType() && (*p2).hasType()) {

            if ((*p1).rightType() != (*p2).rightType())

                return false;