/****************************************************************************** * * * * Copyright (C) 1997-2008 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 "qtbc.h" #include #include #include //#include "entry.h" #include "memberlist.h" #include "definition.h" #include "sortdict.h" class MemberDict; class ClassList; class ClassSDict; class OutputList; class FileDef; class BaseClassList; class NamespaceDef; class MemberDef; class ExampleSDict; class MemberNameInfoSDict; class UsesClassDict; class MemberGroupSDict; class QTextStream; class PackageDef; class GroupDef; class StringDict; struct IncludeInfo; class ClassDefImpl; /*! \brief This class contains all information about a compound. * * A compound can be a class, struct, union, interface, 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 }; /*! 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 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. */ ClassDef(const char *fileName,int startLine, const char *name,CompoundType ct, const char *ref=0,const char *fName=0, bool isSymbol=TRUE); /*! 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; QCString getFileBase() 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 *getInnerClasses(); /*! returns TRUE if this class has documentation */ bool hasDocumentation() const; /*! Returns the name as it is appears in the documentation */ QCString displayName() 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(); /*! 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 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 *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; 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); /*! Returns the template parameter lists that form the template * declaration of this class. * * Example: template class TC {}; * will return a list with one ArgumentList containing one argument * with type="class" and name="T". */ void getTemplateParameterLists(QList &lists) const; QCString qualifiedNameWithTemplateParameters( QList *actualParams=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 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(MemberList::ListType lt); /*! Returns the list containing the list of members sorted per type */ const QList &getMemberLists() const; /*! Returns the member groups defined for this class */ MemberGroupSDict *getMemberGroupSDict() const; QDict *getTemplateBaseClassNames() const; ClassDef *getVariableInstance(const char *templSpec); bool isUsedOnly() 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(const char *); 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, const QCString &templSpec,bool &freshInstance); void addUsedClass(ClassDef *cd,const char *accessName); void addUsedByClass(ClassDef *cd,const char *accessName); void setIsStatic(bool b); void setIsObjectiveC(bool b); void setCompoundType(CompoundType t); void setClassName(const char *name); void setTemplateArguments(ArgumentList *al); void setTemplateBaseClassNames(QDict *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); //----------------------------------------------------------------------------------- // --- actions ---- //----------------------------------------------------------------------------------- void findSectionsInDocumentation(); void addMembersToMemberGroup(); void addListReferences(); void computeAnchors(); void mergeMembers(); 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); void writeQuickMemberLinks(OutputList &ol,MemberDef *md) const; void reclassifyMember(MemberDef *md,MemberDef::MemberType t); bool visited; protected: void addUsedInterfaceClasses(MemberDef *md,const char *typeStr); bool hasExamples(); bool hasNonReferenceSuperClass(); void showUsedFiles(OutputList &ol); private: void internalInsertMember(MemberDef *md,Protection prot,bool addToAllList); QCString getMemberListFileName() const; void addMemberToList(MemberList::ListType lt,MemberDef *md,bool isBrief); MemberList *createMemberList(MemberList::ListType lt); void writeMemberDeclarations(OutputList &ol,MemberList::ListType lt,const QCString &title, const char *subTitle=0); void writeMemberDocumentation(OutputList &ol,MemberList::ListType lt,const QCString &title); void writePlainMemberDeclaration(OutputList &ol,MemberList::ListType lt,bool inGroup); void writeBriefDescription(OutputList &ol,bool exampleFlag); void writeDetailedDescription(OutputList &ol,const QCString &pageType,bool exampleFlag, const QCString &title); void writeIncludeFiles(OutputList &ol); void writeAllMembersLink(OutputList &ol); void writeInheritanceGraph(OutputList &ol); void writeCollaborationGraph(OutputList &ol); void writeMemberGroups(OutputList &ol); void writeNestedClasses(OutputList &ol,const QCString &title); void startMemberDeclarations(OutputList &ol); void endMemberDeclarations(OutputList &ol); void startMemberDocumentation(OutputList &ol); void endMemberDocumentation(OutputList &ol); void writeAuthorSection(OutputList &ol); ClassDefImpl *m_impl; }; /*! \brief Class that contains information about a usage relation. */ struct UsesClassDef { UsesClassDef(ClassDef *cd) : classDef(cd) { accessors = new QDict(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 *accessors; /*! Template arguments used for the base class */ QCString templSpecifiers; bool containment; }; /*! \brief Dictionary of usage relations. */ class UsesClassDict : public QDict { public: UsesClassDict(int size) : QDict(size) {} ~UsesClassDict() {} }; /*! \brief Iterator class to iterate over a dictionary of usage relations. */ class UsesClassDictIterator : public QDictIterator { public: UsesClassDictIterator(const QDict &d) : QDictIterator(d) {} ~UsesClassDictIterator() {} }; /*! \brief 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; }; /*! \brief list of base classes * * The classes are alphabetically sorted on name if inSort() is used. */ class BaseClassList : public QList { public: ~BaseClassList() {} int compareItems(GCI item1,GCI item2) { ClassDef *c1=((BaseClassDef *)item1)->classDef; ClassDef *c2=((BaseClassDef *)item2)->classDef; if (c1==0 || c2==0) return FALSE; else return stricmp(c1->name(),c2->name()); } }; /*! \brief Iterator for a list of base classes */ class BaseClassListIterator : public QListIterator { public: BaseClassListIterator(const BaseClassList &bcl) : QListIterator(bcl) {} }; #endif