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

**

** 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 "node.h"

#include <qdebug.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;

}

/*!

  Construct a node with the given \a type and having the

  given \a parent and \a name. The new node is added to the

  parent's child list.

 */

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

    : typ(type),

      acc(Public),

      saf(UnspecifiedSafeness),

      pageTyp(NoPageType),

      sta(Commendable),

      par(parent),

      rel(0),

      nam(name)

{

    if (par)

        par->addChild(this);

}

/*!

  Returns the node's URL.

 */

QString Node::url() const

{

    return u;

}

/*!

  Sets the node's URL to \a url

 */

void Node::setUrl(const QString &url)

{

    u = url;

}

void Node::setPageType(const QString& t)

{

    if ((t == "API") || (t == "api"))

        pageTyp = ApiPage;

    else if (t == "article")

        pageTyp = ArticlePage;

    else if (t == "example")

        pageTyp = ExamplePage;

}

/*!

  Sets the pointer to the node that this node relates to.

 */

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();

}

/*!

  Find the node in this node's children that has the

  given \a name. If this node is a QML class node, be

  sure to also look in the children of its property

  group nodes. Return the matching node or 0.

 */

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

{

    Node *node = childMap.value(name);

        return node;

    if ((type() == Fake) && (subType() == QmlClass)) {

        for (int i=0; i<children.size(); ++i) {

            Node* n = children.at(i);

            if (n->subType() == QmlPropertyGroup) {

                node = static_cast<InnerNode*>(n)->findNode(name);

                if (node)

                    return node;

            }

        }

    }

    return primaryFunctionMap.value(name);

}

/*!

  Same as the other findNode(), but if the node with the

  specified \a name is not of the specified \a type, return

  0.

 */

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()) {