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

**

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

*/

#ifndef NODE_H

#define NODE_H

#include <qdir.h>

#include <qmap.h>

#include <qpair.h>

#include <qstringlist.h>

#include "codechunk.h"

#include "doc.h"

#include "location.h"

#include "text.h"

#include <QUuid>

QT_BEGIN_NAMESPACE

class InnerNode;

class Node

{

 public:

    enum Type { 

        Namespace, 

        Class, 

        Fake, 

        Enum, 

        Typedef, 

        Function, 

        Property,

        Variable, 

#ifdef QDOC_QML

        Target,

        QmlProperty,

        QmlSignal,

        QmlMethod,

        LastType

#else

        Target,

        LastType

#endif

    };

    enum SubType { 

        NoSubType,

        Example, 

        HeaderFile, 

        File,

        Image,

        Group,

        Module,

        Page,

#ifdef QDOC_QML

        ExternalPage,

        QmlClass,

        QmlPropertyGroup,

        QmlBasicType

#else

        ExternalPage

#endif

    };

    enum Access { Public, Protected, Private };

    enum Status { 

        Compat, 

        Obsolete, 

        Deprecated, 

        Preliminary, 

        Commendable, 

        Main, 

        Internal 

    }; // don't reorder thisw enum

    enum ThreadSafeness { 

        UnspecifiedSafeness, 

        NonReentrant, 

        Reentrant, 

        ThreadSafe 

    };

    enum LinkType { 

        StartLink, 

        NextLink, 

        PreviousLink,

        ContentsLink, 

        IndexLink,

        InheritsLink /*, 

        GlossaryLink, 

        CopyrightLink,

        ChapterLink, 

        SectionLink, 

        SubsectionLink, 

        AppendixLink */ 

    };

    enum PageType {

        NoPageType,

        ApiPage,

        ArticlePage,

        ExamplePage

    };

    virtual ~Node();

    void setAccess(Access access) { acc = access; }

    void setLocation(const Location& location) { loc = location; }

    void setDoc(const Doc& doc, bool replace = false);

    void setStatus(Status status) { sta = status; }

    void setThreadSafeness(ThreadSafeness safeness) { saf = safeness; }

    void setSince(const QString &since) { sinc = since; }

    void setRelates(InnerNode* pseudoParent);

    void setModuleName(const QString &module) { mod = module; }

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

    void setUrl(const QString &url);

    void setTemplateStuff(const QString &templateStuff) { tpl = templateStuff; }

    void setPageType(PageType t) { pageTyp = t; }

    void setPageType(const QString& t);

    virtual bool isInnerNode() const = 0;

    virtual bool isReimp() const { return false; }

    virtual bool isFunction() const { return false; }

    virtual bool isQmlNode() const { return false; }

    Type type() const { return typ; }

    virtual SubType subType() const { return NoSubType; }

    InnerNode* parent() const { return par; }

    InnerNode* relates() const { return rel; }

    const QString& name() const { return nam; }

    QMap<LinkType, QPair<QString,QString> > links() const { return linkMap; }

    QString moduleName() const;

    QString url() const;

    virtual QString nameForLists() const { return nam; }

    Access access() const { return acc; }

    QString accessString() const;

    const Location& location() const { return loc; }

    const Doc& doc() const { return d; }

    Status status() const { return sta; }

    Status inheritedStatus() const;

    ThreadSafeness threadSafeness() const;

    ThreadSafeness inheritedThreadSafeness() const;

    QString since() const { return sinc; }

    QString templateStuff() const { return tpl; }

    PageType pageType() const { return pageTyp; }

    virtual void addPageKeywords(const QString& ) { }

    void clearRelated() { rel = 0; }

    virtual QString fileBase() const;

    QUuid guid() const;

    QString ditaXmlHref();

    QString extractClassName(const QString &string) const;

 protected:

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

 private:

#ifdef Q_WS_WIN

    Type typ;

    Access acc;

    ThreadSafeness saf;

    PageType pageTyp;

    Status sta;

#else

    Type typ : 4;

    Access acc : 2;

    ThreadSafeness saf : 2;

    PageType pageTyp : 4;

    Status sta : 3;

#endif

    InnerNode* par;

    InnerNode* rel;

    QString nam;

    Location loc;

    Doc d;

    QMap<LinkType, QPair<QString, QString> > linkMap;

    QString mod;

    QString u;

    QString sinc;

    QString tpl;

    mutable QUuid uuid;

};

class FunctionNode;

class EnumNode;

typedef QList<Node*> NodeList;

class InnerNode : public Node

{

 public:

    virtual ~InnerNode();

    Node* findNode(const QString& name);

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

    FunctionNode* findFunctionNode(const QString& name);

    FunctionNode* findFunctionNode(const FunctionNode* clone);

    void addInclude(const QString &include);

    void setIncludes(const QStringList &includes);

    void setOverload(const FunctionNode* func, bool overlode);

    void normalizeOverloads();

    void makeUndocumentedChildrenInternal();

    void deleteChildren();

    void removeFromRelated();

    virtual bool isInnerNode() const;

    const Node* findNode(const QString& name) const;

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

    const FunctionNode* findFunctionNode(const QString& name) const;

    const FunctionNode* findFunctionNode(const FunctionNode* clone) const;

    const EnumNode* findEnumNodeForValue(const QString &enumValue) const;

    const NodeList & childNodes() const { return children; }

    const NodeList & relatedNodes() const { return related; }

    int count() const { return children.size(); }

    int overloadNumber(const FunctionNode* func) const;

    int numOverloads(const QString& funcName) const;

    NodeList overloads(const QString &funcName) const;

    const QStringList& includes() const { return inc; }

    QStringList primaryKeys();

    QStringList secondaryKeys();

    const QStringList& pageKeywords() const { return pageKeywds; }

    virtual void addPageKeywords(const QString& t) { pageKeywds << t; }

    virtual bool isAbstract() const { return false; }

    virtual void setAbstract(bool ) { }

 protected:

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

 private:

    friend class Node;

    static bool isSameSignature(const FunctionNode* f1, const FunctionNode* f2);

    void addChild(Node* child);

    void removeChild(Node* child);

    void removeRelated(Node* pseudoChild);

    QStringList pageKeywds;

    QStringList inc;

    NodeList children;

    NodeList enumChildren;

    NodeList related;

    QMap<QString, Node*> childMap;

    QMap<QString, Node*> primaryFunctionMap;

    QMap<QString, NodeList> secondaryFunctionMap;

};

class LeafNode : public Node

{

 public:

    LeafNode();

    virtual ~LeafNode() { }

    virtual bool isInnerNode() const;

 protected:

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

};

class NamespaceNode : public InnerNode

{

 public:

    NamespaceNode(InnerNode* parent, const QString& name);

    virtual ~NamespaceNode() { }

};

class ClassNode;

struct RelatedClass

{

    RelatedClass() { }

    RelatedClass(Node::Access access0, 

                 ClassNode* node0,

                 const QString& dataTypeWithTemplateArgs0 = "")

      : access(access0), 

        node(node0),

        dataTypeWithTemplateArgs(dataTypeWithTemplateArgs0) { }

    QString accessString() const;

    Node::Access        access;

    ClassNode*          node;

    QString             dataTypeWithTemplateArgs;

};

class PropertyNode;

class ClassNode : public InnerNode

{

 public:

    ClassNode(InnerNode* parent, const QString& name);

    virtual ~ClassNode() { }

    void addBaseClass(Access access, 

                      ClassNode* node, 

                      const QString &dataTypeWithTemplateArgs = "");

    void fixBaseClasses();

    const QList<RelatedClass> &baseClasses() const { return bases; }

    const QList<RelatedClass> &derivedClasses() const { return derived; }

    const QList<RelatedClass> &ignoredBaseClasses() const { return ignoredBases; }

    bool hideFromMainList() const { return hidden; }

    void setHideFromMainList(bool value) { hidden = value; }

    QString serviceName() const { return sname; }

    void setServiceName(const QString& value) { sname = value; }

    QString qmlElement() const { return qmlelement; }

    void setQmlElement(const QString& value) { qmlelement = value; }

    virtual bool isAbstract() const { return abstract; }

    virtual void setAbstract(bool b) { abstract = b; }

    const PropertyNode* findPropertyNode(const QString& name) const;

 private:

    QList<RelatedClass> bases;

    QList<RelatedClass> derived;

    QList<RelatedClass> ignoredBases;

    bool hidden;

    bool abstract;

    QString sname;

    QString qmlelement;

};

class FakeNode : public InnerNode

{

 public:

    FakeNode(InnerNode* parent, const QString& name, SubType subType);

    virtual ~FakeNode() { }

    void setTitle(const QString &title) { tle = title; }

    void setSubTitle(const QString &subTitle) { stle = subTitle; }

    void addGroupMember(Node* node) { gr.append(node); }

    SubType subType() const { return sub; }

    virtual QString title() const;

    virtual QString fullTitle() const;

    virtual QString subTitle() const;

    const NodeList &groupMembers() const { return gr; }

    virtual QString nameForLists() const { return title(); }

 private:

    SubType sub;

    QString tle;

    QString stle;

    NodeList gr;

};

#ifdef QDOC_QML

class QmlClassNode : public FakeNode

{

 public:

    QmlClassNode(InnerNode* parent, 

                 const QString& name, 

                 const ClassNode* cn);

    virtual ~QmlClassNode();

    virtual bool isQmlNode() const { return true; }

    const ClassNode* classNode() const { return cnode; }

    virtual QString fileBase() const;

    static void addInheritedBy(const QString& base, Node* sub);

    static void subclasses(const QString& base, NodeList& subs);

    static void clear();

 public:

    static bool qmlOnly;

    static QMultiMap<QString,Node*> inheritedBy;

 private:

    const ClassNode*    cnode;

};

class QmlBasicTypeNode : public FakeNode

{

 public:

    QmlBasicTypeNode(InnerNode* parent, 

                     const QString& name);

    virtual ~QmlBasicTypeNode() { }

    virtual bool isQmlNode() const { return true; }

};

class QmlPropGroupNode : public FakeNode

{

 public:

    QmlPropGroupNode(QmlClassNode* parent, 

                     const QString& name,

                     bool attached);

    virtual ~QmlPropGroupNode() { }

    virtual bool isQmlNode() const { return true; }

    const QString& element() const { return parent()->name(); }

    void setDefault() { isdefault = true; }

    bool isDefault() const { return isdefault; }

    bool isAttached() const { return att; }

 private:

    bool    isdefault;

    bool    att;

};

class Tree;

class QmlPropertyNode : public LeafNode

{

 public:

    QmlPropertyNode(QmlPropGroupNode* parent, 

                    const QString& name,

                    const QString& type,

                    bool attached);

    virtual ~QmlPropertyNode() { }

    void setDataType(const QString& dataType) { dt = dataType; }

    void setStored(bool stored) { sto = toTrool(stored); }

    void setDesignable(bool designable) { des = toTrool(designable); }

    void setWritable(bool writable) { wri = toTrool(writable); }

    const QString &dataType() const { return dt; }

    QString qualifiedDataType() const { return dt; }

    bool isStored() const { return fromTrool(sto,true); }

    bool isDesignable() const { return fromTrool(des,false); }

    bool isWritable(const Tree* tree) const;

    bool isAttached() const { return att; }

    virtual bool isQmlNode() const { return true; }

    const QString& element() const { return static_cast<QmlPropGroupNode*>(parent())->element(); }

 private:

    enum Trool { Trool_True, Trool_False, Trool_Default };

    static Trool toTrool(bool boolean);

    static bool fromTrool(Trool troolean, bool defaultValue);

    QString dt;

    Trool   sto;

    Trool   des;

    Trool   wri;

    bool    att;

};

#endif

class EnumItem

{

 public:

    EnumItem() { }

    EnumItem(const QString& name, const QString& value)

	: nam(name), val(value) { }

    EnumItem(const QString& name, const QString& value, const Text &txt)

	: nam(name), val(value), txt(txt) { }

    const QString& name() const { return nam; }

    const QString& value() const { return val; }

    const Text &text() const { return txt; }

 private:

    QString nam;

    QString val;

    Text txt;

};

class TypedefNode;

class EnumNode : public LeafNode

{

 public:

    EnumNode(InnerNode* parent, const QString& name);

    virtual ~EnumNode() { }

    void addItem(const EnumItem& item);

    void setFlagsType(TypedefNode* typedeff);