classdef.h

Go to the documentation of this file.

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

class ClassDef : public Definition
{
  public:
    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
                      };

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

    //-----------------------------------------------------------------------------------
    // --- getters 
    //-----------------------------------------------------------------------------------

    DefType definitionType() const { return TypeClass; }

    QCString getOutputFileBase() const;
    QCString getInstanceOutputFileBase() const; 

    QCString getSourceFileBase() const; 

    QCString getReference() const;

    bool isReference() const;

    bool isLocal() const;

    ClassSDict *getClassSDict();

    bool hasDocumentation() const;

    bool hasDetailedDescription() const;
    
    QCString collaborationGraphFileName() const;

    QCString inheritanceGraphFileName() const;

    QCString displayName(bool includeScope=TRUE) const;

    CompoundType compoundType() const;

    QCString compoundTypeString() const;

    BaseClassList *baseClasses() const;
    
    BaseClassList *subClasses() const;

    MemberNameInfoSDict *memberNameInfoSDict() const;

    Protection protection() const;

    bool isLinkableInProject() const;

    bool isLinkable() const;

    bool isVisibleInHierarchy();
    
    bool visibleInParentsDeclList() const;

    ArgumentList *templateArguments() const;

    NamespaceDef *getNamespaceDef() const;

    FileDef      *getFileDef() const;

    MemberDef    *getMemberByName(const QCString &) const;
    
    bool isBaseClass(ClassDef *bcd,bool followInstances,int level=0);

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

    bool isAccessibleMember(MemberDef *md);

    QDict<ClassDef> *getTemplateInstances() const;

    ClassDef *templateMaster() const;

    bool isTemplate() const;

    IncludeInfo *includeInfo() const;
    
    UsesClassDict *usedImplementationClasses() const;

    UsesClassDict *usedByImplementationClasses() const;

    UsesClassDict *usedInterfaceClasses() const;

    ConstraintClassDict *templateTypeConstraints() const;

    bool isTemplateArgument() const;

    virtual Definition *findInnerCompound(const char *name);

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

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

    bool isAbstract() const;

    bool isObjectiveC() const;

    bool isCSharp() const;

    bool isFinal() const;

    bool isSealed() const;

    bool isPublished() const;

    bool isExtension() const;

    bool isForwardDeclared() const;

    ClassDef *categoryOf() const;

    QCString className() const;

    MemberList *getMemberList(MemberListType lt);

    const QList<MemberList> &getMemberLists() const;

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

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

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);
    }
  }
  ClassDef *classDef;

  QDict<void> *accessors;

  QCString templSpecifiers;

  bool containment;
};

class UsesClassDict : public QDict<UsesClassDef>
{
  public:
    UsesClassDict(int size) : QDict<UsesClassDef>(size) {}
   ~UsesClassDict() {}
};

class UsesClassDictIterator : public QDictIterator<UsesClassDef>
{
  public:
    UsesClassDictIterator(const QDict<UsesClassDef> &d) 
      : QDictIterator<UsesClassDef>(d) {}
   ~UsesClassDictIterator() {}
};

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

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

  ClassDef *classDef;

  QCString   usedName; 
  
  Protection prot;     

  Specifier  virt;

  QCString templSpecifiers;
};

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

class BaseClassListIterator : public QListIterator<BaseClassDef>
{
  public:
    BaseClassListIterator(const BaseClassList &bcl) : 
      QListIterator<BaseClassDef>(bcl) {}
};

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


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);
    }
  }
  ClassDef *classDef;

  QDict<void> *accessors;
};

class ConstraintClassDict : public QDict<ConstraintClassDef>
{
  public:
    ConstraintClassDict(int size) : QDict<ConstraintClassDef>(size) {}
   ~ConstraintClassDict() {}
};

class ConstraintClassDictIterator : public QDictIterator<ConstraintClassDef>
{
  public:
    ConstraintClassDictIterator(const QDict<ConstraintClassDef> &d)
      : QDictIterator<ConstraintClassDef>(d) {}
   ~ConstraintClassDictIterator() {}
};

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

#endif