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

 *

 * 

 *

 * Copyright (C) 1997-2015 by Dimitri van Heesch.

 *

 * Permission to use, copy, modify, and distribute this software and its

 * documentation under the terms of the GNU General Public License is hereby 

 * granted. No representations are made about the suitability of this software 

 * for any purpose. It is provided "as is" without express or implied warranty.

 * See the GNU General Public License for more details.

 *

 * Documents produced by Doxygen are derivative works derived from the

 * input used in their production; they are not affected by this license.

 *

 */

#ifndef CLASSDEF_H

#define CLASSDEF_H

#include <qlist.h>

#include <qdict.h>

#include <qptrdict.h>

#include "definition.h"

struct Argument;

class MemberDef;

class MemberList;

class MemberDict;

class ClassList;

class ClassSDict;

class OutputList;

class FileDef;

class FileList;

class BaseClassList;

class NamespaceDef;

class MemberDef;

class ExampleSDict;

class MemberNameInfoSDict;

class UsesClassDict;

class ConstraintClassDict;

class MemberGroupSDict;

class QTextStream;

class PackageDef;

class GroupDef;

class StringDict;

struct IncludeInfo;

class ClassDefImpl;

class ArgumentList;

class FTextStream;

/** A class representing of a compound symbol.

 *

 *  A compound can be a class, struct, union, interface, service, singleton,

 *  or exception.

 *  \note This class should be renamed to CompoundDef

 */

class ClassDef : public Definition

{

  public:

    /** The various compound types */

    enum CompoundType { Class,     //=Entry::CLASS_SEC, 

                        Struct,    //=Entry::STRUCT_SEC, 

                        Union,     //=Entry::UNION_SEC,

                        Interface, //=Entry::INTERFACE_SEC,

                        Protocol,  //=Entry::PROTOCOL_SEC,

                        Category,  //=Entry::CATEGORY_SEC,

                        Exception, //=Entry::EXCEPTION_SEC

                        Service,   //=Entry::CLASS_SEC

                        Singleton, //=Entry::CLASS_SEC

                      };

    /** Creates a new compound definition.

     *  \param fileName  full path and file name in which this compound was

     *                   found.

     *  \param startLine line number where the definition of this compound

     *                   starts.

     *  \param startColumn column number where the definition of this compound

     *                   starts.

     *  \param name      the name of this compound (including scope)

     *  \param ct        the kind of Compound

     *  \param ref       the tag file from which this compound is extracted

     *                   or 0 if the compound doesn't come from a tag file

     *  \param fName     the file name as found in the tag file. 

     *                   This overwrites the file that doxygen normally 

     *                   generates based on the compound type & name.

     *  \param isSymbol  If TRUE this class name is added as a publicly 

     *                   visible (and referencable) symbol.

     *  \param isJavaEnum If TRUE this class is actually a Java enum.

     *                    I didn't add this to CompoundType to avoid having

     *                    to adapt all translators.

     */

    ClassDef(const char *fileName,int startLine,int startColumn,

             const char *name,CompoundType ct,

             const char *ref=0,const char *fName=0,

             bool isSymbol=TRUE,bool isJavaEnum=FALSE);

    /** Destroys a compound definition. */

   ~ClassDef();

    //-----------------------------------------------------------------------------------

    // --- getters 

    //-----------------------------------------------------------------------------------

    /** Used for RTTI, this is a class */

    DefType definitionType() const { return TypeClass; }

    /** Returns the unique base name (without extension) of the class's file on disk */

    QCString getOutputFileBase() const;

    QCString getInstanceOutputFileBase() const; 

    /** Returns the base name for the source code file */

    QCString getSourceFileBase() const; 

    /** If this class originated from a tagfile, this will return the tag file reference */

    QCString getReference() const;

    /** Returns TRUE if this class is imported via a tag file */

    bool isReference() const;

    /** Returns TRUE if this is a local class definition, see EXTRACT_LOCAL_CLASSES */

    bool isLocal() const;

    /** returns the classes nested into this class */

    ClassSDict *getClassSDict() const;

    /** returns TRUE if this class has documentation */

    bool hasDocumentation() const;

    /** returns TRUE if this class has a non-empty detailed description */

    bool hasDetailedDescription() const;

    /** returns the file name to use for the collaboration graph */

    QCString collaborationGraphFileName() const;

    /** returns the file name to use for the inheritance graph */

    QCString inheritanceGraphFileName() const;

    /** Returns the name as it is appears in the documentation */

    QCString displayName(bool includeScope=TRUE) const;

    /** Returns the type of compound this is, i.e. class/struct/union/.. */

    CompoundType compoundType() const;

    /** Returns the type of compound as a string */

    QCString compoundTypeString() const;

    /** Returns the list of base classes from which this class directly

     *  inherits.

     */

    BaseClassList *baseClasses() const;

    /** Returns the list of sub classes that directly derive from this class

     */

    BaseClassList *subClasses() const;

    /** Returns a dictionary of all members. This includes any inherited 

     *  members. Members are sorted alphabetically.

     */ 

    MemberNameInfoSDict *memberNameInfoSDict() const;

    /** Return the protection level (Public,Protected,Private) in which 

     *  this compound was found.

     */

    Protection protection() const;

    /** returns TRUE iff a link is possible to this item within this project.

     */

    bool isLinkableInProject() const;

    /** return TRUE iff a link to this class is possible (either within 

     *  this project, or as a cross-reference to another project).

     */

    bool isLinkable() const;

    /** the class is visible in a class diagram, or class hierarchy */

    bool isVisibleInHierarchy();

    /** show this class in the declaration section of its parent? */

    bool visibleInParentsDeclList() const;

    /** Returns the template arguments of this class 

     *  Will return 0 if not applicable.

     */

    ArgumentList *templateArguments() const;

    /** Returns the namespace this compound is in, or 0 if it has a global

     *  scope.

     */

    NamespaceDef *getNamespaceDef() const;

    /** Returns the file in which this compound's definition can be found.

     *  Should not return 0 (but it might be a good idea to check anyway).

     */

    FileDef      *getFileDef() const;

    /** Returns the Java package this class is in or 0 if not applicable. 

     */ 

    MemberDef    *getMemberByName(const QCString &) const;

    /** Returns TRUE iff \a bcd is a direct or indirect base class of this

     *  class. This function will recusively traverse all branches of the

     *  inheritance tree.

     */

    bool isBaseClass(ClassDef *bcd,bool followInstances,int level=0);

    /** Returns TRUE iff \a bcd is a direct or indirect sub class of this

     *  class.

     */

    bool isSubClass(ClassDef *bcd,int level=0);

    /** returns TRUE iff \a md is a member of this class or of the

     *  the public/protected members of a base class 

     */

    bool isAccessibleMember(MemberDef *md);

    /** Returns a sorted dictionary with all template instances found for

     *  this template class. Returns 0 if not a template or no instances.

     */

    QDict<ClassDef> *getTemplateInstances() const;

    /** Returns the template master of which this class is an instance.

     *  Returns 0 if not applicable.

     */

    ClassDef *templateMaster() const;

    /** Returns TRUE if this class is a template */

    bool isTemplate() const;

    IncludeInfo *includeInfo() const;

    UsesClassDict *usedImplementationClasses() const;

    UsesClassDict *usedByImplementationClasses() const;

    UsesClassDict *usedInterfaceClasses() const;

    ConstraintClassDict *templateTypeConstraints() const;

    bool isTemplateArgument() const;

    /** Returns the definition of a nested compound if

     *  available, or 0 otherwise.

     *  @param name The name of the nested compound

     */

    virtual Definition *findInnerCompound(const char *name) const;

    /** Returns the template parameter lists that form the template

     *  declaration of this class.

     *  

     *  Example: template<class T> class TC {};

     *  will return a list with one ArgumentList containing one argument

     *  with type="class" and name="T".

     */

    void getTemplateParameterLists(QList<ArgumentList> &lists) const;

    QCString qualifiedNameWithTemplateParameters(

        QList<ArgumentList> *actualParams=0,int *actualParamIndex=0) const;

    /** Returns TRUE if there is at least one pure virtual member in this

     *  class.

     */

    bool isAbstract() const;

    /** Returns TRUE if this class is implemented in Objective-C */

    bool isObjectiveC() const;

    /** Returns TRUE if this class is implemented in C# */

    bool isCSharp() const;

    /** Returns TRUE if this class is marked as final */

    bool isFinal() const;

    /** Returns TRUE if this class is marked as sealed */

    bool isSealed() const;

    /** Returns TRUE if this class is marked as published */

    bool isPublished() const;

    /** Returns TRUE if this class represents an Objective-C 2.0 extension (nameless category) */

    bool isExtension() const;

    /** Returns TRUE if this class represents a forward declaration of a template class */

    bool isForwardDeclared() const;

    /** Returns the class of which this is a category (Objective-C only) */

    ClassDef *categoryOf() const;

    /** Returns the name of the class including outer classes, but not

     *  including namespaces.

     */

    QCString className() const;

    /** Returns the members in the list identified by \a lt */

    MemberList *getMemberList(MemberListType lt);

    /** Returns the list containing the list of members sorted per type */

    const QList<MemberList> &getMemberLists() const;

    /** Returns the member groups defined for this class */

    MemberGroupSDict *getMemberGroupSDict() const;

    QDict<int> *getTemplateBaseClassNames() const;

    ClassDef *getVariableInstance(const char *templSpec);

    bool isUsedOnly() const;

    QCString anchor() const;

    bool isEmbeddedInOuterScope() const;

    bool isSimple() const;

    const ClassList *taggedInnerClasses() const;

    ClassDef *tagLessReference() const;

    MemberDef *isSmartPointer() const;

    bool isJavaEnum() const;

    bool isGeneric() const;

    bool isAnonymous() const;

    const ClassSDict *innerClasses() const;

    QCString title() const;

    QCString generatedFromFiles() const;

    const FileList &usedFiles() const;

    const ArgumentList *typeConstraints() const;

    const ExampleSDict *exampleList() const;

    bool hasExamples() const;

    QCString getMemberListFileName() const;

    bool subGrouping() const;

    //-----------------------------------------------------------------------------------

    // --- setters ----

    //-----------------------------------------------------------------------------------

    void insertBaseClass(ClassDef *,const char *name,Protection p,Specifier s,const char *t=0);

    void insertSubClass(ClassDef *,Protection p,Specifier s,const char *t=0);

    void setIncludeFile(FileDef *fd,const char *incName,bool local,bool force); 

    void insertMember(MemberDef *);

    void insertUsedFile(FileDef *);

    bool addExample(const char *anchor,const char *name, const char *file);

    void mergeCategory(ClassDef *category);

    void setNamespace(NamespaceDef *nd);

    void setFileDef(FileDef *fd);

    void setSubGrouping(bool enabled);

    void setProtection(Protection p);

    void setGroupDefForAllMembers(GroupDef *g,Grouping::GroupPri_t pri,const QCString &fileName,int startLine,bool hasDocs);

    void addInnerCompound(Definition *d);

    ClassDef *insertTemplateInstance(const QCString &fileName,int startLine,int startColumn,

                                const QCString &templSpec,bool &freshInstance);

    void addUsedClass(ClassDef *cd,const char *accessName,Protection prot);

    void addUsedByClass(ClassDef *cd,const char *accessName,Protection prot);

    void setIsStatic(bool b);

    void setCompoundType(CompoundType t);

    void setClassName(const char *name);

    void setClassSpecifier(uint64 spec);

    void setTemplateArguments(ArgumentList *al);

    void setTemplateBaseClassNames(QDict<int> *templateNames);

    void setTemplateMaster(ClassDef *tm);

    void setTypeConstraints(ArgumentList *al);

    void addMembersToTemplateInstance(ClassDef *cd,const char *templSpec);

    void makeTemplateArgument(bool b=TRUE);

    void setCategoryOf(ClassDef *cd);

    void setUsedOnly(bool b);

    void addTaggedInnerClass(ClassDef *cd);

    void setTagLessReference(ClassDef *cd);

    void setName(const char *name);

    //-----------------------------------------------------------------------------------

    // --- actions ----

    //-----------------------------------------------------------------------------------

    void findSectionsInDocumentation();

    void addMembersToMemberGroup();

    void addListReferences();

    void addTypeConstraints();

    void computeAnchors();

    void mergeMembers();

    void sortMemberLists();

    void distributeMemberGroupDocumentation();

    void writeDocumentation(OutputList &ol);

    void writeDocumentationForInnerClasses(OutputList &ol);

    void writeMemberPages(OutputList &ol);

    void writeMemberList(OutputList &ol);

    void writeDeclaration(OutputList &ol,MemberDef *md,bool inGroup,

                          ClassDef *inheritedFrom,const char *inheritId);

    void writeQuickMemberLinks(OutputList &ol,MemberDef *md) const;

    void writeSummaryLinks(OutputList &ol);

    void reclassifyMember(MemberDef *md,MemberType t);

    void writeInlineDocumentation(OutputList &ol);

    void writeDeclarationLink(OutputList &ol,bool &found,

                              const char *header,bool localNames);

    void removeMemberFromLists(MemberDef *md);

    void addGroupedInheritedMembers(OutputList &ol,MemberListType lt,

                              ClassDef *inheritedFrom,const QCString &inheritId);

    int countMembersIncludingGrouped(MemberListType lt,ClassDef *inheritedFrom,bool additional);

    int countInheritanceNodes();

    void writeTagFile(FTextStream &);

    bool visited;

  protected:

    void addUsedInterfaceClasses(MemberDef *md,const char *typeStr);

    bool hasNonReferenceSuperClass();

    void showUsedFiles(OutputList &ol);

  private: 

    void writeDocumentationContents(OutputList &ol,const QCString &pageTitle);

    void internalInsertMember(MemberDef *md,Protection prot,bool addToAllList);

    void addMemberToList(MemberListType lt,MemberDef *md,bool isBrief);

    MemberList *createMemberList(MemberListType lt);

    void writeInheritedMemberDeclarations(OutputList &ol,MemberListType lt,int lt2,const QCString &title,ClassDef *inheritedFrom,bool invert,bool showAlways,QPtrDict<void> *visitedClasses);

    void writeMemberDeclarations(OutputList &ol,MemberListType lt,const QCString &title,

                                 const char *subTitle=0,bool showInline=FALSE,ClassDef *inheritedFrom=0,int lt2=-1,bool invert=FALSE,bool showAlways=FALSE,QPtrDict<void> *visitedClasses=0);

    void writeMemberDocumentation(OutputList &ol,MemberListType lt,const QCString &title,bool showInline=FALSE);

    void writeSimpleMemberDocumentation(OutputList &ol,MemberListType lt);

    void writePlainMemberDeclaration(OutputList &ol,MemberListType lt,bool inGroup,ClassDef *inheritedFrom,const char *inheritId);

    void writeBriefDescription(OutputList &ol,bool exampleFlag);

    void writeDetailedDescription(OutputList &ol,const QCString &pageType,bool exampleFlag,

                                  const QCString &title,const QCString &anchor=QCString());

    void writeIncludeFiles(OutputList &ol);

    //void writeAllMembersLink(OutputList &ol);

    void writeInheritanceGraph(OutputList &ol);

    void writeCollaborationGraph(OutputList &ol);

    void writeMemberGroups(OutputList &ol,bool showInline=FALSE);

    void writeNestedClasses(OutputList &ol,const QCString &title);

    void writeInlineClasses(OutputList &ol);

    void startMemberDeclarations(OutputList &ol);

    void endMemberDeclarations(OutputList &ol);

    void startMemberDocumentation(OutputList &ol);

    void endMemberDocumentation(OutputList &ol);

    void writeAuthorSection(OutputList &ol);

    void writeMoreLink(OutputList &ol,const QCString &anchor);

    void writeDetailedDocumentationBody(OutputList &ol);

    int countAdditionalInheritedMembers();

    void writeAdditionalInheritedMembers(OutputList &ol);

    void addClassAttributes(OutputList &ol);

    int countMemberDeclarations(MemberListType lt,ClassDef *inheritedFrom,

                                int lt2,bool invert,bool showAlways,QPtrDict<void> *visitedClasses);

    int countInheritedDecMembers(MemberListType lt,

                                 ClassDef *inheritedFrom,bool invert,bool showAlways,

                                 QPtrDict<void> *visitedClasses);

    void getTitleForMemberListType(MemberListType type,

               QCString &title,QCString &subtitle);

    QCString includeStatement() const;

    void addTypeConstraint(const QCString &typeConstraint,const QCString &type);

    ClassDefImpl *m_impl;

};

//------------------------------------------------------------------------

/** Class that contains information about a usage relation. 

 */

struct UsesClassDef

{

  UsesClassDef(ClassDef *cd) : classDef(cd) 

  { 

    accessors = new QDict<void>(17); 

    containment = TRUE;

  }

 ~UsesClassDef()

  {

    delete accessors;

  }

  void addAccessor(const char *s)

  {

    if (accessors->find(s)==0)

    {

      accessors->insert(s,(void *)666);

    }

  }

  /** Class definition that this relation uses. */

  ClassDef *classDef;

  /** Dictionary of member variable names that form the edge labels of the

   *  usage relation.

   */

  QDict<void> *accessors;

  /** Template arguments used for the base class */

  QCString templSpecifiers;

  bool containment;

};

/** Dictionary of usage relations. 

 */

class UsesClassDict : public QDict<UsesClassDef>

{

  public:

    UsesClassDict(int size) : QDict<UsesClassDef>(size) {}

   ~UsesClassDict() {}

};

/** Iterator class to iterate over a dictionary of usage relations. 

 */

class UsesClassDictIterator : public QDictIterator<UsesClassDef>

{

  public:

    UsesClassDictIterator(const QDict<UsesClassDef> &d) 

      : QDictIterator<UsesClassDef>(d) {}

   ~UsesClassDictIterator() {}

};

//------------------------------------------------------------------------

/** Class that contains information about an inheritance relation. 

 */

struct BaseClassDef

{

  BaseClassDef(ClassDef *cd,const char *n,Protection p,

               Specifier v,const char *t) : 

        classDef(cd), usedName(n), prot(p), virt(v), templSpecifiers(t) {}

  /** Class definition that this relation inherits from. */

  ClassDef *classDef;

  /** name used in the inheritance list 

   * (may be a typedef name instead of the class name)

   */

  QCString   usedName; 

  /** Protection level of the inheritance relation: 

   *  Public, Protected, or Private 

   */

  Protection prot;     

  /** Virtualness of the inheritance relation:

   *  Normal, or Virtual

   */

  Specifier  virt;

  /** Template arguments used for the base class */

  QCString templSpecifiers;

};

/** List of base classes.

 *  

 *  The classes are alphabetically sorted on name if inSort() is used.

 */

class BaseClassList : public QList<BaseClassDef>

{

  public:

   ~BaseClassList() {}

    int compareValues(const BaseClassDef *item1,const BaseClassDef *item2) const

    {

      const ClassDef *c1=item1->classDef;

      const ClassDef *c2=item2->classDef;

      if (c1==0 || c2==0)

        return FALSE;

      else

        return qstricmp(c1->name(),c2->name());

    }

};

/** Iterator for a list of base classes.

 */

class BaseClassListIterator : public QListIterator<BaseClassDef>

{

  public:

    BaseClassListIterator(const BaseClassList &bcl) : 

      QListIterator<BaseClassDef>(bcl) {}

};

//------------------------------------------------------------------------

/** Class that contains information about a type constraint relations.

 */

struct ConstraintClassDef

{

  ConstraintClassDef(ClassDef *cd) : classDef(cd)

  {

    accessors = new QDict<void>(17);

  }

 ~ConstraintClassDef()

  {

    delete accessors;

  }

  void addAccessor(const char *s)

  {

    if (accessors->find(s)==0)

    {

      accessors->insert(s,(void *)666);

    }

  }

  /** Class definition that this relation uses. */

  ClassDef *classDef;

  /** Dictionary of member types names that form the edge labels of the

   *  constraint relation.

   */

  QDict<void> *accessors;

};

/** Dictionary of constraint relations.

 */

class ConstraintClassDict : public QDict<ConstraintClassDef>

{

  public:

    ConstraintClassDict(int size) : QDict<ConstraintClassDef>(size) {}

   ~ConstraintClassDict() {}

};

/** Iterator class to iterate over a dictionary of constraint relations.

 */

class ConstraintClassDictIterator : public QDictIterator<ConstraintClassDef>

{

  public:

    ConstraintClassDictIterator(const QDict<ConstraintClassDef> &d)

      : QDictIterator<ConstraintClassDef>(d) {}

   ~ConstraintClassDictIterator() {}

};

//------------------------------------------------------------------------

#endif