--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Orb/Doxygen/src/classdef.h Fri Apr 23 20:47:58 2010 +0100
@@ -0,0 +1,465 @@
+/******************************************************************************
+ *
+ *
+ *
+ * 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 <qlist.h>
+#include <qdict.h>
+#include <qstrlist.h>
+
+//#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<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;
+
+ 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: <code>template<class T> class TC {};</code>
+ * 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) 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<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;
+
+ bool hasFunction(const QCString &theDef, Protection prot);
+ //-----------------------------------------------------------------------------------
+ // --- 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<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);
+
+ //-----------------------------------------------------------------------------------
+ // --- 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);
+ bool hasFunction(MemberList::ListType lt, const QCString &theDef);
+
+ 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<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;
+};
+
+/*! \brief Dictionary of usage relations.
+ */
+class UsesClassDict : public QDict<UsesClassDef>
+{
+ public:
+ UsesClassDict(int size) : QDict<UsesClassDef>(size) {}
+ ~UsesClassDict() {}
+};
+
+/*! \brief 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() {}
+};
+
+/*! \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<BaseClassDef>
+{
+ 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<BaseClassDef>
+{
+ public:
+ BaseClassListIterator(const BaseClassList &bcl) :
+ QListIterator<BaseClassDef>(bcl) {}
+};
+
+#endif