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

**

** 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"

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

#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 */ 

    };

    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; }

    virtual bool isInnerNode() const = 0;

    virtual bool isReimp() const { return false; }

    virtual bool isFunction() 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; }

    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; }

    void clearRelated() { rel = 0; }

    virtual QString fileBase() const;

 protected:

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

 private:

#ifdef Q_WS_WIN

    Type typ;

    Access acc;

    Status sta;

    ThreadSafeness saf;

#else

    Type typ : 4;

    Access acc : 2;

    Status sta : 3;

    ThreadSafeness saf : 2;

#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;

};

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

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

    Node::Access        access;

    ClassNode*          node;

    QString             dataTypeWithTemplateArgs;

};

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 bas; }

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

    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; }

 private:

    QList<RelatedClass> bas;

    QList<RelatedClass> der;

    bool hidden;

    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; }

    QString title() const { return tle; }

    QString fullTitle() const;

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

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

    virtual QString fileBase() const;

    static bool qmlOnly;

 private:

    const ClassNode* cnode;

};

class QmlPropGroupNode : public FakeNode

{

 public:

    QmlPropGroupNode(QmlClassNode* parent, 

                     const QString& name,

                     bool attached);

    virtual ~QmlPropGroupNode() { }

    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 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 { return fromTrool(wri,true); }

    bool isAttached() const { return att; }

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

    bool hasItem(const QString &name) const { return names.contains(name); }

    const QList<EnumItem>& items() const { return itms; }

    Access itemAccess(const QString& name) const;

    const TypedefNode *flagsType() const { return ft; }

    QString itemValue(const QString &name) const;

 private:

    QList<EnumItem> itms;

    QSet<QString> names;

    const TypedefNode *ft;

};

class TypedefNode : public LeafNode

{

 public:

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

    virtual ~TypedefNode() { }

    const EnumNode *associatedEnum() const { return ae; }

 private:

    void setAssociatedEnum(const EnumNode *enume);

    friend class EnumNode;

    const EnumNode *ae;

};

inline void EnumNode::setFlagsType(TypedefNode *typedeff)

{

    ft = typedeff;

    typedeff->setAssociatedEnum(this);

}

class Parameter

{

 public:

    Parameter() {}

    Parameter(const QString& leftType, 

              const QString& rightType = "",

              const QString& name = "", 

              const QString& defaultValue = "");

    Parameter(const Parameter& p);

    Parameter& operator=(const Parameter& p);

    void setName(const QString& name) { nam = name; }

    bool hasType() const { return lef.length() + rig.length() > 0; }

    const QString& leftType() const { return lef; }

    const QString& rightType() const { return rig; }

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

    const QString& defaultValue() const { return def; }

    QString reconstruct(bool value = false) const;

 private:

    QString lef;

    QString rig;

    QString nam;

    QString def;

};

class PropertyNode;